Jump to content
PLC Forum


dnmeza

Prova differenziale con Arduino nano

Recommended Posts

dnmeza

allego il codice e lo schema, sicuramente qualche esperto piu di me, che mi sto approcciando a questo hardware, per corregerlo o migliorarlo.

 

//    Prova del Salvavita
// include the library code:
#include <LiquidCrystal.h>

// initialize the library by associating any needed LCD interface pin
// with the arduino pin number it is connected to
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
/*
Prova differenziale, schema di prova ricavato da nuova elettronica

 */
//
unsigned long ti=0; //tempo iniziale
unsigned long tf=0; //tempo finale
unsigned long tt=0; //delta tempo
//--------------------------------------------setup------------------------------------------------
void setup() {
 
 pinMode(5, OUTPUT);
 pinMode(4, OUTPUT);
 pinMode(3, INPUT);
 Serial.begin(9600);

//  lcd.print("prova differenziale");
}
//---------------------------------------------inizio-----------------------------------------
void loop() {
 
  lcd.home (); // set cursor to 0,0
  lcd.print("Inizio Prova");  
    lcd.clear();
    lcd.display();
    lcd.setCursor(0, 0); // top left
    //_________________________________________________________________________________-
  inizio:
 //primo ciclo da quando si accende per definire il tempo del primo impulso
 if(ti==0){
   while(digitalRead(3)!=HIGH){  //legge lo stato dell'ingresso 3 per avviare lo start
    }
   ti=millis();
   lcd.print(millis());
   while(digitalRead(3)!=LOW){  //legge lostato del pulsante ingresso 3 per avviare lo scatto
  }
 }
 //-------------------------------------------------primo scatto--------------------------
 while(digitalRead(5)!=HIGH){ //provoca lo scatto
 }
 tf=millis();
 tt=tf-ti;
 Serial.print(tt);
 Serial.print("  ");

 lcd.print("secondi:");
 lcd.print(tt);  

 ti=tf;
 while(digitalRead(5)!=LOW){
  delay(60000); // attesa di un minuto
 }
//--------------------------------------------azzerramento dei tempi per seconda prova
 ti=0;
 tf=0;
 tt=0;
 //------------------------------------------------secondo scatto-------------------------------
 //secondo ciclo da quando si accende per definire il tempo del primo impulso
 if(ti==0){
   while(digitalRead(3)!=HIGH){  //legge lo stato dell'ingresso 3 per avviare lo start
    }
   ti=millis();
   lcd.print(millis());
   while(digitalRead(3)!=LOW){  //legge lostato del pulsante ingresso 3 per avviare lo scatto
  }
 }
 //-------------------------------------------------secondo scatto--------------------------
 while(digitalRead(4)!=HIGH){ //provoca lo scatto
 }
 tf=millis();
 tt=tf-ti;
 Serial.print(tt);
 Serial.print("  ");

 lcd.print("secondi:");
 lcd.print(tt);  

 ti=tf;
 while(digitalRead(4)!=LOW){
 }
}

Arduino controllo differenziale.png

Share this post


Link to post
Share on other sites

dott.cicala

Ho capito cosa vuoi fare: Il circuito di NE migrato su Arduino.

Però, se è alimentato dalla rete e al test il differenziale interviene, tutto il circuito rimarrà senza alimentazione?

 

Mi sembra di capire che gli impulsi di comando dei MOC li ottieni tramite gruppi RC, ma per tempi certi e precisi sarebbe meglio farlo da firmware e magari

far girare la parte che li genera ed esegue la misura in una routine di interrupt....

 

Io non ho il nano ma penso che si possa provare anche con l'uno, ho pure tutti i componenti nel cassetto, ma qui nasce il vero dilemma:

 

Per far le prove devo continuamente far saltare la corrente? Mi ammazzano! :lol:

Già quelle poche volte che salta, magari per il maltempo....vengono a chedermi  con tono minaccioso  "Cos hai attaccato?! :angry: "

Share this post


Link to post
Share on other sites
gabri-z
39 minuti fa, dott.cicala scrisse:

Per far le prove devo continuamente far saltare la corrente?

