Arduino Forum

International => Italiano => Software => Topic started by: Ziostep on Nov 16, 2018, 06:00 pm

Title: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 16, 2018, 06:00 pm
Salve ragazzi,
cerco consigli/esempi per realizzare un progetto con Arduino.
Il progetto che vorrei realizzare consiste nel pilotare con Arduino uno un generatore di aria compressa a 12V e due elettrovalvola a solenoide 12V alimentate a 12V (le elettrovaolvola servono per gonfiare e sgonfiare un manicotto).
Ho inserito un regolatore di tensione a 9V per alimentare l'Arduino e uno switch per aprire e chiudere il circuito. Vi allego lo schema elettrico per vedere nel dettaglio la parte hardware.

Ho abbozzato uno sketch dove gonfio e sgonfio un manicotto tramite la pompa e le elettrovalvole, lasciando per il momento da parte il sensore di pressione.
Considerando che è la prima volta che utilizzo Arduino, aspetto vivamente consigli.
Grazie a tutti.
Title: Re: Pilotare elettrovalvole Arduino
Post by: MatteoDerrico on Nov 16, 2018, 06:15 pm
Ciao

beh lo sketch per adesso è molto semplice, ma già ben impostato :)

quanto riguarda l'elettronica... come mai la scelta di non mettere nessun resistenza sulla base del transistor ?:)

MD
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 16, 2018, 06:24 pm
Ciao Matteo,
essendo il mio primo progetto con Arduino non ho valutato l'inserimento delle resistenze.
Pensi che siano necessarie ed indispensabili?
Grazie
Title: Re: Pilotare elettrovalvole Arduino
Post by: MatteoDerrico on Nov 16, 2018, 06:47 pm
direi di proprio di si...

cerco di spiegarti il perchè :

tu stai cercando di usare (giustamente) il transistor come se fosse un relè... diciamo in modo On/Off...
nel mondo transistor chiamiamo : On-->saturato   Off--> interdetto

ok, per saturate il transistor, per farla semplice, dobbiamo avere 2,5 V sulla base Vbe(sat) (dato preso da datasheet) , cosa che senza resistenza ora come ora gli stiamo dando 5 V... il doppio...

perciò dobbiamo "togliere" 2,5V perchè se 5V escono da arduino, 2,5V devono arrivare sulla base del transistor --> 2,5 V devono cadere sulla resistenza :)

perciò la nostra resistenza serve per comandare correttamente il nostro transistor...

ti lascio questa guida (http://bildr.org/2011/03/high-power-control-with-arduino-and-tip120/) che spiega come usare questi transistor con arduino :)

e come vedi c'è una bella resistenza tra arduino e il tranistor :)

Spero di averti chiarito un po' le idee, e di non aver detto troppe cavolate ahaha

MD

Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 16, 2018, 06:56 pm
Grazie Matteo,
quindi se ho capito bene devo inserire una resistenza da 2.2kohm tra base del tip120 e ll pin di arduino.
Essendo 3 tip120 devo inserire 3 resistenze da 2.2kohm ciascuna? Corretto?
Title: Re: Pilotare elettrovalvole Arduino
Post by: MatteoDerrico on Nov 16, 2018, 06:58 pm
esatto ... ogni cavo che adesso parte da Arduino e va verso la base... gli metti una resistenza ... ogni singolo ramo :)

MD
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 16, 2018, 07:02 pm
ok perfetto, grazie.

Se volessi aggiungere la funzione millis nello sketch e quindi gonfiar e sgonfiare ogni tot secondi come posso implementare il codice?
Title: Re: Pilotare elettrovalvole Arduino
Post by: MatteoDerrico on Nov 16, 2018, 07:10 pm
se è per fare delle prove, ti consiglio la funzione delay... ma se vuoi usare millis perchè poi ti serve più avanti averlo già implementato :

beh molto semplice.... potresti spulciare negli esempi-> digital -> Blink without Delay

:)

se c'è qualcosa che non ti torna o non capisci chiedi pure :)

