Swich case over flow blocco arduino

Ciao a tutti solo curiosità,
Mi dite perchè questo programma mi manda in blocco Arduino? non riceve
più dati dal tablet quando vengono inviati e sono costretto a spegnere e accendere arduino

// GESTIONE ILLUMINAZIONE  

#define rele1  2 // relè 1  collegato sul pin digitale 2
#define rele2  3 // relè 2  collegato sul pin digitale 3
#define rele3  4 // relè 3  collegato sul pin digitale 4
#define rele4  5 // relè 4  collegato sul pin digitale 5
#define rele5  6 // relè 5  collegato sul pin digitale 6
#define rele6  7 // relè 6  collegato sul pin digitale 7

int pulsante8 = 8; // pulsante  collegato sul pin digitale 8
int pulsante9 = 9; // pulsante  collegato sul pin digitale 9
int pulsante10 = 10; // pulsante  collegato sul pin digitale 10
int pulsante11 = 11;// pulsante  collegato sul pin digitale 11
int pulsante12 = 12;// pulsante  collegato sul pin digitale 12
int pulsante13 = 14;// pulsante  collegato sul pin analog A0

boolean statoPulsante8 = false;  // si userà valPulsante per conservare lo stato del pin di input pulsante
boolean statoPulsante9 = false;  // si userà valPulsante per conservare lo stato del pin di input pulsante 
boolean statoPulsante10 = false; // si userà valPulsante per conservare lo stato del pin di input pulsante
boolean statoPulsante11 = false; // si userà valPulsante per conservare lo stato del pin di input pulsante
boolean statoPulsante12 = false; // si userà valPulsante per conservare lo stato del pin di input pulsante 
boolean statoPulsante13 = false; // si userà valPulsante per conservare lo stato del pin di input pulsante

char val;
int T = 400; 
void setup() {                  
  
Serial.begin(9600);

  
 // IMPOSTA I VARI PIN IN OUTPUT
  pinMode(rele1, OUTPUT); 
  pinMode(rele2, OUTPUT); 
  pinMode(rele3, OUTPUT);
  pinMode(rele4, OUTPUT);
  pinMode(rele5, OUTPUT);
  pinMode(rele6, OUTPUT);
 
  digitalWrite(rele1, HIGH);
  digitalWrite(rele2, HIGH);
  digitalWrite(rele3, HIGH);
  digitalWrite(rele4, HIGH);
  digitalWrite(rele5, HIGH);
  digitalWrite(rele6, HIGH);

  pinMode(pulsante8, INPUT); // imposta il pin 8 pulsante come input 
  pinMode(pulsante9, INPUT); // imposta il pin 9 pulsante  come input
  pinMode(pulsante10, INPUT); // imposta il pin 10 pulsante  come input
  pinMode(pulsante11, INPUT); // imposta il pin 11 pulsante come input
  pinMode(pulsante12, INPUT); // imposta il pin 12 pulsante come input
  pinMode(pulsante13, INPUT); // imposta il pin A0 pulsante  come input

}  
  
 void loop() {  
 
 int  valPulsante8 = digitalRead(pulsante8); // controlla se il pulsante 8 è LOW o HIGH
 int  valPulsante9 = digitalRead(pulsante9); // controlla se il pulsante 9 è LOW o HIGH
 int  valPulsante10 = digitalRead(pulsante10); // controlla se il pulsante 10 è LOW o HIGH
 int  valPulsante11 = digitalRead(pulsante11); // controlla se il pulsante 11 è LOW o HIGH
 int  valPulsante12 = digitalRead(pulsante12); // controlla se il pulsante 12 è LOW o HIGH
 int  valPulsante13 = digitalRead(pulsante13); // controlla se il pulsante 13 è LOW o HIGH

// Verifica se  è ON o OFF e aggiorna lo stato del pulsante sul tablet in ON o OFF  
  if (valPulsante8 == LOW)
  {
    if (statoPulsante8 == false)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("6");// ON 
        Serial.flush();
      }
        statoPulsante8 = true;
    }
  }
  else if (valPulsante8 == HIGH) 
  {
    if (statoPulsante8 == true)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("5");// OFF 
        Serial.flush();
      }
        statoPulsante8 = false;
    }
  }
 
 //  Verifica se la luce  è ON o OFF e aggiorna lo stato del pulsante sul tablet in ON o OFF 
  if (valPulsante9 == LOW)
  {
    if (statoPulsante9 == false)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("8");// ON 
        Serial.flush();
      }
        statoPulsante9 = true;
    }
  }
  else if (valPulsante9 == HIGH) 
  {
    if (statoPulsante9 == true)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("7");// OFF 
        Serial.flush();
      }
        statoPulsante9 = false;
    }
  }
   
