Salve, in un mio progetto sto usando l'ingresso analogico A1 per rilevare la pressione di 5 tasti da usare per un menù. Ho messo resistenze diverse su ogni pulsante per avere valori diversi da confrontare e decidere quale pulsante è stato premuto. Li programma l'ho creato e funziona. Ho ripreso dopo qualche giorno il circuito e i Pulsanti non mi funzionavano, controllo i valori tornati da A1 ed erano diversi da quelli rilevati quando ho creato il circuito. Come posso stabilizzare i valori in modo che siano
Si ma "diversi" in che senso, ossia di quanto "diversi" e come esattamente tu li leggevi? Dovresti sempre prevedere comunque un certo margine di variabilità, dovuto alla temperatura, all'alimentazione (dalla quale si ottiene il valore di riferimento), alla tolleranza delle resistenze... In questi casi magari anche postare il tuo codice non sarebbe stato male.
Comunque se hai messo le resistenze spero che tu non le abbia messe realmente diverse per ogni pulsante, la cosa più semplice è fare un partitore con resistenze identiche, quindi identificare il pulsante premuto in base al range di valori.
In pratica questo è uno schema che usai tempo fa:

E quindi verificando sperimentalmente il valore rilevato, con una funzioncina tipo questa determini il valore limite di ogni pulsante (i valori qui indicati erano per il mio caso, tu usando la Serial.print puoi verificare i tuoi), poi basta prendere come valore limite quello che si trova all'incirca a metà dell'intervallo tra due consecutivi. Esempio:
// Passando il valore del pin analogico restituisce il
// numero del pulsante o 0 se nessuno è premuto
int Analog2Button(int pin) {
int valore = analogRead(pin);
// Solo per debug!
//if (valore < 1000) Serial.println(valore);
int p = 0; // Nessun pulsante
if (valore < 90) p = 1; // 0
else if (valore < 240) p = 2; // 180
else if (valore < 352) p = 3; // 305
else if (valore < 440) p = 4; // 400
else if (valore < 510) p = 5; // 470
return p;
}
E quindi lo si usa:
void loop() {
int pulsante = Analog2Button(A0);
if (pulsante > 0) {
// Premuto un pulsante
Serial.print("P ");
Serial.println(pulsante);
// Attende il rilascio
delay(50);
while (Analog2Button(A0) != pulsante)
delay(10);
}
}
La tensione di riferimento deve essere la stessa per il convertitore e per il partitore resistivo: se usi gli 1,2V per l'uno, devi usarli anche per l'altro; se usi i 5V per l'uno, anche per l'altro. La precisione è la stessa, perché se varia la tensione di alimentazione varia anche, proporzionalmente, la tensione che esce dal partitore. Ben diverso è il discorso se la tensione in ingresso ha un suo riferimento indipendente e stabile.
Comunque questa è una soluzione che si usa solo se proprio non ci sono abbastanza ingressi disponibili neanche multiplexando. Io avevo suggerito un comodo e intuitivo encoder rotativo, con il quale non devi nemmeno ragionare su quali pulsanti siano il +, il - e la conferma.
L'alimentazione è quella della presa usb del pc, quindi sempre la stessa. Ho usato una resistenza diversa per ogni pulsante, e una tolleranza - 5 a +5 valori rispetto a quello letto durante le prove per determinare i valori da inserire negli if.
La differenza trovata tra prima e dopo è alta, per esempio un tasto, prima mi dava 900 e poi segnava 850.
Non posso rischiare di non vederlo funzionare, una volta finito.
Se non riesco ad ottenere valori stabili vedrò come posso sostituire i 5 tasti con un encoder a pulsante centrale. Avevo pensato: la rotazione per auemtnare e diminuire il valore nel menù, premere il pulsante per scorrere il menù e tenerlo premuto più a lungo per uscire dal menù e memorizzare i valori. Che ne dite, si potrebbe fare?
Provo prima con lo schema proposto, anche se, con l'encoder si semplificherebbe l'installazione in una scatola.
Come dico sempre ... NON reinventate l'acqua calda ...
... nella sezione delle librerie di Arduino, dove sono presenti centinaia di librerie divise per categorie, quasi sicuramente trovate quello che vi serve.
Nella sezione "Signal Input/Output" ci sono alcune librerie per la gestione di encore e di encoder con bottone ... ![]()
Guglielmo
Ripeto, se tu confronti le letture con singoli valori è possibilissimo. Tu devi usare intervalli di valori, come ti ho consigliato. Prova col partitore che ti ho descritto (e relativa funzione) e vedrai che non avrai problemi. Io ho realizzato vari pulsanti, deviatori, ed anche rotary switch per un progetto di pannello per un 737 su Flight Simulator...
Si può anche creare una scala di tensioni equidistanti e ottenere direttamente da map il numero del pulsante premuto:
Rimane però il fatto che un valore analogico può essere letto in un punto intermedio di qualsiasi valore durante la transizione da uno stato stabile all'altro, per cui va attuata una strategia di debounce. Come minimo prendere buona una lettura solo se uguale per due volte successive ad almeno 10 ms di distanza.
26KB per leggere un endoder???...!!! Preferisco la mia funzione:
#define puls_prem !(PIND&0b01000000) // Se il pulsante chiude a massa su I/O 6 (PD6) (serve INPUT_PULLUP nel pinMode).
// oppure:
#define puls_prem !digitalRead(x) // Se il pulsante chiude a massa sull'I/O x (serve INPUT_PULLUP nel pinMode).
// oppure:
#define puls_prem digitalRead(x) // Se il pulsante chiude a Vcc sull'I/O x (serve una resistenza di pulldown verso massa).
int8_t E; // Risultato della routine encoder(): 1, -1, 0.
uint8_t S; // Lettura dei due valori dell'encoder.
uint8_t Sp;// Lettura precedente dell'encoder.
uint8_t X; // Usato in encoder() per evitare letture multiple.
// --------------------------------------------------------------------------------
while(!puls_prem) // Finché non premo:
{
encoder();
if(E) // Solo se l'encoder è stato ruotato:
{
valore+=E; delay(20); // Somma +1 o -1. Credo che il delay non serva.
if(valore<0) {valore=0;}
if(valore>100) {valore=100;}
char buf[6]; // Prepara un buffer, che chiamo buf, per metterci i caratteri delle cifre, poi trasforma il valore in caratteri e li scrive sull'LCD.
lcd.setCursor(3, 1); dtostrf(valore, 5, 0, buf); lcd.print(buf);
}
}
void encoder()
{
// PD 76543210
// S=3-PIND&B00000011; Gli I/O 1 e 0 sono PD1 e PD0, perciò non devo scorrere a destra.
// S=3-(PIND>>3)&B00000011; Serviva per l'encoder su PD4 e PD3.
// S=3-((PIND>>4)&B00000011); // Gli I/O 5 e 4 erano PD5 e PD4, perciò dovevo scorrere a destra di 4 bit.
// S=3-((PIND>>2)&B00000011); // Uso PD3 e PD2, quindi scorro a destra di 2 bit per farli diventare 1 e 0.
S=3-((PINC>>1)&B00000011); // Uso PC2 e PC1 (A2 e A1), quindi scorro a destra di 1 bit per farli diventare 1 e 0.
// Il valore binario di S rappresenta A e B. Il centrale dell'encoder è a massa, quindi faccio complemento a 3 (11).
S^=S>>1; // Faccio XOR (^) fra S (gray) e il suo bit 1, facendolo scorrere a Dx: AB XOR A,
// ottenendo un binario che per ogni scatto fa 0-1-2-3-0 oppure 0-3-2-1-0.
E=0; // Azzeramento iniziale.
if (S!=Sp && S==0) X=0: Se lo stato è cambiato ed è andato a 0 (fine dello scatto), azzera X.
if (X==0)
{
if (Sp==1 && S==2) // Se lo stato precedente era 1 e adesso è 2:
{E=1; X=1;} // X=1 impedisce letture doppie prima che lo stato sia tornato a 0.
if (Sp==3 && S==2) // Se lo stato precedente era 3 e adesso è 2:
{E=-1; X=1;} // X=1 come sopra.
if (S==0) // Se lo stato attuale è 0:
{E=0; X=0;}
So=S;
}
}
Oppure la versione con interrupt, di cui questo è un applicativo completo:
// https://dronebotworkshop.com/interrupts/
#include <PCF8574_HD44780_I2C.h>
// LCD 16x2 con indirizzo I2C 0x27:
PCF8574_HD44780_I2C lcd(0x27,16,2);
volatile int16_t contatore=0; // Fino a oltre +/-32000. Ho previsto anche i valori negativi.
volatile uint8_t s=0; // Valore decimale dei bit.
volatile uint8_t sp=0; // Stato precedente di s.
volatile uint8_t x=0;
int16_t contatorep=0; // Valore precedente.
void setup()
{
pinMode(8, INPUT_PULLUP);
pinMode(9, INPUT_PULLUP);
Serial.begin(9600);
Serial.println("Start");
lcd.init();
lcd.backlight();
lcd.setCursor(7, 1); lcd.print('0');
// Pin Change Interrupt Control Register (PCICR): PORTD=PCIE2; PORTC=PCIE1; PORTB=PCIE0;
// PCICR |= 0b00000001; // PORT B.
PCICR |= 1<<PCIE0;
// PORT B: PMSK0; D9 e D8 sono i bit 1 e 0:
// PCMSK0 |= 0b00000011;
PCMSK0 |= 1<<PCINT1 | 1<<PCINT0;
}
void loop()
{
if(contatore != contatorep)
{
Serial.println (contatore);
char buf[6];
lcd.setCursor(3, 1); dtostrf(contatore, 5, 0, buf); lcd.print(buf);
contatorep = contatore;
}
}
ISR (PCINT0_vect)
{
// bit AB
s=((PINB^0xFF) & 0b00000011); // Inverto i bit, perché l'encoder chiude a massa, e considero solo D9 e D8. S è composto dai bit A e B.
s^=s>>1; // Faccio AB XOR A, ottenendo un valore decimale fra 0 e 3.
if (s!=sp && s==0) x=0;
if (x==0)
{
if (sp==1 && s==2)
{
contatore+=1;
x=1;
}
else if (sp==3 && s==2)
{
contatore-=1;
x=1;
}
else if (!s) x=0;
sp=s;
}
}
Hai fatto il link di qualche porgramma o hai solo guardato i sorgenti? ... perché il compilatore NON è stupido ed ottimizza ... lasciando SOLO quello che veramente serve.
Tutte le librerie comprendono un sacco di funzioni e di possibilità (spesso molte più di quelle che servono), poi dipende quelle che veramente si usano!
Imparate ad usarle ... ![]()
Guglielmo
Sì, lo so, ma appunto preferisco usare, se possibile, una funzione con solo ciò che serve incorporata nel programma, piuttosto che allegare un polpettone di libreria di cui ne userò un decimo, devo pure capire come si usa e non so se funziona proprio come desidero io... La mia so che funziona benissimo e commuta in un verso dallo stato 1 al 2 e, nell'altro verso, dal 3 al 2, rendendo impossibili instabilità.
Sei un'altro di quelli che "reinventa l'acqua calda" ...
... del resto de gustibus non est disputandum ![]()
Guglielmo
Eh, ma l'acqua calda fatta in casa ha tutt'un altro sapore! ![]()
Grazie per il link, molto interessante. Penso che se è possibile, conviene sempre farsi il codice su misura. Per esempio, per il mio progetto ho usato, all'inizio, la libreria RBDdimmer.h, con una lampada va bene ma con più lampade no. Mi è stata consigliata un'altra libreria che mi dava errore e grazie all'intervento di un iscritto sono riuscita a farla funzionare. Sicuramente se si trova una libreria che funziona per il proprio progetto, conviene usarla per risparmiare tempo, specialmente se a programmare è un principiante come me.
Interessante il tuo sistema, farò delle prove insieme al sistema proposto da docdoc, però voglio provare anche l'encoder con lo schema proposto da Datman, alla fine vedrò quale mi convince di più.
Comunque sto arduino mi attizza non poco, per le grandi potenzialità che nasconde.
Ho optato per l'uso dell'encoder, anche per provare un nuovo sistema.
void menutempo(){
lcd.setCursor(0,ve);
lcd.write(byte(0)); // Stampa la freccia alla posizione indicata da lcd.setCursor
tasto = 0;
stato = 0;
menu();
while(stato != 1) {
//delay(150);
tasto = digitalRead(A0);
int currClk = digitalRead(A1);
int currDt = digitalRead(A2);
if (tasto==0) { // Se viene premuto il tasto brevemente fa scendere la freccia
ve = ve+1;
if (ve>3) ve=0;
muovefreccia();
}
// Questo IF controlla l'encoder
if (currClk != prevClk) {
if (currDt == currClk) {inc = -1;} //Se il valore di dt è uguale al valore corrente di clk diminuisce i secondi di 1 altrimenti li aumenta
else inc = +1;
setTempo();
prevClk = currClk;
prevDt = currDt;
}
} // Fine while
for(int i=0;i<4;i++) { // Pulisce la prima colonna di ogni riga, in pratica cancella la freccia
lcd.setCursor(0,i);
lcd.print(" ");
}
// Inizializza tutto in base al nuovo valore del tempo
fase=0; // Quando si esce dal menù si ricomincia dall' Alba
n=125; // Variabile per step Notte
g=0; // Variabile per step Giorno
a=0; // variabile per step Alba
t=0; // variabile per step Tramonto
l1.setBrightness(a); // Imposta luminosità Alba
l2.setBrightness(g); // Imposta luminosità Giorno
l3.setBrightness(t); // Imposta luminosità Tramonto
l4.setBrightness(n); // Imposta luminosità Notte
mta=(tempo[0]/2)/255; // La formula mi calcola quanto deve durare metà fase dell'alba. 255 è il valore per otteneere la massima luminosità
tg=tempo[1]/255; // La formula mi calcola quanto deve durare la fase del giorno. Al tempo totale viene tolto metà tempo Alba e metà tempo Tramonto
mtt=(tempo[2]/2)/255; // La formula mi calcola quanto deve durare metà fase del Tramonto. 255 è il valore per otteneere la massima luminosità
tn=tempo[3]/255UL; // La formula mi calcola quanto deve durare la fase della notte.
}
Nel loop se viene premuto il pulsante dell'encoder si avvia la routine menutempo. Se premo il pulsante la freccia che indica quale fase cambierà il suo valore, aumenta di uno, quindi va alla riga seguente. Dato che il display è a 4 righe, quando arriva alla quarta, la freccia viene riportata alla prima riga. Se giro l'encoder, il valore relativo alla posizione della freccia aumenta o diminuisce. Tutto ciò funziona ma il valore aumenta o diminuisce di 2 numeri alla volta anche se inc=-1 o +1.
Perché un singolo scatto di encoder produce due variazioni di Clk e due di Dt:

