Pedale 3D sketch

Pedale 3D sketch è dedicato alla realizzazione del codice, sketch, per Arduino che ti permette di utilizzare il pedale con diverse applicazioni.

se hai letto i precedenti articoli dedicati a questo progetto sai che il pedale è nato per essere utilizzto in ambiti differenti, come descritto nel primo articolo:

Pedale 3D Arduino

e che sono partito da un progetto condiviso su thingiverse applicando delle modifiche che mi hanno permesso di personalizzarlo già nella parte 3D:

Pedale 3D modifiche

a cui ho aggiunto la parte elettronica:

Pedale 3D Arduino schema e collegamenti

realizzata con Arduino pro mini, due pulsanti, un potenziometro, un mosfet, due led ed il circuito DC-DC step down per l’alimentazione della board.

In questo articolo leggerai come ho realizzato lo sketch e a cosa serve il codice arduino per adattare il pedale alle tue esigenze.

Pedale 3D sketch

Per consentire al pedale di essere facilmente adattato a qualsiasi progetto ho deciso di rendere semplice il suo funzionamento.

In pratica la tensione di ingresso viene modulata in base alla pressione del pedale dalla sua intensità minima alla massima, consentendoti di utilizzare il pedale con tensioni da 4 a 24v.

Il regolatore di tensione dc-dc step down accetta in ingresso il range di tensione da 4 a 24v ed in output è costante con i 5v in modo da poter alimentare senza problemi l’arduino.

Il mosfet, al contrario, modula la tensione di output in base all’input proveniente dal pin PWM di Arduino.

Lo schema dei collegamenti è il seguente:

come hai avuto modo di leggere nell’articolo dedicato a questa parte del progetto.

Passiamo allo sketch del pedale

Concettualmente è semplice la pressione del piede sul pedale trasferisce al potenziometro la rotazione proporzionale.

Arduino legge il valore del potenziometro e modula il segnale Pwm in uscita in base al valore letto.

La parte più complessa riguarda la taratura del pedale che ti serve in diversi casi:

correggere le anomalie meccaniche dovute all’uso del pedale;

impostare i valori minimo e massimo di escursione;

regolare il range in funzione dell’applicazione che intendi realizzare;

per ottenere questo ho deciso di avvalermi della libreria EEPROM in cui memorizzare i due valori ( min e max ) registrati dal potenziometro;

due pulsanti per definire la modalità di registrazione di ciascun valore;

un led bicolore per segnalare il corretto funzionamento e gli stati di registrazione dei valori.

Lo sketch è il seguente:

#include <EEPROM.h>

#define buttPinOne 2
#define buttPinTwo 4
#define pinLedGreen 3
#define pinLedRed 5
#define outputPin 9
#define inputPin A0

int minVal,maxVal;
byte minOutputVal = 0;
byte maxOutputVal = 255;
byte threshold = 10;

unsigned long keyPrevMillis = 0;
const unsigned long keySampleIntervalMs = 25;
byte longKeyPressCountMax = 80;    // 80 * 25 = 2000 ms
byte longKeyPressCountOne = 0;
byte longKeyPressCountTwo = 0;
byte prevKeyStateOne = 0;         // button is active high
byte prevKeyStateTwo = 0;         // button is active high

void setup() {
  Serial.begin(115200);

  pinMode( buttPinOne,  INPUT );
  pinMode( buttPinTwo,  INPUT );
  pinMode( inputPin,    INPUT );
  
  pinMode( pinLedGreen, OUTPUT );
  pinMode( pinLedRed,   OUTPUT );
  pinMode( outputPin,   OUTPUT );

  /* Demo */
  digitalWrite(pinLedGreen, 1);
  digitalWrite(pinLedRed  , 0);
  delay(500);
  digitalWrite(pinLedGreen, 0);
  digitalWrite(pinLedRed,   1);
  delay(500);
  digitalWrite(pinLedGreen, 0);
  digitalWrite(pinLedRed,   0);
  delay(500);  
  /* End Demo */
  digitalWrite(pinLedRed,   1);

  /**** EEPROM Data *****/
  minVal = EEPROM.read(0);
  maxVal = EEPROM.read(1);

  if (minVal == 0 && maxVal == 0) {
    // EEPROM empty
    for ( byte i=0; i<10; i++ ) {
      digitalWrite(pinLedGreen, 1);
      digitalWrite(pinLedRed, 1);
      delay(250);
      digitalWrite(pinLedGreen, 0);
      digitalWrite(pinLedRed, 0);
      delay(250);
    }
    saveMin();
    saveMax();
  }
}