MD
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 16, 2018, 07:41 pm
Grazie Matteo,
dovendo inserire il sensore di pressione che monitori appunto la pressione all'interno del manicotto, attraverso cui verranno pilotate le elettrovalvole e la pompa per raggiungere ed eventualmente mantenere una determinata pressione, forse è opportuno utilizzare millis come funzione in quanto utilizziamo tempi piccoli nel processo.
Cosa ne pensi?
Title: Re: Pilotare elettrovalvole Arduino
Post by: MatteoDerrico on Nov 17, 2018, 04:44 am
dipende tutto da come deve funzionare il sistema... ovvero che funzione ha sto sensore?

conviene che ci spieghi come deve funzionare il tutto per poterti aiutare :)

MD
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 17, 2018, 08:54 am
Quote from: Ziostep
forse è opportuno utilizzare millis come funzione in quanto utilizziamo tempi piccoli nel processo
Al solito, non si tratta di millis vs delay, ma di struttura: http://forum.arduino.cc/index.php?topic=520666.msg3551257#msg3551257 (http://forum.arduino.cc/index.php?topic=520666.msg3551257#msg3551257)

Usare millis o piccoli delay dipende solo dalla precisione temporale che serve: http://forum.arduino.cc/index.php?topic=534874.msg3652203#msg3652203 (http://forum.arduino.cc/index.php?topic=534874.msg3652203#msg3652203)

Qui due esempi, uno con millis e uno con delay che fanno la stessa cosa, entrambi strutturati in modo da non bloccare mai l'esecuzione veloce del ciclo di loop: http://forum.arduino.cc/index.php?topic=523919.msg3576847#msg3576847 (http://forum.arduino.cc/index.php?topic=523919.msg3576847#msg3576847)
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 17, 2018, 10:38 am
Ragazzi grazie per i consigli e gli interventi, cerco di spiegare al meglio l'intero progetto così da poter chiarire le vostre idee.

Sto cercando di realizzare un manicotto dalla circonferenza di 16/20cm (simile allo sfigmomanometro della pressione arteriosa) da posizionare attorno al polso. Il manicotto tramite insufflazione di aria prodotta dalla pompa e fatta passare attraverso la prima elettrovalvola (range da 0-350 mmhg), fa espandere il manicotto esercitando una pressione attorno al polso (non devo misurare la pressione sanguigna, devo solo effettuare una compressione attorno al polso). Quindi la massima pressione attorno al polso è di 350mmhg.

Prima operazione da fare attraverso il sensore di pressione è conoscere la pressione all'interno del manicotto tale da poterla tenere costante per un top di tempo. Ovviamente non essendo tutti uguali i polsi il sensore deve lavorare in un range. Il sensore ancora non è stato scelto in quanto non so quale prendere.

Dopo aver raggiunto la pressione desiderata e mantenuta per un top di secondi, la seconda elettovalvola fa uscire l'aria dal manicotto inibendo la pompa.
In linea di massima il progetto è questo.

Grazie a tutti.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 17, 2018, 11:21 am
Quote from: Ziostep
cerco di spiegare al meglio l'intero progetto così da poter chiarire le vostre idee
Ok, hai descritto il tutto nei termini del dominio applicativo, ora riesci (in base a quanto hai descritto) a sintetizzare le diverse situazioni in cui si può venire a trovare il sistema con dei semplici nomi che le descrivono? Questi saranno gli stati del sistema (io ne vedo almeno cinque, il primo sicuramente è RIPOSO/IDLE).

Dopo di che ti basta decidere a quali eventi/condizioni prestare attenzione in ogni stato, e cosa fare quando l'evento accade (compreso eventualmente quale nuovo stato diventa attivo).

Ad esempio nello stato RIPOSO interessa solo avvertire il comando di avvio (pulsante/switch), e nel caso di comando attivato dare inizio al gonfiaggio rendendo attivo lo stato successivo (che sicuramente sarà GONFIA/INFLATE).
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 17, 2018, 04:50 pm
Ciao Claudio,
guarda nel mio primo post ho caricato già lo sketch riferito al gonfiare/sgonfiare considerando la posizione dello switch. E' semplice come codice ma son partito da li.

Non ho capito bene cosa intendi per suddividere per stati tutto il processo. Penso tu ti stia riferendo ad:
1 stato: riposo
            Verificare la posizione dello switch

2 stato: Se lo switch si trova in alto
             Allora attiva la pompa e gonfia