//  Verifica se la luce  è ON o OFF e aggiorna lo stato del pulsante sul tablet in ON o OFF 
  if (valPulsante10 == LOW)
  {
    if (statoPulsante10 == false)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("10");// ON 
        Serial.flush();
      }
        statoPulsante10 = true;
    }
  }
  else if (valPulsante10 == HIGH) 
  {
    if (statoPulsante10 == true)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("9");// OFF 
        Serial.flush();
      }
        statoPulsante10 = false;
    }
  } 
 
//  Verifica se la luce è ON o OFF e aggiorna lo stato del pulsante sul tablet in ON o OFF 
  if (valPulsante11 == LOW)
  {
    if (statoPulsante11 == false)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("12");// ON 
        Serial.flush();
      }
        statoPulsante11 = true;
    }
  }
  else if (valPulsante11 == HIGH) 
  {
    if (statoPulsante11 == true)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("11");// OFF 
        Serial.flush();
      }
        statoPulsante11 = false;
    }
  } 
//  Verifica se la luce è ON o OFF e aggiorna lo stato del pulsante sul tablet in ON o OFF 
  if (valPulsante12 == LOW)
  {
    if (statoPulsante12 == false)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("14");// ON 
        Serial.flush();
      }
        statoPulsante12 = true;
    }
  }
  else if (valPulsante12 == HIGH) 
  {
    if (statoPulsante12 == true)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("13");// OFF 
        Serial.flush();
      }
        statoPulsante12 = false;
    }
  }
//  Verifica se la luce è ON o OFF e aggiorna lo stato del pulsante sul tablet in ON o OFF 
  if (valPulsante13 == LOW)
  {
    if (statoPulsante13 == false)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("16");// ON 
        Serial.flush();
      }
        statoPulsante13 = true;
    }
  }
  else if (valPulsante13 == HIGH) 
  {
    if (statoPulsante13 == true)
    {
      for (int A = 0; A < 4; A++)
      {
        delay(T);
        Serial.println("15");// OFF 
        Serial.flush();
      }
        statoPulsante13 = false;
    }
  }  

//*********INIZIO CONTROLLO ATTIVAZIONE RLE' ************  
  
  if (Serial.available() > 0) {
    delay(3);  
    val = Serial.read();

  switch (val) { //prevedere il otherwise
       
  case 'A': //ON/OFF
      digitalWrite(rele1, LOW);
      delay(400);//400
      digitalWrite(rele1, HIGH);
      break;
    
  case 'B': // ON/OFF     
      digitalWrite(rele2, LOW);
      delay(400);//400
      digitalWrite(rele2, HIGH);
      break;
    
  case 'C'://ON/OFF     
      digitalWrite(rele3, LOW);
      delay(400);//400
      digitalWrite(rele3, HIGH);
      break;

  case 'D'://ON/OFF     
      digitalWrite(rele4, LOW);
      delay(400);//400
      digitalWrite(rele4, HIGH);
      break;

  case 'E': //ON/OFF     
      digitalWrite(rele5, LOW);
      delay(400);//400
      digitalWrite(rele5, HIGH);
      break;

  case 'F': //ON/OFF     
      digitalWrite(rele6, LOW);
      delay(400);//400
      digitalWrite(rele6, HIGH);
      break;
  default: 
      Serial.flush(); 
  
  }
  }
 }

Grazie mille.

Premesso che Arduino NON va in blocco, ma sicuramente è il tuo programma che contiene un errore e entra in loop su se stesso da qualche parte, mi spieghi l'abbondante uso di Serial.flush() ? Tu sai a cosa serve ?

Guglielmo

Serve per il buffer, lo svuota. Ho visto su internet un tutorial e ho provato. Tu mi parli di un loop continuo, ma dovrebbe resertarsi se premo il tasto reste su arcuino. Ma non fa nulla continua a non funzionare. Devo togliere corrente. Volevo provare anche il reset via programma ma non lo provato ancora e non so se va a buon fine.

Reset, Watchdog, ecc. sono solouziodi di EMERGENZA per imprevisti che arrivano dall'esterno (es. scarica elettrica che fa impazzire il programma), NON soluzioni ai vostri ERRORI di programmazione !!! >:(

Mettiti li armato di santa pazienza, riempi il programma di Serial.print() e fai DEBUG seriamente !!!

Ah, secondo le ma Serial.flush() NON serve (... NON svuota alcun buffer, blocca il programma fino a quando non è finita la trasmissine di tutti i caratteri) ... poi fai tu ... ::slight_smile:

Guglielmo

Ma a tutti quei pulsanti l hai messa una resistenza? Se no ti danno letture un pó ballerine.

Non ho letto tutto ma mi é saltato all occhio il serial.read() sai che legge valori in ascii?

Non arrabbiarti ma non ha senso fare un programma del genere...
Stai cercando di fare un programma sopra le tue competenze...
Tu in un ciclo for applichi 400millisecondi tra un ciclo e l'altro... e' come mettere 500Kg di sabbia nel bagagliaio per far andare la macchina a 30 kmh..... E' CONCETTUALMENTE sbagliato.
Se poi lo ripeti per ben 12 volte mi sa che è meglio se ti scarichi una delle migliaia di guide sulla programmazione prima di avventurarti in un progetto sopra le tue competenze...

aster94:
Ma a tutti quei pulsanti l hai messa una resistenza? Se no ti danno letture un pó ballerine.

Non ho letto tutto ma mi é saltato all occhio il serial.read() sai che legge valori in ascii?

il problema resistenza è il meno...

Vabbe ma si impara, fai una cosa ho notato ora che guardi sia stato vecchio che nuovo con due if uno dentro l altro, modificalo con & in uno solo e già ti semplifichi un sacco la vita
Poi per il futuro, almeno io quando scrivo faccio un upload ogni tanto per controllare se tutto va come penso che dovrebbe andare

:confused: Rispondo un po a tutti. :slight_smile:
Si a quei pulsanti ho messo delle resistenze anche un condensatore. "perchè in effetti sono interruttori relè" e sotto il consiglio di Guglielmo ho modificato il circuito.
Il programma funziona bene in parte diciamo per un giorno o meno. Se risolvo il problema del blocco
funziona tutto. Sempre sotto consiglio di Guglielmo che a modo suo nel farmi le ramanzine bene accette sto facendo varie modifiche, come nel eliminare le stringhe. sto provando questa soluzione swich case.
Il ciclo for mi serve per un motivo semplice quei dati vengono inviati ad un tablet che li riconosce. ora se elimino i for il tablet fa difficoltà a riconoscerli mentre se inserisco il for mi funziona bene.
Ti dico di più anche il delay (400) è giusto.
Non posso modificare la condizione false true deve essere per forza cosi altrimenti il tablet non mi fa delle funzioni.

Serial.read() posso anche modificare e mettere dati ascii, ma sicuramente si blocca. "Provo comunque"

All'inizio di tutto questi aiuti ho sempre detto che non sono un esperto di programmazione, cerco solo aiuto per andare avanti con il progetto. Siccome sono quasi alla fine mi spiace fermare il tutto adesso.

Ora però faccio una domanda io, perchè questo programma che mi gestisce le tende

int alzadx = 2;      // imposta il pin 2 alza tenda destra
int abbassadx = 3;   // imposta il pin 3 abbassa tenda destra
int alzasx = 4;      // imposta il pin 4 alza tenda sinistra
int abbassasx = 5;   // imposta il pin 5 abbassa tenda sinistra
boolean statoingresso = false;
boolean statocucina = false;
boolean statopioggia = false;
const int sensorValueingresso = 980;  //imposta il valore del sensore 980
const int sensorValuecucina = 1000; // 1000
//const int sensorValuepioggia = 600;
String readString;
void setup() {
  Serial.begin(9600);

  pinMode(alzadx, OUTPUT);
  pinMode(abbassadx, OUTPUT);
  digitalWrite(alzadx, HIGH);
  digitalWrite(abbassadx, HIGH);
  pinMode(alzasx, OUTPUT);
  pinMode(abbassasx, OUTPUT);
  digitalWrite(alzasx, HIGH);
  digitalWrite(abbassasx, HIGH);
}