In un senso troverai sempre Dt concordante, nell'altro discordante.
Puoi determinare il verso semplicemente rilevando lo stato di uno quando cambia l'altro, ma così puoi avere instabilità e rimbalzi.
Per il mio uso va bene anche 2 valori alla volta, tanto se il giorno mi dura 40 o 41 o 42 secondi non cambia nulla. Alla fine proverò comunque a farlo scalare di un valore alla volta.
Ho fatto così ed in effetti a volte mi capita che anche se giro sempre nello stesso verso, anziché aggiungere, sottrae, ma lo fa raramente.
void menutempo(){
lcd.setCursor(0,ve);
lcd.write(byte(0)); // Stampa la freccia alla posizione indicata da lcd.setCursor
bool premuto = 0;
bool uscire=0;
tasto = 0;
stato = 0;
menu();
mil = millis();
while(stato != 1) {
if (millis()-mil > 5000 ) {
uscire=1;
premuto=0;
mil=millis();
}
if (uscire == 1 && premuto ==0) stato=1;
tasto = digitalRead(A0);
int currClk = digitalRead(A1);
int currDt = digitalRead(A2);
if (tasto==0) { // Se viene premuto il tasto brevemente fa scendere la freccia
ve = ve+1;
mil=millis();
premuto=1;
if (ve>3) ve=0;
muovefreccia();
}
// Questo IF controlla l'encoder
if (currClk != prevClk) {
if (currDt == currClk) {inc = -1;} //Se il valore di dt è uguale al valore corrente di clk diminuisce i secondi di 1 altrimenti li aumenta
else inc = +1;
setTempo();
mil=millis();
premuto=1;
prevClk = currClk;
prevDt = currDt;
}
} // Fine while
lcd.clear();
// Inizializza tutto in base al nuovo valore dei tempi
fase=0; // Quando si esce dal menù si ricomincia dall' Alba
n=125; // Variabile per step Notte
g=0; // Variabile per step Giorno
a=0; // variabile per step Alba
t=0; // variabile per step Tramonto
l1.setBrightness(a); // Imposta luminosità Alba
l2.setBrightness(g); // Imposta luminosità Giorno
l3.setBrightness(t); // Imposta luminosità Tramonto
l4.setBrightness(n); // Imposta luminosità Notte
mta=(tempo[0]*500)/255UL; // La formula mi calcola quanto deve durare metà fase dell'alba. 255 è il valore per otteneere la massima luminosità
tg=(tempo[1]*1000)/255UL; // La formula mi calcola quanto deve durare la fase del giorno. Al tempo totale viene tolto metà tempo Alba e metà tempo Tramonto
mtt=(tempo[2]*500)/255UL; // La formula mi calcola quanto deve durare metà fase del Tramonto. 255 è il valore per otteneere la massima luminosità
tn=(tempo[3]*1000)/255UL; // La formula mi calcola quanto deve durare la fase della notte.
// if (tempo[0] != EEPROM.get(0)) EEPROM.put(0,tempo[0]); // Se il valore di Alba contenuto nella posizione zero è cambiato, scrive il nuovo valore
// if (tempo[1] != EEPROM.get(2)) EEPROM.put(2,tempo[1]); // Se il valore di Giorno contenuto nella posizione 2 è cambiato, scrive il nuovo valore
// if (tempo[2] != EEPROM.get(4)) EEPROM.put(4,tempo[2]); // Se il valore di Tramonto contenuto nella posizione 4 è cambiato, scrive il nuovo valore
// if (tempo[3] != EEPROM.get(6)) EEPROM.put(6,tempo[3]); // Se il valore di Notte contenuto nella posizione 6 è cambiato, scrive il nuovo valore
} // Fine routine menutempo
questa routine è completa e funzionante, quando premo un tasto faccio muovere la freccia per indicare quale fase sto cambiando, muovendo in un verso o nell'altro, variano i secondi e se non tocco nulla per 5 secondi esco dalla routine senza aver prima settato tutto con i nuovi valori e averli memorizzati nella EEPROM.
Solo una cosa , non mi esce più il disegno della freccia.
L'ho creata così:
byte freccia[8] = { // Crea un carattere con la figura della freccia
B00000,
B00000,
B00010,
B11111,
B00010,
B00000,
B00000,
B00000
};
La routine che stampa la freccia è questa:
void muovefreccia() { // Muove la freccia su e giu
for(int i=0;i<4;i++) { // Pulisce la prima colonna di ogni riga, in pratica cancella la freccia
lcd.setCursor(0,i);
lcd.print(" ");
}
lcd.setCursor(0,ve);
lcd.write(byte(0)); // Stampa la freccia sul LCD
delay(250); // Serve a non far scorrere la freccia troppo velocemente
} // Fine routine muove freccia
Anche se è rimasta sempre la stessa, quando usavo i tasti mi usciva la freccia ora mi escono due barre verticali.
Risolto, nel setup avevo cancellato questo e non me ne ero accorto.
lcd.createChar(0, freccia); // Crea un carattere con la figura della freccia