// the loop routine runs over and over again forever:
void loop() {
  
  Serial.print("A0: "); Serial.print( (analogRead(inputPin)/4) );
  Serial.print(" B1: "); Serial.print( digitalRead(buttPinOne) );
  Serial.print(" B2: "); Serial.print( digitalRead(buttPinTwo) );

  Serial.print(" Min: "); Serial.print( minVal );
  Serial.print(" Max: "); Serial.print( maxVal );
  Serial.print(" Out: "); Serial.print( map((analogRead(inputPin)/4)+threshold,minVal,maxVal,minOutputVal,maxOutputVal) );
  // print out the value you read:
  Serial.println();

  if (millis() - keyPrevMillis >= keySampleIntervalMs) {
        keyPrevMillis = millis();
       
        byte currKeyStateOne = digitalRead(buttPinOne);
        byte currKeyStateTwo = digitalRead(buttPinTwo);
        if (currKeyStateOne == 1)                           { longKeyPressCountOne++; }
        if ( longKeyPressCountOne >= longKeyPressCountMax ) { saveMin(); }
        if (currKeyStateTwo == 1)                           { longKeyPressCountTwo++; }
        if ( longKeyPressCountTwo >= longKeyPressCountMax ) { saveMax(); }
  }

  /**** Output Pedal ****/
  byte interval = map((analogRead(inputPin)/4)+threshold,minVal,maxVal,minOutputVal,maxOutputVal);
  if ( interval <= minOutputVal )   interval = minOutputVal;
  if ( interval >= maxOutputVal ) interval = maxOutputVal;
  
  analogWrite(outputPin, interval );
  
  delay(100);        // delay in between reads for stability
}

void saveMin() {
  digitalWrite(pinLedRed  , 0);
  
  for ( byte i=0; i<10; i++ ) {
    digitalWrite(pinLedGreen, 1);
    delay(250);
    digitalWrite(pinLedGreen, 0);
    delay(250);
  }
  minVal = (analogRead(inputPin)/4);
  EEPROM.update(0, minVal);
  longKeyPressCountOne=0;
  digitalWrite(pinLedRed  , 1);
}

void saveMax() {
  digitalWrite(pinLedGreen, 0);
      
  for ( byte i=0; i<10; i++ ) {
    digitalWrite(pinLedRed  , 1);
    delay(250);
    digitalWrite(pinLedRed,   0);
    delay(250);
  }
  maxVal = (analogRead(inputPin)/4);
  EEPROM.update(1, maxVal);
  longKeyPressCountTwo=0;
  digitalWrite(pinLedRed  , 1);
}

ecco come funziona linea per linea:

001: includi la libreria, di default nell’IDE Arduino, EEPROM;

003-008: definisci i pin che userai per il controllo di bottoni, del led, l’output e il potenziometro in input;

010: imposta le due variabili in cui memorizzerai la soglia min e max;

011-012: definisci il valore di output minimo ed il malore output max;

ad esempio se decidi di alimentare il tuo circuito a 12v e necessiti solo di una variazione tra 0 e 6v in output potresti cambiare la line 012 in modo che il Pwm massimo sia 127 ottenendo l’effetto desiderato.

013: imposta una soglia che utilizzerai in seguito nello sketch;

015-021: definisci le variabili che ti serviranno nelle fasi di taratura. In modo particolare la variabile keySampleIntervalMs in combinazione con la variabile longKeyPressCountMax stabilisce quanto lungo deve essere il tempo di pressione applicato a ciascun pulsante prima che esso entri in modalità di registrazione;

024-032: definisci la comunicazione seriale, utile in fase di debug, e le modalità di utilizzo di ciascun pin definito alle linee precedenti ( 003-008 );

035-043: è una sequenza demo applicata i led in fase di avvio che ti permette di capire se siano correttamente connessi e funzionanti prima di passare alle fasi successive;

045: dopo l’esecuzione della sequenza demo, accendi il led rosso per segnalare il punto in cui sei arrivato e che il sistema è pronto a funzionare;

048-049: leggi dalla EEPROM i valori di min e max memorizzati in modo da avere un riferimento per l’output ed utilizzare i valori precedentemente memorizzati ad ogni successivo utilizzo;