Ti riferisci ad un suddivisione degli eventi di questo tipo?
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 17, 2018, 06:30 pm
Quote from: Ziostep
guarda nel mio primo post ho caricato già lo sketch riferito al gonfiare/sgonfiare considerando la posizione dello switch. E' semplice come codice ma son partito da li.
Manca la lettura dello switch.



Quote
Non ho capito bene cosa intendi per suddividere per stati tutto il processo. Penso tu ti stia riferendo ad:
1 stato: riposo
            Verificare la posizione dello switch

2 stato: Se lo switch si trova in alto
             Allora attiva la pompa e gonfia

Ti riferisci ad un suddivisione degli eventi di questo tipo?
Quasi, il tuo codice è stateless e reattivo, quello che fa dipende direttamente e solo dall'ingresso, e non ha memoria di quello che eventualmente è stato fatto prima (le situazioni attraversate).

Per me gli stati che hai elencato nella descrizione sono:
- IDLE (attesa comando)
- INFLATE (gonfiaggio, attesa pressione alta)
- PAUSE (pausa tot secondi, non so se serve fare anche un REFILL se la pressione scende)
- DEFLATE (sgonfiaggio, attesa pressione bassa)

ed eventualmente un ulteriore stato di attesa WAIT_NO_COMMAND per aspettare che lo switch sia riportato in posizione disattiva e non ripartire subito con un nuovo gonfiaggio.

Si possono definire delle etichette di comodo:
Code: [Select]
#define   IDLE            0
#define   INFLATE         1
#define   PAUSE           2
#define   DEFLATE         3
#define   WAIT_NO_COMMAND 4

Una variabile globale per memorizzare lo stato, che parte da IDLE
Code: [Select]
byte state = IDLE;
E nel loop una struttura decisionale che elabora solo lo stato attivo in quel momento. È come avere diversi programmi (i casi) di cui uno solo alla volta viene eseguito, quello corrispondente alla situazione attuale del sistema indicata dalla variabile 'state':
Code: [Select]
switch(state)
{
    case IDLE:
        break;

    case INFLATE:
        break;

    case PAUSE:
        break;

    case DEFLATE:
        break;

    case WAIT_NO_COMMAND:
        break;
}

Quando siamo in IDLE l'unica cosa che interessa è sentire il comando di avvio:
Code: [Select]
   case IDLE:
        if(...lettura pin switch... == ...livello attivo...) {
            ...avvia gonfiaggio...
            state = INFLATE; // <--- nuovo stato attivo
            }
        break;

eccetera...
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 18, 2018, 12:01 pm
Grazie Claudio,
provo a scrivere lo sketch seguendo questo schema logico, essendo alle prime armi con Arduino non conoscevo queste funzioni, quindi grazie.

Caricherò lo sketch quanto prima, grazie per l momento.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 18, 2018, 12:18 pm
Lo switch è come un if con tante scelte mutuamente esclusive, questo fa la stessa cosa, procedendo dall'alto al basso viene eseguito solo il primo ramo trovato vero (o nessuno se nessuna condizione risulta vera):
Code: [Select]
if(state == IDLE) {
}
else if(state == INFLATE) {
}
else if(state == PAUSE) {
}
else if(state == DEFLATE) {
}
else if(state == WAIT_NO_COMMAND) {
}
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 18, 2018, 12:37 pm
Grazie Claudio,
ti carico lo sketch così mi dici se ho capito quello che volevi dirmi e se sto facendo bene.
Grazie davvero.

P.s.: ho visto solo adesso questo tuo post, perdonami.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 18, 2018, 04:33 pm
Manca sempre la digitalRead per leggere lo switch.

L'else (oltre che scritto sbagliato) non serve: nello stato IDLE non ci interessa sapere se lo switch è disattivo.

Volendo anche per dare dei nomi di comodo ai vari pin si possono usare le define, non serve a niente creare delle variabili a 16 bit da usare come costanti che occupano solo memoria.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 18, 2018, 04:51 pm
Manca sempre la digitalRead per leggere lo switch.
Questa riga di comando non ho capito dove inserirla.