A tutta quella apparecchiatura che possiedi , potresti aggiungere un differenziale , per lo studio soltanto , te lo alimenti dal trafo separatore , aggiungi la vera terra et voilà...

Credo che valga per evitare di sentire :

39 minuti fa, dott.cicala scrisse:

"Cos hai attaccato?!

 

 

Edited by gabri-z

Share this post


Link to post
Share on other sites
ilguargua

Nel setup() manca l'inizializzazione del display lcd.begin(cols, rows).

 

 

Ciao, Ale.

Share this post


Link to post
Share on other sites
Daniele Orisio
Quote

Mi sembra di capire che gli impulsi di comando dei MOC li ottieni tramite gruppi RC, ma per tempi certi e precisi sarebbe meglio farlo da firmware e magari

 far girare la parte che li genera ed esegue la misura in una routine di interrupt....

 

Concordo. Aggiungo che, secondo me, sarebbe opportuno scrivere il firmware con Atmel studio in modo da avere una generazione dei tempi molto più precisa. Se cerchi qualche video su youtube scoprirai che il delay di arduino non è molto accurato.

Share this post


Link to post
Share on other sites
dnmeza
1 ora fa, ilguargua scrisse:

Nel setup()

hai ragione ma sembrava mi funzionasse, ora son senza LCD perchè sto costruendo l'harware, comunque lo inserisco, grazie del suggerimento

 ... ora l'ho inserito

Share this post


Link to post
Share on other sites
ilguargua
4 ore fa, dnmeza scrisse:

while(digitalRead(5)!=HIGH){ //provoca lo scatto
 }

Ma questi costrutti che usi spesso nel tuo codice sei sicuro che funzionino? Perchè leggere (digitalRead()) il pin 5 (che è un uscita) dovrebbe provocare lo scatto? C'è qualcosa che mi sfugge?

 

 

Ciao, Ale.

Share this post


Link to post
Share on other sites
dnmeza

sicuramente nelle varie modifiche, ho sbagliato a scrivere, dovrei scrivere digitalWrite(5) per mandare il piedino 5 alto (5Volt) per attivare il moc e mettere a massa la fase tramite la resistenza da 6,8 kohm

7 minuti fa, ilguargua scrisse:

sei sicuro che funzionino?

mi ero messo a costruire l'harware, ed è da almeno 15 gg che non controllo, grazie delle Tue correzioni

 

 

 

Share this post


Link to post
Share on other sites
dnmeza

avevo proprio sbagliato file nel selezionarlo,

questo sarebbe l'ultima corretta

 

//    Prova del Salvavita
// include the library code:
#include <LiquidCrystal.h>

// initialize the library by associating any needed LCD interface pin
// with the arduino pin number it is connected to
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
/*
Prova differenziale, schema di prova ricavato da nuova elettronica

 */
