Vai al contenuto
PLC Forum


Prova differenziale con Arduino nano


dnmeza

Messaggi consigliati

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

Link al commento
Condividi su altri siti


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: "

Link al commento
Condividi su altri siti

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?!

 

 

Modificato: da gabri-z
Link al commento
Condividi su altri siti

del_user_237282
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.

Link al commento
Condividi su altri siti

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

Link al commento
Condividi su altri siti

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.

Link al commento
Condividi su altri siti

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

 

 

 

Link al commento
Condividi su altri siti

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

Link al commento
Condividi su altri siti

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;
                    }            
                      
        }
  }

 

 

Link al commento
Condividi su altri siti

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.

 

 

 

 

 

 

 

 

 

 

 

Modificato: da Nino1001-b
Link al commento
Condividi su altri siti

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:

Link al commento
Condividi su altri siti

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....

Link al commento
Condividi su altri siti

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.

Link al commento
Condividi su altri siti

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

Link al commento
Condividi su altri siti

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,

Link al commento
Condividi su altri siti

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

 

Modificato: da dott.cicala
Link al commento
Condividi su altri siti

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.

Link al commento
Condividi su altri siti

Crea un account o accedi per commentare

Devi essere un utente per poter lasciare un commento

Crea un account

Registrati per un nuovo account nella nostra comunità. è facile!

Registra un nuovo account

Accedi

Hai già un account? Accedi qui.

Accedi ora
×
×
  • Crea nuovo/a...