Non sono sicuro di aver scritto bene, inoltre, ho corretto lo sketch come dici tu.
Ovviamente è da finire lo sketch ma ho carico il file per vedere se scritto così è più corretto.
Title: Re: Pilotare elettrovalvole Arduino
Post by: MatteoDerrico on Nov 18, 2018, 09:45 pm
ciao ti consiglio di cambiare nome a IDLE, perchè come vedi si colora di blu da solo, ciò vuol dire che è un qualcosa di già utilizzato all'interno del core di Arduino.

Lascio la parola ai più esperti, però nel dubbio io cambierei il nome :)

MD
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 18, 2018, 09:58 pm
Ah, vero, c'è sempre il rischio di scrivere qualche nome già predefinito.
Si potrebbe cambiare in ONIDLE.
A parte un ; svista il resto è tutto corretto.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 19, 2018, 10:17 am
Grazie ragazzi,

ulteriore dubbio.

Nel passare dallo stato ONILDE --> INFLATE (INFLATE-->PAUSE ECC) non so scrivere il codice in quanto non riesco a capire bene come funzioni Switch/case in arduino... :smiley-roll-sweat:  :smiley-roll-sweat:

Scusate ma sto facendo il massimo per capire il linguaggio nel più breve tempo possibile.
Grazie ancora.

P.s.: ho caricato lo sketch dove ho provato ad implementare lo stato WAIT_NO_COMMAND, non sono sicuro di aver fatto bene.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 19, 2018, 11:14 am
Quote from: Ziostep
non riesco a capire bene come funzioni Switch/case in arduino
Come il codice del post #16

Quote
ho provato ad implementare lo stato WAIT_NO_COMMAND, non sono sicuro di aver fatto bene
Il caso WAIT_NO_COMMAND serve solo ad attendere che l'interruttore sia portato nello stato non attivo se per caso non lo è già.
Code: [Select]
   case WAIT_NO_COMMAND:
            if (digitalRead(SWITCHPIN) == LOW) state = ONIDLE;
            break;                      



IL commento "stato che memorizza il case eseguito" sarebbe più corretto: "variabile che memorizza lo stato corrente", di fatto lo stato corrente corrisponde al case eseguito.

Se durante la pausa serve anche mantenere la pressione tramite "rabbocchi" allora bisogna aggiungere uno stato REFILL, e si potrà andare avanti e indietro diverse volte tra i due stati PAUSA e REFILL a seconda del valore letto della pressione.

Con la logica ci sei quasi, in ogni case un if corrisponde a un evento che si vuole gestire, e il contenuto dell'if alle azioni in risposta all'evento. Lo stop sgonfiaggio va dentro il caso DEFLATE, non dentro il WAIT_NO_COMMAND.
Code: [Select]
    case DEFLATE:
        if(raggiunta la pressione minima nel manicotto) { // <----EVENTO
            digitalWrite(INTELVALVEPIN, LOW);             // <----AZIONI
            digitalWrite(PUMPPIN, LOW);
            digitalWrite(EXAUSTVALVEPIN, LOW);
            digitalWrite(LED, LOW);
            state = WAIT_NO_COMMAND;
            }
         break;

Non serve (anzi non si deve) usare delay da nessuna parte, altrimenti l'esecuzione dei casi si blocca.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 19, 2018, 11:26 am
Grazie Claudio,
adesso il codice inizia ad essere più chiaro.
Inizio, finalmente, a comprendere anche la logica dello switch/case.

Continuo e cerco di inserire anche il codice per il sensore di pressione.
Grazie per il momento.


P.s.: Nel DEFLATE
       digitalwrite(EXHASTVALVEPIN, HIGH); e non LOW altrimenti l'aria non esce e si blocca a quella pressione il tutto.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 19, 2018, 12:20 pm
P.s.: Nel DEFLATE
        digitalwrite(EXHASTVALVEPIN, HIGH); e non LOW altrimenti l'aria non esce e si blocca a quella pressione il tutto.
Nel DEFLATE le azioni vengono eseguite a sgonfiaggio già terminato (evento pressione zero).
L'avvio dello sgonfiaggio avviene quando nel PAUSE si rileva l'evento timeout.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 19, 2018, 12:37 pm
Quindi devo seguire questa logica??
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 19, 2018, 06:19 pm
La logica è esattamente come la si descriverebbe in italiano:
Code: [Select]
Quando sono in attesa (ONIDLE)
    se comando attivo -> avvia gonfiaggio -> INFLATE
    