//
unsigned long ti=0; //tempo iniziale
unsigned long tf=0; //tempo finale
unsigned long tt=0; //delta tempo
int pin ;
//--------------------------------------------setup------------------------------------------------
void setup() {
 lcd.begin(16, 2);
 pinMode(11, OUTPUT);
 pinMode(5, OUTPUT); // Scatto prima fase/neutro
 pinMode(4, OUTPUT); // Scatto seconda Fase/Neutro
 pinMode(3, INPUT_PULLUP); // pulsante di avvio scatto
 pinMode(2, INPUT_PULLUP); // rilevamento presenza tensione
 Serial.begin(9600);

//  lcd.print("prova differenziale");
}
//---------------------------------------------inizio-----------------------------------------
void loop() {
 
  lcd.home (); // set cursor to 0,0
  lcd.print("Inizio Prova");  
    lcd.clear();
    lcd.display();
    lcd.setCursor(0, 0); // top left
    //_________________________________________________________________________________-
  inizio:
 //primo ciclo da quando si accende per definire il tempo del primo impulso
 if(ti==0){
   while(digitalRead(3)!=HIGH){  //legge lo stato dell'ingresso 3 per avviare lo start
   tone(11, 440);
    }
   ti=millis();
 
   while(digitalRead(3)!=LOW){  //legge lostato del pulsante ingresso 3 per avviare lo scatto
 
  tone(11, 600);
  }
 }
 //-------------------------------------------------primo scatto--------------------------
 digitalWrite(5,HIGH);//provoca lo scatto
 
 while(digitalRead(2)!=HIGH){ //controlla la mancanza di tensione sul pin 2
 }
 
 if (digitalRead(2)!=LOW) {
 tf=millis();
 tt=tf-ti;
 Serial.print(tt);
 Serial.print("  ");
 lcd.print("secondi:");
 lcd.print(tt);  
 }
 ti=tf;
 (digitalWrite(5,LOW));
  delay(1200000); // attesa di un 2 minuti
 
 
//--------------------------------------------azzerramento dei tempi per seconda prova
 ti=0;
 tf=0;
 tt=0;
 //------------------------------------------------secondo scatto-------------------------------
 //secondo ciclo da quando si accende per definire il tempo del primo impulso
 if(ti==0){
   while(digitalRead(3)!=HIGH){  //legge lo stato dell'ingresso 3 per avviare lo start
    tone(11, 440);
    }
   ti=millis();
   lcd.print(millis());
   while(digitalRead(3)!=LOW){  //legge lostato del pulsante ingresso 3 per avviare lo scatto
    tone(11, 600);
  }
 }
 //-------------------------------------------------secondo scatto--------------------------Write while(digitalWrite(4)!=HIGH){ //provoca lo scatto
  if(ti==0){
   while(digitalRead(3)!=HIGH){  //legge lo stato dell'ingresso 3 per avviare lo start
   tone(11, 440);
    }
   ti=millis();
 
   while(digitalRead(3)!=LOW){  //legge lostato del pulsante ingresso 3 per avviare lo scatto
 
  tone(11, 600);
  }
 }
 //-------------------------------------------------primo scatto--------------------------
 digitalWrite(5,HIGH); //provoca lo scatto
 while(digitalRead(2)!=HIGH){ //controlla la mancanza di tensione sul pin 2
 }
 if (digitalRead(2)!= LOW) {
 tf=millis();
 tt=tf-ti;
 Serial.print(tt);
 Serial.print("  ");
 lcd.print("secondi:");
 lcd.print(tt);  
 }
 ti=tf;
 digitalWrite(5,LOW);
  delay(1200000); // attesa di un 2 minuti
 
 
//--------------------------------------------azzerramento dei tempi per seconda prova
 ti=0;
 tf=0;
 tt=0;
 //------------------------------------------------secondo scatto-------------------------------
 //secondo ciclo da quando si accende per definire il tempo del primo impulso
 if(ti==0){
   while(digitalRead(3)!=HIGH){  //legge lo stato dell'ingresso 3 per avviare lo start
    tone(11, 440);
    }
   ti=millis();
   lcd.print(millis());
   while(digitalRead(3)!=LOW){  //legge lostato del pulsante ingresso 3 per avviare lo scatto
    tone(11, 600);
  }
 }
 //-------------------------------------------------secondo scatto--------------------------Write while(digitalWrite(4)!=HIGH){ //provoca lo scatto
  if(ti==0){
   while(digitalRead(3)!=HIGH){  //legge lo stato dell'ingresso 3 per avviare lo start
   tone(11, 440);
    }
   ti=millis();
 
   while(digitalRead(3)!=LOW){  //legge lostato del pulsante ingresso 3 per avviare lo scatto
 
  tone(11, 600);
  }
 }
 //------------------------------------------------- scatto--------------------------
 digitalWrite(4,HIGH); //provoca lo scatto
  while(digitalRead(2)!=HIGH){ // controlla la mancanza di tensione sul pin 2
 }
 if (digitalRead(2)!= LOW) {
 tf=millis();
 tt=tf-ti;
 Serial.print(tt);
 Serial.print("  ");
 lcd.print("secondi:");
 lcd.print(tt);  
 }
 ti=tf;
 digitalWrite(4,LOW);
  delay(300000); // attesa di un 5 minuti
}

 

Arduino controllo differenziale.png

