Go Down

Topic: Impianto d'Irrigazione Interrato gestito da Arduino (Read 2372 times) previous topic - next topic

Ryan0497

Salve, mi scuso se il titolo non spiega proprio bene quello che vorrei fare ma non basterebbe lo spazio disponibile per farlo.



Obiettivo:

Creare una Centralina d'Irrigazione con Arduino.
Ho già acquistato diversi componenti tra cui uno mi deve ancora arrivare nel frattempo sto cercando di occuparmi del lato programmazione.


Componenti:

  • Arduino UNO R3;
  • RTC DS3231 I2C (Componente che mi dovrà ancora arrivare e se vogliamo il più importante dell'intero progetto);
  • LCD 1602 I2C;
  • Relay Board 8Ch
  • 4 Pulsanti Normalmente Aperti
  • 5 Resistenze qualsiasi
  • Cavetterie Varie
  • BreadBoard per la fase di test che poi trasformerò tutto in un PCB


Informazioni:

Ho scelto di utilizzare l'LCD e l'RTC connettendoli entrambi al modulo I2C per risparmiare quanti più pin digitali possibili e farli utilizzare dal Modulo Relay a 8 canali da connetterli a delle elettrovalvole che interromperanno il flusso dell'acqua tramite una Bassa Tensione (24V) dato che Acqua e Corrente sono altamente pericolosi se messi vicini... ma sono consapevole di quello che faccio e che utilizzare la corrente è altamente pericoloso per me e per chiunque. Tornando al discorso ho scelto di utilizzare 5 pulsanti collegati tutti a un solo pin analogico che tramite resistenze, 5V+ e GND dell'Arduino posso utilizzarli per creare i soliti 4 pulsanti: Sopra, Sotto, Invio e Indietro.

Diciamo che mi sento già a buon punto però ora arriva la parte cruciale (o almeno per me)... il lato programmazione.


Domanda:

Dovrei creare un menù, nel quale muovermi sull'LCD tramite i pulsanti, così come ho creato uno schema logico tramite notepad++.

Una volta creato il menù dovrò:
 Inserire la possibilità di impostare data e ora attuale;
 Settare 4 timer diversi per ogni Relay che utilizzerà l'RTC in modo che se dovessi interrompere l'alimentazione ad Arduino verrà tutto salvato grazie la batteria a bottone presente su di esso;
 E questo è tutto... per l'accensione manuale per fortuna riesco a fare da solo il problema è la programmazione automatica giornaliera.

Mi sono informato prima di scrivervi qui e ho visto che ci sono delle librerie per la creazione dei menù ma non ho dimestichezza... ci ho provato ma non riesco proprio ad utilizzarla (troppo complicata per il mio livello di programmazione  sennò non starei qui a chiedervi aiuti ed esempi).

Se per voi è un problema aiutarmi interamente, mi basterebbero anche degli esempi di sketch:

Esempio per la creazione di menù, submenù a 5 livelli/piani magari con dei commenti che mi fanno capire come modificarli o sistemarli per il mio scopo;

Esempio per far funzionare il modulo RTC DS3231 I2C che mi permettono di Settare la Data Attuale, Settare l'Ora Attuale, Visualizzare Ora e data su due righe diverse ma nella stessa schermata;

Esempio di come, se premo il pulsante Invio una volta giunto al "submenù" di 5° Livello, mi faccia impostare l'Ora di Attivazione relativa a un pin dal quale sarà attivato un relay (non chiedo l'esempio per lo spegnimento in quanto sarà il contrario e credo di potercela fare da solo una volta capito il funzionamento dell'attivazione)

Esempio di come salvare i timer inseriti in modo che non vengano dimenticati in caso di mancata alimentazione elettrica (Se non erro qui si tratterà di eeprom e sò bene che questa mi darà dei problemi, non ci ho mai capito niente dalle varie discussioni lette sui forum dove se ne parla di come salvare date e orari... per cui se riusciste a commentare qualche stringa anche qui mi aiutereste davvero tanto.

E in teoria dovrebbe essere tutto se non dimentico qualcosa.



Per favore, non rimandatemi a forum dove discutono di come funzionano gli elementi ecc. perchè come ci sapete andare voi ci sò andare anche io e se vi scrivo è perchè non mi sono di aiuto per cui confido in soli vostri commenti ed esempi che mi aiutino a realizzare questo progetto che una volta finito renderò pubblico per chiunque ne abbia bisogno (anche perchè tra progetti italiani e stranieri relativo alle centraline d'irrigazioni nessuno è tanto preciso quanto questo che vorrei realizzare io).

Mi scuso per le eventuali ripetizioni o il mio stile di scrivere periodi lunghi e interminabili... sono settimane che cerco di documentarmi, ormai mi si è fuso il cervello ahah.

Ora lascio la parola a voi e spero che mi diate gli input necessari per il mio output  :smiley-lol:

Se volete vi rilascerò anche lo schema che ho realizzato con Fritzing di come ho messo in comunicazione tutti gli elementi.

Puso

Ciao

comincia intanto a settare RTC ed Visualizzarlo sul display.

Se NON PREMI il pulsante vedi solo la data, se PREMI il pulsante vedi per 10 secondi ORA e DATA.....ed i secondi devono scorrere , non bloccarsi.

Poi posta lo schetc se hai problemi  :smiley-wink:  :smiley-wink:  :smiley-wink:

gpb01

>Ryan0497: Nonostante tu sia iscritto da molto tempo, NON trovo il tuo post di presentazione :smiley-confuse: , per cui ... nel rispetto del regolamento della sezione Italiana del forum (… punto 13, primo capoverso), ti chiedo cortesemente di presentarti IN QUESTO THREAD (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con MOLTA attenzione il su citato REGOLAMENTO ... Grazie.

Guglielmo
Search is Your friend ... or I am Your enemy !

Ryan0497

>Ryan0497: Nonostante tu sia iscritto da molto tempo, NON trovo il tuo post di presentazione :smiley-confuse: , per cui ... nel rispetto del regolamento della sezione Italiana del forum (… punto 13, primo capoverso), ti chiedo cortesemente di presentarti IN QUESTO THREAD (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con MOLTA attenzione il su citato REGOLAMENTO ... Grazie.

Guglielmo
Sembra strano... chiedo scusa e interverrò il prima possibile non me ne vogliate ma a quest'ora non riuscirei a farlo.

Ciao

comincia intanto a settare RTC ed Visualizzarlo sul display.

Se NON PREMI il pulsante vedi solo la data, se PREMI il pulsante vedi per 10 secondi ORA e DATA.....ed i secondi devono scorrere , non bloccarsi.

Poi posta lo schetc se hai problemi  :smiley-wink:  :smiley-wink:  :smiley-wink:
Allora dovrò aspettare che mi arrivi l'RTC e vedrò cosa riuscirò a fare... intanto sto vedendo anche di utilizzare Blynk per Android che sembrerebbe essere ottimo al caso mio e forse più completo del mio stesso progetto.

Comunque vi terrò aggiornati non appena mi arriva il modulo. Grazie Mille e Mi scuso ancora per la mia mancata presentazione in questo forum... di solito la prima cosa che faccio nei forum è leggermi il regolamento e presentarmi. Comunque rimedierò il prima possibile.

Claudio_FF

La prima cosa da fare mi sembra sia quella di leggere correttamente i pulsanti, altrimenti poi i problemi da affrontare insieme sono più di uno ;)

Leggere i pulsanti e farsi stampare via monitor seriale gli eventi rilevati, pressione1, pressione2, rilascio.
* * * *    if non è un ciclo   * * * *

* * * Una domanda ben posta è già mezza soluzione. * * *

Ryan0497

#5
May 03, 2018, 03:06 pm Last Edit: May 03, 2018, 03:08 pm by Ryan0497
La prima cosa da fare mi sembra sia quella di leggere correttamente i pulsanti, altrimenti poi i problemi da affrontare insieme sono più di uno ;)

Leggere i pulsanti e farsi stampare via monitor seriale gli eventi rilevati, pressione1, pressione2, rilascio.
Allora io ho creato questo sketch ma funziona in parte. Non riesco a far scrivere sul monitor seriale il tasto che sto premendo al posto di farmi visualizzare solo i valori del pulsante premuto e che fanno parte degli insiemi creati a inizio sketch più o meno.

Code: [Select]
/*
  Titolo:      Tastiera Menù
  Autore:      Ryan0497
  Data:        03/05/2018
  Obiettivo:   Leggere Tutti Valori dal PIN A0 alla pressione dei pulsanti per creare tastiera menù.
*/

void setup() {
  Serial.begin(9600);
}

void loop() {
 
  //Dichiarazione Variabili
  int TASTIERA = analogRead(A0);  //Chiamo i valori letti dal PIN A0 "TASTIERA"
  int INVIO[]     =  {0, 20};     //Chiamo i valori inclusi nell'insieme x,y INVIO
  int SINISTRA[]  =  {929, 931};  //Chiamo i valori inclusi nell'insieme x,y SINISTRA
  int DESTRA[]    =  {936, 939};  //Chiamo i valori inclusi nell'insieme x,y DESTRA
  int SOPRA[]     =  {943, 945};  //Chiamo i valori inclusi nell'insieme x,y SOPRA
  int SOTTO[]     =  {946, 947};  //Chiamo i valori inclusi nell'insieme x,y SOTTO
 
  //Svolgimento
  Serial.println(TASTIERA); //Stampa i Valori letti alla pressione dei pulsanti per creare gli insiemi delle VARIABILI create sopra
  delay(250); //Tempo di aggiornamento prima di ristampare il valore letto
 
  //Alla pressione scrivi "IL PULSANTE PREMUTO"
  //Se TASTIERA è un numero compreso tra uno delle 5 variabili create, allora stampa il nome della variabile creata
  if (TASTIERA == INVIO) {
    Serial.println("INVIO");
  }

  if (TASTIERA == SINISTRA) {
    Serial.println("SINISTRA");
  }

  if (TASTIERA == DESTRA) {
    Serial.println("DESTRA");
  }

  if (TASTIERA == SOPRA) {
    Serial.println("SOPRA");
  }

  if (TASTIERA == SOTTO) {
    Serial.println("SOTTO");
  }
}


Ryan0497

#6
May 03, 2018, 11:00 pm Last Edit: May 03, 2018, 11:01 pm by Ryan0497
Ok, ho risolto il mio problema semplificandomi un po' la vita in questo modo:

Code: [Select]
/*
  Titolo:      Tastiera Menù
  Autore:      Ryan0497
  Data:        03/05/2018
  Obiettivo:   Leggere Tutti Valori dal PIN A0 alla pressione dei pulsanti per creare tastiera menù.
*/

void setup() {
  Serial.begin(9600);
}

void loop() {

  //Dichiarazione Variabile per Tastiera
  int TASTIERA = analogRead(A0);  //Chiamo i valori letti dal PIN A0 "TASTIERA"

  //Lettura Valori per settare la tastiera
  //Serial.println(TASTIERA); //Stampa i Valori letti alla pressione dei pulsanti per creare gli insiemi delle VARIABILI create sopra

  /******************************************************************************/
  /***********************************TASTIERA***********************************/
  /******************************************************************************/
  //INVIO
  if (TASTIERA >= 0 && TASTIERA <= 100) {
    Serial.println("INVIO");
  } else {}

  //SINISTRA
  if (TASTIERA >= 928 && TASTIERA <= 931) {
    Serial.println("SINISTRA");
  } else {}

  //DESTRA
  if (TASTIERA >= 935 && TASTIERA <= 939) {
    Serial.println("DESTRA");
  } else {}

  //SOPRA
  if (TASTIERA >= 942 && TASTIERA <= 945) {
    Serial.println("SOPRA");
  } else {}

  //SOTTO
  if (TASTIERA >= 946 && TASTIERA <= 950) {
    Serial.println("SOTTO");
  } else {}
  /******************************************************************************/
  /******************************************************************************/
  /******************************************************************************/


  delay(50); //Tempo di aggiornamento prima di ristampare il valore letto
}


Lascio in Allegato il monitor seriale.

Ora cosa mi consigliate di fare per proseguire il progetto?
Metto in comunicazione l'LCD 1602A I2C con Arduino UNO R3?

Claudio_FF

#7
May 04, 2018, 09:17 am Last Edit: May 04, 2018, 09:40 am by Claudio_FF
C'è qualcosa che non va nei valori di accettazione, idealmente con cinque pulsanti che generano valori equamente spaziati nel range 0..1023 dovrebbero esserci finestre di accettazione larghe circa 200 punti, non 3..4. Ritengo che il partitore di tensione usato sia un po' "strano".

In questo ad esempio i pulsanti dovrebbero generare questi valori (salvo tolleranze delle resistenze):
Code: [Select]
+5V---[R2k2]---+-------+-------+-------+-------+--->in
               |       |       |       |       |
             [R8k2]  [R3k3]  [R1k5]  [R560]    |
               |       |       |       |       |
                /       /       /       /       /
               |       |       |       |       |
              Gnd     Gnd     Gnd     Gnd     Gnd

   nessuno   sotto   sopra   destra  sinist. invio
    1023      806     614     414     208      0
Quindi in pratica il tasto <invio> si prenderà per buono per valori minori di 104, altrimenti il tasto <sinistra> si prenderà per buono per valori minori di 311 e così via. Poi leggendo i valori reali restituiti dal proprio partitore si aggiustano le finestre in modo da centrarle sui valori reali.

Seconda cosa, non è così semplice, con il tuo codice è vero che individui il tasto premuto, ma non rilevi il momento della pressione, cioè il click, che è il vero comando che poi dovrà comandare il menu. In pratica se tieni premuto il monitor seriale continua a stampare a raffica.

Il click avviene quando da <nessuno> si passa ad una delle altre possibilità (e il valore rimane stabile per almeno 50ms), il rilascio quando si torna a <nessuno>, e solo a quel punto potrà esserci un altro click.
* * * *    if non è un ciclo   * * * *

* * * Una domanda ben posta è già mezza soluzione. * * *

Etemenanki

#8
May 04, 2018, 11:24 am Last Edit: May 04, 2018, 11:25 am by Etemenanki
Scusa, perche' non usare una rete simmetrica per il divisore ? ... una cosa tipo questa ...



con quei valori, il consumo totale della rete sarebbe di circa 300uA, e le tensioni dovrebbero essere abbastanza stabili (meno un minimo causato dalla resistenza da 220K di pulldown, che pero' influisce poco in proporzione)
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

Ryan0497

C'è qualcosa che non va nei valori di accettazione, idealmente con cinque pulsanti che generano valori equamente spaziati nel range 0..1023 dovrebbero esserci finestre di accettazione larghe circa 200 punti, non 3..4. Ritengo che il partitore di tensione usato sia un po' "strano".

In questo ad esempio i pulsanti dovrebbero generare questi valori (salvo tolleranze delle resistenze):
Code: [Select]
+5V---[R2k2]---+-------+-------+-------+-------+--->in
               |       |       |       |       |
             [R8k2]  [R3k3]  [R1k5]  [R560]    |
               |       |       |       |       |
                /       /       /       /       /
               |       |       |       |       |
              Gnd     Gnd     Gnd     Gnd     Gnd

   nessuno   sotto   sopra   destra  sinist. invio
    1023      806     614     414     208      0

Quindi in pratica il tasto <invio> si prenderà per buono per valori minori di 104, altrimenti il tasto <sinistra> si prenderà per buono per valori minori di 311 e così via. Poi leggendo i valori reali restituiti dal proprio partitore si aggiustano le finestre in modo da centrarle sui valori reali.
Hai perfettamente ragione, devo andare a comprare delle resistenze diverse e cambiarle con quelle attuali perchè quando ho realizzato il circuito per fare una prova, non avendo 5 resistenze diverse, decisi di utilizzarne 5 uguali che avevo da un kit comprato.



Quote
Seconda cosa, non è così semplice, con il tuo codice è vero che individui il tasto premuto, ma non rilevi il momento della pressione, cioè il click, che è il vero comando che poi dovrà comandare il menu. In pratica se tieni premuto il monitor seriale continua a stampare a raffica.

Il click avviene quando da <nessuno> si passa ad una delle altre possibilità (e il valore rimane stabile per almeno 50ms), il rilascio quando si torna a <nessuno>, e solo a quel punto potrà esserci un altro click.
Allora correggimi se erro, il codice va cacciato fuori loop() e si toglie la funzione delay(50) o non basta?
Sennò pensavo di cambiare lo stato dei pin analogici in digitale e collegare solo 4 pulsanti  ai 4 pin (uno per pin) e definirli con un nome che li identificasse del tipo

Code: [Select]

int SOPRA A0;
int INDIETRO A1;
int INVIO A2;
int SOTTO A3;


Così alla pressione di uno dei tasti riesco a far leggere se il pulsante è premuto oppure no. Ovviamente quello di sopra è un esempio, non so nemmeno se è la corretta dicitura per fare tutto questo (andrò a vedere sul dizionario del linguaggio in C  :D


Scusa, perche' non usare una rete simmetrica per il divisore ? ... una cosa tipo questa ...



con quei valori, il consumo totale della rete sarebbe di circa 300uA, e le tensioni dovrebbero essere abbastanza stabili (meno un minimo causato dalla resistenza da 220K di pulldown, che pero' influisce poco in proporzione)
ma in questo modo se non ho capito male mi ritroverò di nuovo allo stato di prima che seppur riesco a far vedere 5 pulsanti collegati tutti allo stesso pin, durante la creazione del menù avrò problemi nel richiamarli alla loro pressione

Etemenanki

Problema che hai comunque, con entrambi i sistemi (il mio di diverso ha solo che hai una divisione piu lineare dei valori e meno casini per calcolarti i partitori) ... per il problema che dici tu, serve che gestisci la cosa in modo diverso ... un modo, ad esempio, potrebbe essere quello di inserire nella parte che controlla il valore letto dall'ingresso analogico, come primo controllo, un'if che attiva una flag (o quello che preferisci) se il valore letto e' maggiore di un minimo ... dato che nessun pulsante = 0V, se fai il mapping con 1023, il minimo valore con 1V sarebbe intorno ai 204, per cui se metti un'if (valore letto > 50 oppure 100) flag=1 else flag=0, o qualcosa di simile, avrai la flag che va ad 1 ogni volta che premi un qualsiasi pulsante e torna a 0 quando nulla e' premuto, da poter usare nello sketch per "sentire" quando li premi ...
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

Ryan0497

Mh... non capisco tanto bene come dovrei creare uno sketch che faccia quello che mi hai appena detto. Mica mi puoi mandare un mini-sketch che mi mostri come può funzionare già solo con un pulsante? Non so proprio cosa cominciare a scrivere  ::)

Etemenanki

In che senso scusa ?

Se usi un solo pin per leggere piu di un pulsante, dovrai per forza avere nel loop almeno una sezione che ti fa la lettura dell'ingresso analogico a cui i pulsanti sono connessi, per sapere quale e' stato premuto ... potrebbe essere una cosa tipo (pseudocodice, da completare con le tue variabili)

Code: [Select]

void loop()
   {
   ...
   tuo codice
   ...
   int valoreletto=digitalRead(pin_analogico_che_usi);
   valore=map(valoreletto, 0, 1023, 0, 5); //questo da un valore proporzionale al pulsante premuto
   ...
   ...eccetera


solo come esempio, ci sono altri modi ... ma se usi una cosa simile, valoreletto sara' zero o comunque un valore pprossimo a zero senza alcun pulsante premuto, e superiore a zero (almeno 200 per 5 pulsanti) quando un qualsiasi pulsante e' premuto ... per cui, se sempre come esempio, prima della conversione fatta con la map, ci metti una cosa del genere

Code: [Select]

   if(valoreletto >= 50)
   {
      miaflag=1;
   }
   else
   {
      miaflag=0;
   }


avrai una flag (miaflag in questo caso, ma puoi dargli il nome che vuoi, e' una semplice variabile byte) che ogni volta che premi un pulsante passera' da 0 ad 1, tornando a 0 quando lo rilasci ... che quindi potrai usare in qualche altra parte dello sketch per "dire" al micro che un pulsante e' stato premuto, nel caso servisse ...

Oppure potresti usare uno switch case per valori da 0 a 5, con 0 non e' stato premuto alcun pulsante, con gli altri valori automaticamente sai che un pulsante e' stato premuto ed anche quale (l'if viene buono se non usi la switch, oppure se lo stato dei pulsanti serve anche saperlo in qualche altro punto dello sketch) ...

O magari a qualche programmatore viene in mente un sistema anche migliore, a me, non essendo un programmatore, sono venuti in mente al volo solo questi ...
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

Claudio_FF

#13
May 04, 2018, 05:42 pm Last Edit: May 04, 2018, 05:56 pm by Claudio_FF
Quote
un mini-sketch che mi mostri come può funzionare già solo con un pulsante?
Il riconoscimento di una variazione passa sempre per l'uso di una variabile che rappresenta lo stato precedente, da confrontare con la situazione aggiornata attuale, se c'è differenza allora è avvenuta una variazione (poi si aggiorna la variabile di stato alla situazione attuale, in modo da poter sentire variazioni successive). Il sistema più semplice per un pulsante digitale credo sia questo (si assume un collegamento hardware con resistenza di pull-up, quindi pulsante chiuso = lettura LOW):
Code: [Select]
//-----------------------------------------------
#define PULS  3
#define PULS_PRESS_LEVEL  LOW  //configuraz.pull-up
//-----------------------------------------------
byte precedente = !PULS_PRESS_LEVEL; //non premuto
//-----------------------------------------------
void setup()
{
    pinMode(PULS, INPUT);
}
//-----------------------------------------------
void loop()
{
    byte attuale = digitalRead(PULS);
    if(attuale != precedente)
    {
        precedente = attuale;
        if(attuale == PULS_PRESS_LEVEL)
        {
            //...rilevato istante di pressione...
        }
        else
        {
            //...rilevato istante di rilascio...
        }
    }
    delay(50);
}
//-----------------------------------------------

NOTA: i nomi di comodo PULS e PULS_PRESS_LEVEL sono "etichette" da usare nel resto del programma per non scrivere ogni volta il numeri dei pin o i livelli HIGH/LOW. Qui è poco importante, ma in programmi più grossi aiuta a non fare confusione.

Il delay(50) dipende. In questo caso specifico non fa male, rallenta l'esecuzione della funzione loop a circa 20 cicli al secondo e serve quindi da tempo di debounce per i pulsanti (se non hanno un debounce hardware esterno), ma potrebbe diventare un intralcio se il programma più avanti richiedesse altre temporizzazioni o una velocità maggiore della loop.

Cosa fare nelle righe ...rilevato istante di...? Quello che serve, si possono chiamare delle funzioni (che verranno eseguite una volta solo in quel momento), oppure si possono impostare delle variabili flag da leggere in un altro punto del programma:
Code: [Select]
//-----------------------------------------------
void loop()
{
    boolean onUp = false;
    boolean onDn = false;
    byte attuale = digitalRead(PULS);
    if(attuale != precedente)
    {
        precedente = attuale;
        if(attuale == PULS_PRESS_LEVEL) onDn = true;
        else                            onUp = true;
    }

    if(onDn)
    {
        //...rilevato istante di pressione...
    }

    if(onUp)
    {
        //...rilevato istante di rilascio...
    }

    delay(50);
}
//-----------------------------------------------

NOTA: le variabili onUp e onDn diventano true per un solo ciclo di loop, cioè sono "impulsi" che avvengono solo nel momento in cui si riconosce una pressione o un rilascio, quindi continuando a tenere il pulsante premuto non ci saranno ulteriori riconoscimenti della pressione.

Per i pulsanti collegati a pin analogico alla fine va applicata la stessa idea, ma in più c'è la fase iniziale di lettura e decisione in base ai valori letti.
* * * *    if non è un ciclo   * * * *

* * * Una domanda ben posta è già mezza soluzione. * * *

Ryan0497

Innanzitutto vi ringrazio davvero tanto per le vostre spiegazioni ed esempi che mi stanno aprendo un nuovo mondo nella programmazione (i flag non li ho mai usati e questa è la prima volta che ne apprendo il significato/uso).

Purtroppo trovo complicato capire come funzionano... guardando un po' lo sketch di @Etemenanki, tutti quei numeri tra le parentesi cosa sono e cosa fanno?! Non rispondetemi per il momento perché mi rendo conto che vi faccio perdere troppo tempo.

Guardando lo sketch di Claudio_FF  mi sembra più o meno più semplice e forse più funzionale per il caso mio... mi sono permesso un po' di cambiare i nomi delle variabili per studiarmelo un po' ed ecco cosa ne è uscito:

Code: [Select]
//-----------------------------------------------
#define INVIO  0
#define INVIO_PREMUTO  LOW  //configuraz.pull-up
//-----------------------------------------------
byte precedente = !INVIO_PREMUTO; //non premuto
//-----------------------------------------------
void setup()
{
    pinMode(INVIO, INPUT);
}
//-----------------------------------------------
void loop()
{
    boolean onUp = false;
    boolean onDn = false;
    byte attuale = digitalRead(INVIO);
    if(attuale != precedente)
    {
        precedente = attuale;
        if(attuale == INVIO_PREMUTO) onDn = true;
        else                         onUp = true;
    }

    if(onDn)
    {
        //...rilevato istante di pressione...
    }

    if(onUp)
    {
        //...rilevato istante di rilascio...
    }

    delay(50);
}
//-----------------------------------------------


In questo sketch però non capisco come faccio a far capire ad Arduino che i 5 pulsanti differenti, se sono collegati tutti al pin analogico 0 con diverso valore, devono svolgere una funzione diversa.

Ho visto girando su alcuni forum inglesi in questi giorni, che utilizzano un pin analogico per ogni pulsante, dichiarando che sono pin input e che normalmente non sono premuti. Purtroppo non riesco più a trovarlo quel forum nemmeno più cercando nella cronologia. ricordo che per esempio riuscivano a far accendere un led alla pressione di un pulsante collegato all'A0.

Ora parlando con voi, mi è venuto in mente di utilizzare quel tipo di funzionamento che sembrerebbe essere ottimo per poi richiamarlo nella digitazione del menù. Il problema è che seppur dovesse essere uno sketch davvero semplice non riesco più a trovarlo... qualche idea? In pratica 4 pin analogici verranno trasformati in digitali; serve qualche libreria specifica?

Go Up