Quando sto gonfiando (INFLATE)
    se pressione massima -> ferma gonfiaggio e
                            annota tempo attuale -> PAUSE

Quando sono in pausa (PAUSE)
    se trascorsi N secondi -> avvia sgonfiaggio -> DEFLATE
    altrimenti se pressione bassa -> avvia gonfiaggio -> REFILL

Quando sto rabboccando (REFILL)
    se trascorsi N secondi -> avvia sgonfiaggio -> DEFLATE
    altrimenti se pressione massima -> ferma gonfiaggio -> PAUSE

Quando sto sgonfiando (DEFLATE)
    se pressione minima -> ferma sgonfiaggio -> WAIT_NO_COMMAND

Quando sto attendendo nessun comando (WAIT_NO_COMMAND)
    se comando disattivo -> ONIDLE

Poi questa è una logica di partenza, su un sistema reale io vorrei poter interrompere il processo in qualsiasi momento, e far fronte ai guasti della sonda pressione (ad esempio aggiungendo dei timeout). Ma queste modifiche sono solo altre semplici righe descrittive da aggiungere ai "quando" (gli stati/situazioni), o altre situazioni, ad esempio uno stato ERROR.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 19, 2018, 06:40 pm
Ovviamente devo aggiungere il sensore di pressione collegandolo al pin analogico.
Saranno modifiche che dovrò apportare in quanto deve funzionare in real-time il sistema e deve poter essere adattato alle situazioni.

Comunque grazie Claudio, essendo alle prime armi con Arduino devo prendere un po la mano.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 20, 2018, 10:37 am
Ciao Claudio,
seguendo la tua guida sto scrivendo così lo sketch ( in allegato).
Riscontro un bel problema sul come inserire il codice per il sensore e quindi mettere la condizione nello stato dell'if facente riferimento sempre al sensore.

Hai ulteriori direttive in merito? :smiley-sweat:
Title: Re: Pilotare elettrovalvole Arduino
Post by: Datman on Nov 20, 2018, 10:46 am
Usando nel programma parole italiane come attesa, gonfia, sgonfia, pausa non si correrebbe il rischio di creare conflitti con parole "proibite". Un francese non si sognerebbe nemmeno di scrivere parole in inglese! :-)
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 20, 2018, 10:54 am
Ciao DATMAN,
grazie per la direttiva, ma sembra che non ci siano parole proibite all'interno del codice...
Ma ho sostituito gli stati in italiano e anche il resto.
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 20, 2018, 11:45 am
Allora si può scrivere proprio tutto in italiano, così la logica è perfettamente leggibile:
Code: [Select]
switch(stato)
{
    case RIPOSO:
        if (comando_attivo()) {
            avvia_gonfiaggio();
            stato = GONFIAGGIO;
            }
        break;

    case GONFIAGGIO:
        if(pressione_massima()) {
            fermo();
            annota_tempo();
            stato = PAUSA;
            }
        break;

    case PAUSA:
        if(trascorsi(10000)) {
            avvia_sgonfiaggio();
            stato = SGONFIAGGIO;
            }
        else if(pressione_bassa()){
            avvia_gonfiaggio();
            stato = RABBOCCA;
            }
        break;

    case RABBOCCA:
        if(trascorsi(10000)) {
            avvia_sgonfiaggio();
            stato = SGONFIAGGIO;
            }
        else if(pressione_massima()){
            fermo();
            stato = PAUSA;
            }
        break;

    case SGONFIAGGIO:
        if(pressione_minima()) {
            fermo();
            stato = ATTENDI_NO_COMANDO;
            }
        break;

    case ATTENDI_NO_COMANDO:
        if (!comando_attivo()) stato = RIPOSO;
        break;                      
}

Dopo di che restano da scrivere le brevi funzioncine che vengono richiamate (per quasi tutte credo basti una sola riga).
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 20, 2018, 12:03 pm
Sto facendo bene così???

Title: Re: Pilotare elettrovalvole Arduino
Post by: Datman on Nov 20, 2018, 12:10 pm
Devi mettere le condizioni pressione bassa, pressione massima, ...
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 20, 2018, 02:06 pm
Si lo so DATMAN,
volevo sapere se il resto era tutto corretto.