Share this post


Link to post
Share on other sites
dott.cicala

Io ho buttato giù la mia versione, che è anche la mia prima prova con Arduino, quindi molti aspetti ancora li ignoro. Sembra funzionare.

Ho evitato l'uso di interrupts e la generazione di impulsi precisi. Il principio è molto semplice:

Genero un impulso di max 500ms per ogni moc e misuro il tempo di intervento.

Il primo che fa saltare il differenziale conclude il test e spegne il MOC.

Per simulare lo scatto ho mandato su un BJT l'uscita che comanda un MOC a scelta, in questo modo appena arriva il comando, l'ingresso che monitorizza la rete va basso, simulando appunto lo scatto.

Misurando con l'oscilloscopio la durata dell'impulso è di 6ms...una scheggia :superlol:.

 

/*
 Prova SalvaVita
 */
//********************************************************************************
  #include <LiquidCrystal.h>
  LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

  int Monitor =2;  //Presenza rete
  int Button  =3;  //Pulsante start
  int MOC1    =4; 
  int MOC2    =5;
  int Step    =0;

  unsigned long StartTime =0;
  unsigned long ElapsedTime =0;
  bool Memoria = LOW;
//********************************************************************************
void setup() {
  pinMode(Monitor, INPUT);
  pinMode(Button, INPUT);
  pinMode(MOC1, OUTPUT);
  pinMode(MOC2, OUTPUT);
  lcd.begin(16, 2);
  lcd.print("Test SalvaVita");
  delay(2000);
  lcd.clear();
}
//********************************************************************************
void loop()
  {
      switch(Step)
        {
          case 0: //**** Verifico presenza rete ***********************************
                  if(digitalRead(Monitor)==LOW)
                    {
                      lcd.setCursor(0,1);   
                      lcd.print("Assenza Rete!");
                    }
                  if(digitalRead(Monitor)==HIGH)
                    {
                      lcd.clear();                   
                      Step=1;
                    }
                   break;
                   
           case 1: //**** Verifico pulsante START *********************************                   
                  if(digitalRead(Button)==HIGH)
                    {
                      digitalWrite(MOC1, LOW);
                      digitalWrite(MOC2, LOW);
                      Memoria=LOW;
                      lcd.setCursor(0,1);   
                      lcd.print("...Premi Start..");
                    } 
                            
                  if(digitalRead(Button)==LOW)
                    { 
                      lcd.clear();
                      lcd.setCursor(0,1);   
                      lcd.print("...Avvio test!!!");                 
                      delay(1500);
                      lcd.clear();
                      StartTime=0;   
                      Step=2;
                    }
                  break;
                  
          case 2: //**** Attivo MOC1 **********************************************
                  lcd.clear();
                  StartTime=millis();
                  digitalWrite(MOC1, HIGH);
                  if (digitalRead(Monitor)==LOW)
                      {
                        Memoria=HIGH;
                      } 
                  Step=3;
                  break;
                  
          case 3: //**** Scatto 1 Avvenuto ****************************************
                  if((digitalRead(Monitor)==LOW)||(Memoria==HIGH))
                    { 
                      ElapsedTime=((millis())-StartTime)+6;
                      digitalWrite(MOC1, LOW);
                      lcd.clear();
                      lcd.setCursor(0,0);
                      lcd.print("Intervenuto in");
                      lcd.setCursor(0,1); 
                      lcd.print("ms:");   
                      lcd.print(ElapsedTime);
                      
                      //**** Responso Scatto 1 ************************************
                      if(ElapsedTime<=56)
                        {
                          lcd.print("   Test OK");
                        }
                      if(ElapsedTime>56)
                        {
                          lcd.print("   Test KO");
                        }
                      Step=100; 
                    }
                    
                  //**** Attesa scatto 1 ******************************************
                  if((digitalRead(Monitor)==HIGH)&&(Memoria==LOW))
                    { 
                      ElapsedTime=(millis())-StartTime;
                      if(ElapsedTime<=494)
                        { 
                          lcd.clear();
                          lcd.setCursor(0,0);
                          lcd.print("Attesa scatto 1");
                        }
                        
                      //**** Time Out Scatto 1 ************************************
                      if(ElapsedTime>494)
                        { 
                          digitalWrite(MOC1, LOW);
                          lcd.clear();
                          lcd.setCursor(0,0);  
                          lcd.print("Non Intervenuto");
                          lcd.setCursor(0,1);
                          lcd.print("ms:"); 
                          lcd.print(ElapsedTime);  
                          lcd.print(" Attendi");
                          delay(2000);
                          lcd.clear();
                          StartTime=0;
                          Memoria=LOW;   
                          Step=4;
                        }
                    }
                  break; 
                   
          case 4: //**** Attivo MOC2 **********************************************
                  StartTime=millis();
                  digitalWrite(MOC2, HIGH);
                  if (digitalRead(Monitor)==LOW)
                      {
                        Memoria=HIGH;
                      } 
                  Step=5;
                  break;               

           case 5: //**** Scatto 2 Avvenuto ***************************************
                  if((digitalRead(Monitor)==LOW)||(Memoria==HIGH))
                    { 
                      ElapsedTime=((millis())-StartTime)+6;
                      digitalWrite(MOC2, LOW);
                      lcd.clear();
                      lcd.setCursor(0,0);
                      lcd.print("Intervenuto in");
                      lcd.setCursor(0,1); 
                      lcd.print("ms:");   
                      lcd.print(ElapsedTime);
                      
                      //**** Responso Scatto 2 ************************************
                      if(ElapsedTime<=56)
                        {
                          lcd.print("   Test OK");
                        }
                      if(ElapsedTime>56)
                        {
                          lcd.print("   Test KO");
                        }
                      Step=100; 
                    }
                    
                  //**** Attesa scatto 2 ******************************************
                  if(digitalRead(Monitor)==HIGH)
                    { 
                      ElapsedTime=((millis())-StartTime)+6;
                      if(ElapsedTime<=494)
                        { 
                          lcd.clear();
                          lcd.setCursor(0,0);
                          lcd.print("Attesa Scatto 2");
                        }
                        
                      //**** Time Out Scatto 2 ************************************
                      if(ElapsedTime>494)
                        { 
                          digitalWrite(MOC2, LOW);
                          lcd.clear();
                          lcd.setCursor(0,0);  
                          lcd.print("Test Fallito!!");
                          lcd.setCursor(0,1); 
                          lcd.print("Riprova");
                          StartTime=0; 
                          delay(2000);  
                          Step=100;
                        }
                    }
                  break;  

           case 100: //**** Riprova ***********************************************
                   delay(1000);
                   if(digitalRead(Button)==LOW)
                    {
                      lcd.clear();
                      Memoria=LOW;
                      delay(1000);
                      Step=0;
                    }            
                      
        }
  }

 

 