void loop() {
  // CONTROLLA SE PIOVE ALZA TUTTE LE TENDE 
/*  int sensorepioggia = analogRead (A2); 
  Serial.println(sensorepioggia);
  delay(1000);
  if (sensorepioggia < sensorValuepioggia) {  
    if (statopioggia == false) {
      delay(4000);
      Serial.println("C987789");
      delay(1000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
      statopioggia = true;
      delay(4000);
    }  
  }
  if (sensorepioggia > sensorValuepioggia){
    statopioggia = false;
  }*/

  // CONTROLLA LA LUMINOSITà ESTERNA SE è NOTTE ALZA LE TENDE INGRESSO 
  int sensoringresso = analogRead(A4); // A0
    Serial.println(sensoringresso);
    delay(4000);
  if (sensoringresso < sensorValueingresso) {  
    if (statoingresso == false) {
      delay(1000);
      Serial.println("987789");
      delay(1000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);//40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
      statoingresso = true;
      delay(4000);
    }  
  }
  if (sensoringresso > sensorValueingresso){
    statoingresso = false;
  }
  
  // CONTROLLA LA LUMINOSITà ESTERNA SE è NOTTE ALZA LE TENDE CUCINA
  if (sensoringresso < sensorValuecucina) {  
    if (statocucina == false) {
      delay(1000);
      Serial.println("987789");// questo numero è inviato al tablet in seriale che lo idendifica mandando il 
                               // segnale alle tende in cucina di alzare
      delay(1000);
      statocucina = true;
      delay(4000);
    }  

  }
  if (sensoringresso > sensorValuecucina){
    statocucina = false;
  }  

  while (Serial.available()) {
    delay(3);  
    char c = Serial.read();
    readString += c;
  }
  if (readString.length() >0) {
    Serial.println(readString);
    if (readString == "ALZATENDAINGRESSO")     
    {
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);//40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH);
    }
    
  // controlla la condizione se si possono abbassare le tende
  if (readString == "ABBASSATENDAINGRESSO" && sensoringresso <= 990 ){//990 è il controllo che se le due condizioni sono vere
                                                                       // abbassa le tende
      delay(2000);
      Serial.println("118");// codice in cui il tablet avvisa che le tende non si possono abbassare per scarsa luminosità
                            // esterna
  }

  if (readString == "ABBASSATENDAINGRESSO" && sensoringresso >= 995){//995
    digitalWrite(abbassadx, LOW);
    digitalWrite(abbassasx, LOW);
    delay(40000);//40000
    digitalWrite(abbassadx, HIGH);
    digitalWrite(abbassasx, HIGH);
  }
    if (readString == "ALZATENDATUTTO"){
      Serial.println("987789");
      delay(2000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000); //40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
    }
    if (readString == "ABBASSATENDATUTTO" && sensoringresso >= 1000 ){//1000
      Serial.println("997997");
      delay(2000);
      digitalWrite(abbassadx, LOW);
      digitalWrite(abbassasx, LOW);
      delay(40000);//40000
      digitalWrite(abbassadx, HIGH);
      digitalWrite(abbassasx, HIGH);
    }
    if (readString == "ABBASSATENDATUTTO" && sensoringresso <= 1000 )//1000
    {
      Serial.println("119");
    }
    readString="";
  }
}

non mi da nessun problema e funziona da 6 mesi ? mai bloccato e mai creato dati sbagliati.
Più o meno è lo stesso delle luci il principio è uguale.
Ultime parole famose domani lo trovo bloccato :slight_smile: :slight_smile: :slight_smile: :confused: :confused:

delay(40000) sai cosa significa?????
che per 40 secondi quel arduino li è morto..
delay = stai fermo senza far nulla per x tempo....
delay equivale a spegnere arduino per x tempo non fa nulla!!!
Delay NON è il sistema di far programmi!!!!!!!!!

L'ide di arduino dovrebbe bloccare il delay al massimo a 10 millisecondi....

Dai cambia quel delay con millis e leva quelle stringhe, lavora sull altro lato del programma per mandare un byte piuttosto che tutta quella frase

Dai cambia quel delay con millis e leva quelle stringhe, lavora sull altro lato del programma per mandare un byte piuttosto che tutta quella frase

Già ma è una impresa dimostrare che la funzione delay() non deve essere usata in applicazioni; la sua utilità è innegabile nei test durante lo sviluppo, e inoltre adatta nell'applicazione di esempio "blink", dove all'applicazione non è richiesta altra funzione che fare lampeggiare il led.

Partendo dall'esempio "blink" ed introducendo altro codice la prima cosa che dobbiamo fare è trovare il modo di fare lampeggiare il led senza usare la funzione delay(); con questa finalità c'è anche un esempio chiamato "blink senza delay" (BlinkWithoutDelay) il quale dimostra (uno dei tanti modi) per usare la funzione millis().

Ti dico di più anche il delay (400) è giusto.

Noi tutti invece ti diciamo che il delay (400) non è compatibile con la tua applicazione.

Ciao.

perchè questo programma che mi gestisce le tende,non mi da nessun problema e funziona da 6 mesi ? mai bloccato e mai creato dati sbagliati.

Tutti che notate il programma, ma nessuno ha risposto alla mia domanda.
Forse mi sono fatto un opinione diversa sul forum.
Grazie a tutti.

la risposta te l'ho data io...