051: se entrambi i valori letti sono pari a 0 è la prima volta che esegui il codice e non hai ancora inserito alcun valore in EEPROM, questa situazione viene segnalata con 10 lampeggi ( 053-059 ) veloci gialli, accendendo rosso e verse contemporaneamente e serve a segnalarti che devi intervenire;

061: richiama la funzione che salva, in EEPROM, il valore minimo;

062: richiama la funzione che salva, in EEPROM, il valore massimo;

069-077: usando il monitor seriale puoi vedere a video i valori catturati dal potenziometro ed i pulsanti, il valore min e max impostati e l’output calcolato con la funzione map();

079: definisce quando entrare in modalità di registrazione, se la differenza tra il tempo trascorso attuale ( millis ) ed il suo precedente valore ( keyPrevMillis ) è superiore al valore impostato in keySampleIntervalMs ( 25 millisecondi ) esegue le linee successive 080-087;

080: imposta il nuovo valore per keyPrevMillis;

082-083: registra lo stato dei due pulsanti rispettivamente in: currKeyStateOne e currKeyStateTwo;

084: se è stato premuto il primo pulsante incrementa il valore della variabile longKeyPressCountOne che serve a definire quanto tempo è passato dalla pressione del pulsante;

085: se il valore di longKeyPressCountOne è maggiore uguale di  longKeyPressCountMax richiama la funzione saveMin() che provvede a salvare il valore di soglia minima, quella con il pedale non premuto;

086-087: eseguono la medesima operazione delle linee precedenti per il secondo pulsante e richiamano la funzione di salvataggio del valore massimo saveMax();

091: calcoli ed assegni alla variabile interval il valore letto sul potenziometro e mappato sui valori min e max salvati in EEPROM.

092-093: poiché la funzione map() non imposta i limiti min e max di default è necessario eseguire un controllo aggiuntivo per essere certo che l’output non esca dal range definito, imposti quindi i limiti inferiore e superiore in base al valore di interval;

Le funzioni di salvataggio nella EEPROM

Nel pedale 3D sketch si sono due funzioni di salvataggio definite:

• saveMin();
• saveMax();

rispettivamente hanno lo scopo di salvare nelle corrette posizioni di memori i valori definiti con la pressione del pulsante.

100: definisci la funzione saveMin;

101: spegni il led rosso, questo segnala che sei entrato in modalità di registrazione di uno dei due valori;

103-108: esegui un veloce lampeggio del led verse per 10 volte con un tempo di 0.5 secondi per ciascun lampeggio ( 0.5 x 10 = 5 secondi ) sai che subito dopo questa segnalazione il valore minimo sarà memorizzato;

Usa il tempo del lampeggio per posizionare il pedale sul valore minimo ( di solito in alto, ma potresti decidere di usare il pedale in modo contrario per esigenze di progetto ) ;

109: leggi il valore del potenziometro già diviso 4 in modo che possa essere facilmente memorizzato in una cella EEPROM.

110: usi il metodo update della libreria EEPROM per salvare il nuovo valore di EEPROM nella cella 0;

111: azzera il valore della variabile di conteggio in modo che alla successiva esecuzione del loop() non entrerai nuovamente in questa modalità/funzione;

112: accendi nuovamnete il led rosso, funzionamento normale del progetto e segno che la fase di salvataggio si è concludsa;

115-128: definisci la funzione saveMax() del tutto simile a quella appena vista i cui valori differenti rigiardano la sola cella di memoria EEPROM utilizzata ( la 1 ), il lampeggio del led rosso e il reset della variabile longKeyPressCountTwo;

Come funziona il Pedale 3D sketch

il funzionamento del progetto è semplificato, in pratica all’accensione, quando alimenti il pedale dall’ingresso di destra:

lampeggiano prima i led rosso e verde per segnalre il corretto funzionamento, un check delle spie come fanno di solito le automobili; 

poi si accende il led rosso e puoi premere il pulsante di sinistra per 2 secondi circa, fino a quando non vedi il led lampeggiare verde ed in quel momento imposti l’altezza massima, o valore di minimo, del pedale;

successivamente puoi premere il pulsante di destra per i medesimi 2 secondi ed attendere che il led rosso lampeggi, in questo tempo sposta il pulsante nella posizione massima ( di solito quella di pressione ) e attendi che il ciclo di salvataggio si arresti;

il led rosso tornerà fisso acceso.

Il tuo pedale è pronto per regolare proporzionalmente la tensione di uscita sul connettore RCA rosso ( a sinistra)