Share this post


Link to post
Share on other sites
dott.cicala

.

Edited by dott.cicala

Share this post


Link to post
Share on other sites
Nino1001-b

La mia idea è ancor più semplice:

1) Ridurre ad uno il fototriac ( dovrei studiarmi l'articolo perchè non ho afferrato bene il perchè sono due) e se voglio provare i due rami inverto la spina.

2) Alimentare Arduino nano con batteria propria.

3) Prevedere 4 pulsanti di input, a ciascun pulsante fa capo un'istruzione precisa:

     P1 delay (25 ms)

     P2 delay ( 30 ms)

     P3 (delay (35 ms)

     P4 (delay (40 ms)

in fin dei conti alla pressione del pulsante Arduino deve fare una ed una sola operazione l'importante è che nel complessivo i tempi corrispondano quindi il delay () dovrebbe andare benissimo.

Se poi vogliamo volare più basso usiamo un AttinY45, (scrivo a naso...ma dovrebbe andare bene).

Poi rivoliamo in alto arricchendo il circuito di orpelli inutili ma scenografici con mobile e nome accattivante e lo si mette in commercio ( questo,lo ricordo benissimo, me lo hanno insegnato a scuola...che è poi quello che si fa sia in ambito commerciale e semiprofessionale che professionale)....ovviamente con sigla personalizzata.

Non rimane che stabilire dove e come misurare l'effettivo tempo di intervento, il vecchio oscilloscopio analogico è andato la cineseria digitale da 40 euro andrà bene?

 

Un arricchimento potrebbe essere quello di fargli calcolare la le legge di Ohm R in funzione della tensione letta in quel momento, ruorare un doppio potenziometro (uno di dispersione l'altro di lettura del valore) sulla seconda riga del display...ma qui il delay() non va più bene.

 

....oppure per avere una tensione sempre stabile, e quindi sempre la solita resistenza di dispersione usare (e dove lo trovi?) quei vecchi,pesanti ed ingombranti stabilizzatori che si mettevano sotto le TV in b/n e qui credo che pochi sappiano a cosa mi riferisco.

 

 

 

 

 

 

 

 

 

 

 

Edited by Nino1001-b

Share this post


Link to post
Share on other sites
dott.cicala
37 minuti fa, Nino1001-b scrisse:

stabilizzatori che si mettevano sotto le TV in b/n e qui credo che pochi sappiano a cosa mi riferisco.

Allo stabilizzatore di rete a ferro saturo. Ne ho uno in cantina appartenuto alla tv dei nonni. La Tv, ovviamente a valvole,  l'ho smontata (demolita) 40 anni fa, non ci riuscii con lo stabilizzatore perchè all'interno c'è una colata di catrame e quindi è soprvvissuto :lol:

 

Metterlo in commercio? Se non c'è già, a questo punto un cinese che ci spia atraverso un qualsiasi oggetto cinese, anche non elettrico che abbiamo in casa, ci avrà già rubato l'idea.

Vedrai che alla prossima ricerca che farai su Aliexpress o simile ti comparirà nei suggerimenti :superlol:

Share this post


Link to post
Share on other sites
gabri-z
9 minuti fa, dott.cicala scrisse:

con lo stabilizzatore perchè all'interno c'è una colata di catrame e quindi è soprvvissuto :lol:

Ecco perché il mio era rumoroso , non c'era la colata....

Share this post


Link to post
Share on other sites
dnmeza
52 minuti fa, Nino1001-b scrisse:

Ridurre ad uno il fototriac

servono due canali proprio per non girare la spina, e quindi provare su tutti e due i fili, i quattro pulsanti non riesco a capire le funzioni, sicuramente uno sarà di prova, gli altri tre per un ampliamento di altre analisi/prove, tipo voltmetro, ohmmetro ecc...

Sullo schema non ho inserito la batteria perchè volevo mettere delle batterie al litio (vecchi cell) e dovevo approntare il circuito di ricarica, alla fine ho optato per il trasf. e mettero una presa per batterie, o vedrò, sicuramente le batterie ci vogliono.

Il sofware implementato da Stefano, mi sembra più lineare e più intuitivo di quello che (ignorantemente) ho elaborato io, devo prendere confidenza con le funzioni, per adottare le più opportune del caso, affinche si possa comprendere senza "incasinare" il risultato, l'avevo accantonato per una quindicina di giorni, per assenza del materiale (hardware) e mi ero messo a capire come fare un soff starter, che comunque sempre in attesa che mi arrivassero dei componenti (moc3020 e triac), pertanto la prima versione che ho messo era proprio il primo abbozzo, sono contento della partecipazione, arduino nella sua "semplicità" si presta a molte idee.

Share this post


Link to post
Share on other sites
dott.cicala

Questa è l'ultima versione. Avevo dimenticato una condizione in "Attesa Scatto 2"

 

/*
 Prova SalvaVita
 */
//********************************************************************************
  #include <LiquidCrystal.h>
  LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

  int Monitor =2;  //Presenza rete
  int Button  =3;  //Pulsante start
  int MOC1    =4; 
  int MOC2    =5;
  int Step    =0;

  unsigned long StartTime =0;
  unsigned long ElapsedTime =0;
  bool Memoria = LOW;
//********************************************************************************
void setup() {
  pinMode(Monitor, INPUT);
  pinMode(Button, INPUT);
  pinMode(MOC1, OUTPUT);
  pinMode(MOC2, OUTPUT);
  lcd.begin(16, 2);
  lcd.print("Test SalvaVita");
  delay(2000);
  lcd.clear();
}
//********************************************************************************
void loop()
  {
      switch(Step)
        {
          case 0: //**** Verifico presenza rete ***********************************
                  if(digitalRead(Monitor)==LOW)
                    {
                      lcd.setCursor(0,1);   
                      lcd.print("Assenza Rete!");
                    }
                  if(digitalRead(Monitor)==HIGH)
                    {
                      lcd.clear();                   
                      Step=1;
                    }
                   break;
                   
           case 1: //**** Verifico pulsante START *********************************                   
                  if(digitalRead(Button)==HIGH)
                    {
                      digitalWrite(MOC1, LOW);
                      digitalWrite(MOC2, LOW);
                      Memoria=LOW;
                      lcd.setCursor(0,1);   
                      lcd.print("...Premi Start..");
                    } 
                            
                  if(digitalRead(Button)==LOW)
                    { 
                      lcd.clear();
                      lcd.setCursor(0,1);   
                      lcd.print("...Avvio test!!!");                 
                      delay(1500);
                      lcd.clear();
                      StartTime=0;   
                      Step=2;
                    }
                  break;
                  
          case 2: //**** Attivo MOC1 **********************************************
                  lcd.clear();
                  StartTime=millis();
                  digitalWrite(MOC1, HIGH);
                  if (digitalRead(Monitor)==LOW)
                      {
                        Memoria=HIGH;
                      } 
                  Step=3;
                  break;
                  
          case 3: //**** Scatto 1 Avvenuto ****************************************
                  if((digitalRead(Monitor)==LOW)||(Memoria==HIGH))
                    { 
                      ElapsedTime=((millis())-StartTime)+6;
                      lcd.clear();
                      lcd.setCursor(0,0);
                      lcd.print("Intervenuto in");
                      lcd.setCursor(0,1); 
                      lcd.print("ms:");   
                      lcd.print(ElapsedTime);
                      delay(100);
                      digitalWrite(MOC1, LOW);
                      
                      //**** Responso Scatto 1 ************************************
                      if(ElapsedTime<=56)
                        {
                          lcd.print("   Test OK");
                        }
                      if(ElapsedTime>56)
                        {
                          lcd.print("   Test KO");
                        }
                      Step=100; 
                    }
                    
                  //**** Attesa scatto 1 ******************************************
                  if((digitalRead(Monitor)==HIGH)&&(Memoria==LOW))
                    { 
                      ElapsedTime=(millis())-StartTime;
                      if(ElapsedTime<=494)
                        { 
                          lcd.clear();
                          lcd.setCursor(0,0);
                          lcd.print("Attesa scatto 1");
                        }
                        
                      //**** Time Out Scatto 1 ************************************
                      if(ElapsedTime>494)
                        { 
                          digitalWrite(MOC1, LOW);
                          lcd.clear();
                          lcd.setCursor(0,0);  
                          lcd.print("Non Intervenuto");
                          lcd.setCursor(0,1);
                          lcd.print("ms:"); 
                          lcd.print(ElapsedTime);  
                          lcd.print(" Attendi");
                          delay(2000);
                          lcd.clear();
                          StartTime=0;
                          Memoria=LOW;   
                          Step=4;
                        }
                    }
                  break; 
                   
          case 4: //**** Attivo MOC2 **********************************************
                  StartTime=millis();
                  digitalWrite(MOC2, HIGH);
                  if (digitalRead(Monitor)==LOW)
                      {
                        Memoria=HIGH;
                      } 
                  Step=5;
                  break;               

           case 5: //**** Scatto 2 Avvenuto ***************************************
                  if((digitalRead(Monitor)==LOW)||(Memoria==HIGH))
                    { 
                      ElapsedTime=((millis())-StartTime)+6;
                      lcd.clear();
                      lcd.setCursor(0,0);
                      lcd.print("Intervenuto in");
                      lcd.setCursor(0,1); 
                      lcd.print("ms:");   
                      lcd.print(ElapsedTime);
                      delay(100);
                      digitalWrite(MOC2, LOW);
                      
                      //**** Responso Scatto 2 ************************************
                      if(ElapsedTime<=56)
                        {
                          lcd.print("   Test OK");
                        }
                      if(ElapsedTime>56)
                        {
                          lcd.print("   Test KO");
                        }
                      Step=100; 
                    }
                    
                  //**** Attesa scatto 2 ******************************************
                  if((digitalRead(Monitor)==HIGH)&&(Memoria==LOW))
                    { 
                      ElapsedTime=((millis())-StartTime)+6;
                      if(ElapsedTime<=494)
                        { 
                          lcd.clear();
                          lcd.setCursor(0,0);
                          lcd.print("Attesa Scatto 2");
                        }
                        
                      //**** Time Out Scatto 2 ************************************
                      if(ElapsedTime>494)
                        { 
                          digitalWrite(MOC2, LOW);
                          lcd.clear();
                          lcd.setCursor(0,0);  
                          lcd.print("Test Fallito!!");
                          lcd.setCursor(0,1); 
                          lcd.print("Riprova");
                          StartTime=0; 
                          delay(2000);  
                          Step=100;
                        }
                    }
                  break;  

           case 100: //**** Riprova ***********************************************
                   delay(1000);
                   if(digitalRead(Button)==LOW)
                    {
                      lcd.clear();
                      Memoria=LOW;
                      delay(1000);
                      Step=0;
                    }            
                      
        }
  }

e questo è lo schema

rrr.jpg.1da9a87748446ccdc72f12dcbff7afa7.jpg

Share this post


Link to post
Share on other sites
dnmeza

scusa Stefano, perdona la mia ignoranza,

21 minuti fa, dott.cicala scrisse:

Step=100;

non capisco "step=100"; "step=2"; non sono etichette di salto,

Share this post


Link to post
Share on other sites
dnmeza
13 minuti fa, gabri-z scrisse:

C2 di quanto ritarda lo spegnimento del LED

ci vorrebbe una resistenza in parallelo per diminuire il tempo ?

Share this post


Link to post
Share on other sites
gabri-z

Forse conviene di più mettere in conto il ritardo che mettere una resistenza ....

Share this post


Link to post
Share on other sites
dott.cicala
23 minuti fa, gabri-z scrisse:

Forse conviene di più mettere in conto il ritardo che mettere una resistenza .... 

già fatto

ElapsedTime=((millis())-StartTime)+6;

il +6 è la somma di tutti i ritardi

32 minuti fa, dnmeza scrisse:

non capisco "step=100"; "step=2"; non sono etichette di salto,

Con la funzione SWITCH il programma entra nelle parti CASE in base al valore assunto dall'indice step

esegue tutto quanto sta all'interno fino al break quindi esce dal CASE ed esegue il resto del codice, se c'è, altrimenti ricomincia da capo legge il valore di step e di conseguenza va al CASE con valore corrispondente e via dicendo

 

Edited by dott.cicala

Share this post


Link to post
Share on other sites
dnmeza
2 minuti fa, dott.cicala scrisse:

legge il valore di step e di conseguenza va al CASE con valore corrispondente

quindi salta tipo goto ..... grazie,

Share this post


Link to post
Share on other sites
dott.cicala

Il costrutto switch-case fa parte delle istruzioni condizionali come If-then-else, while ecc. Ha differenze sostaziali rispetto al goto, anche se in apparenza può sembrare simile.

Immagina che sia un commutatore (switch) le cui vie sono i CASE e il cursore, in questo caso, è  Step.

Share this post


Link to post
Share on other sites
gabri-z
1 ora fa, dnmeza scrisse:

quindi salta tipo goto

Ed io che pensavo al :

Quote

Un goto (altro sinonimo vèneto el xe bicièr)

:P:wallbash:

Share this post


Link to post
Share on other sites
dott.cicala

per quello dicevo che è diverso...Un goto de vin

index.jpeg.59e5f00aea51a3c2ec9946fbc0d8c7d5.jpeg

:clap:

Share this post


Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.


×
×
  • Create New...