elpapais:
delay(40000) sai cosa significa?????
che per 40 secondi quel arduino li è morto..
delay = stai fermo senza far nulla per x tempo....
delay equivale a spegnere arduino per x tempo non fa nulla!!!
Delay NON è il sistema di far programmi!!!!!!!!!

L'ide di arduino dovrebbe bloccare il delay al massimo a 10 millisecondi....

Se paragoniamo il tempo di un microcontrollore e quello di un umano, tra un'istruzione e l'altra (con quei delay in mezzo) e come se a noi umani, ci passano dai 5 ai 6 mila anni... quindi l'azione che avevo chiesto si e' ampiamente verificata....
ribadisco...deay = fogna, feccia, cacca...

Quando usi delay il processore NON fa nulla... mi sa che non aggiorna nemmeno i millis() da tanto nulla che fa!!!!!

elpapais:
Quando usi delay il processore NON fa nulla... mi sa che non aggiorna nemmeno i millis() da tanto nulla che fa!!!!!

... ora NON esageriamo, la delay() è utilissima e in decine di casi si usa senza problemi. E' semplicemente una funzione che ritorna dopo N millisecondi, quindi il programma gira in esa invece che da altre parti, ma NULLA sta fermo, gli interrupt funzionano e tutto il resto ... incluso l'avanzamneto di millis().

Ovvio che va usata "cum grano salis" ... :slight_smile:

Guglielmo

Si vabbhe Guglielmo non mi aiuti proprio...
Se gli dici che gli IRQ vanno mo raddoppia l'uso del delay....

La funzione delay(n) permette di fermare l'esecuzione del programma per n millisecondi. Tutto si blocca, la scheda è ferma e non rileva alcun INPUT così come non invia alcun OUTPUT.
Di conseguenza, se nel frattempo succede qualcosa e i sensori attaccati al sistema rilevano variazioni interessanti... non succederà nulla! Questa opzione che può sembrare dannosa è, al contrario, estremamente importante in svariati scenari.
Ora vedi il programma e PENSACI SU un attimo. Come ho detto gestisce dei motori per tende a 220V.

Continui a correggere un programma funzionante, ma non rispondi alla mia domanda del perchè no si blocca mai e funziona BENISSIMO a differenza del primo programma al POST 1 che si blocca sempre.

elpapais:
Si vabbhe Guglielmo non mi aiuti proprio...

... è che NON mi piace "demonizzare" la delay() ... a volte si può usare a volte no ... dipende da quello che deve fare il programma.

L'importante è sapere esattamente quello che fa e conoscere le alternative ...

Guglielmo

Gian70Luca:
Continui a correggere un programma funzionante, ma non rispondi alla mia domanda del perchè no si blocca mai e funziona BENISSIMO a differenza del primo programma al POST 1 che si blocca sempre.

Ma tu pensi veramente che, solo guardando così un programma, scritto in quel modo, senza poter fare un minimo di prove e di debug (... per ovvia mancanza di HW), uno possa darti una risposta ? ? ? :o :o :o

Uno può fare delle "ipotesi", vedere degli errori grossolani che saltano agli occhi, ma il resto ... è TUTTO debug !!!

Guglielmo

Gian70Luca:
La funzione delay(n) permette di fermare l'esecuzione del programma per n millisecondi. Tutto si blocca, la scheda è ferma e non rileva alcun INPUT così come non invia alcun OUTPUT.
Di conseguenza, se nel frattempo succede qualcosa e i sensori attaccati al sistema rilevano variazioni interessanti... non succederà nulla! Questa opzione che può sembrare dannosa è, al contrario, estremamente importante in svariati scenari.
Ora vedi il programma e PENSACI SU un attimo. Come ho detto gestisce dei motori per tende a 220V.

Continui a correggere un programma funzionante, ma non rispondi alla mia domanda del perchè no si blocca mai e funziona BENISSIMO a differenza del primo programma al POST 1 che si blocca sempre.

o ci sei o ci fai....
ti ho gia risposto...
ma ti rispondo nuovamente...
Quello che funziona ha dei delay da 40.000 ovvero 40 secondi!!! Nel quale il microcontrollore NON fa assolutamente nulla!!!!
In quei 40 SECONDI di FANNULLISMO TOTALE magari si scatena l'evento. Nel secondo programma i tempi sono di 400, 1000 e quindi probabimente e statisticamente piu facili da attuarsi la condizione.
Se stai facendo una corsetta a 1 passo ogni 40 secondi o stai correndo a 40 Kmh in quale dei due casi è piu probabile che venga un infarto?
se vuoi ti rispondo in maniera piu esplicativa del perche'...