Inoltre, non avendo acquistato ancora il sensore il codice lo posso scrivere oppure devo tenere a mente casi particolari??

Ovviamente ho il datasheet del sensore che voglio usare, quindi so la Vcc,Vout e il range di pressioni in mmhg di utilizzo.

Grazie
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 20, 2018, 05:13 pm
Che cos'è:
sensorValue = analogRead (AnalogInPin);   //annota pressione attuale
??

Da leggersi come:

quando sto gonfiando
    se pressione massima
        spegni valvole
        annota pressione attuale
        passa a pausa
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 23, 2018, 10:25 am
Scusa Claudio non mi sono spiegato bene,
nello sketch è stato definito lo switch/case con i vari stati, fin qui tutto perfetto.

Devo dichiarare il sensore di pressione all'interno del codice ( non è stato ancora acquistato, mi serve un consiglio sull'acquisto). Vorrei acquistare un sensore con un buon range di misura, spendendo poco se possibile, tenendo a mente che le elettrovalvole hanno  range di 0-350 mmhg.

Ti allego il link di quello che vorrei prendere ' Sensore di pressione Relativa MPX5700GP, pressione massima 700kPa '. Volutamente voglio prendere un sensore con un range maggiore dell' elettrovalvole oggi utilizzate per poter fare un UPGRADE futuro cambiando solo le elettrovalvole.

Negli STATI devo leggere la pressione presente all'interno del manicotto, tramite lettura del sensore di pressione, e passare da uno stato all'altro in funzione della pressione letta.

Se la pressione nello STATO è nel RangeMax allora si ferma il gonfiaggio, il RangeMax deve essere mantenuto per tot secondi e la pressione deve essere stampata sul computer.

Adesso posso passare allo STATO successivo.

Stavo cercando di scrivere proprio questo, pensavo che con " sensorValue = analogRead (AnalogInPin);" andavo a leggere il valore del sensore.

Spero di aver chiarito le idee :smiley-confuse:  :smiley-confuse:
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 23, 2018, 06:33 pm
Quote from: Ziostep
Stavo cercando di scrivere proprio questo, pensavo che con " sensorValue = analogRead (AnalogInPin);" andavo a leggere il valore del sensore.
Si, la lettura è giusta, quello che chiedevo era il significato di metterla quel punto li, cioè in un punto dove significa: "quando è stata rilevata la pressione massima allora annoto la pressione". Mi domandavo se quella "annotazione" (ben diversa da quella che ho scritto io nelle spiegazioni precedenti) avesse uno scopo in previsione di qualcosa da implementare.

Per il resto la pressione basta leggerla prima dello switch (saranno da fare delle calibrazioni per far corrispondere le scale).
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 23, 2018, 06:55 pm
Se ho capito bene quello che vuoi dire è:

case GONFIAGGIO:
        if(analogRead (AnalogInPin)>=Pmax) {           // leggo la pressione e la confronto  con il valore
         digitalWrite(INTELVALEPIN, LOW);                 //smetto di gonfiare
         digitalWrite(PUMPPIN, LOW);
         stato = PAUSA;                                            //passo allo stato successivo                                        
         }
         break;

Ovviamente io vorrei sapere se la pressione è di 302/310/306, vorrei stamparla a video sul computer ma non so scrivere il codice, inoltre, la lettura della pressione non ho capito se va fatta in PAUSA.
Non so se sia giusto quello che ho scritto sopra.

grazie Claudio
Title: Re: Pilotare elettrovalvole Arduino
Post by: Ziostep on Nov 24, 2018, 05:25 pm
Arrivo a questo punto e mi blocco nella stesura del codice. Non capisco come mettere la condizione sul tempo e se la lettura del sensore è giusta.

Grazie, in allegato lo sketch
Title: Re: Pilotare elettrovalvole Arduino
Post by: Claudio_FF on Nov 24, 2018, 08:47 pm
Quote from: Ziostep
Non capisco come mettere la condizione sul tempo
Funzione millis (http://spectrum.altervista.org/funzione-millis/), paragrafi "annotare il tempo attuale" e "calcolare il tempo trascorso".

Per quanto riguarda leggere la pressione e convertirla nella scala voluta forse meglio aprire un thread apposito.