Ciao a tutti,
vorrei sapere se c'è un modo per far si che uno stesso caso di uno switch case non si ripeta due volte consecutivamente.
E' possibile?
Grazie
Leo
Uno switch() normalmente ogni volta che si verifica un case il codice associato viene eseguito!
Per non fare eseguire due volte consecutive lo stesso case potrei memorizzare l'ultimo case eseguito, e
tramite una condizione if() eseguirlo solo se diverso dal precedente.
Esempio:
byte ultimo=-1; // Variabile che memorizza il case eseguito
void loop(){
switch(variabile){
case 1:
if(ultimo!=1){
//Codice da eseguire col case
}
ultimo=1;
break;
case 2:
if(ultimo!=2){
//Codice da eseguire col case
}
ultimo=2;
break;
case 3:
if(ultimo!=3){
//Codice da eseguire col case
}
ultimo=3;
break;
}
}
Intanto grazie mille, ho provato ma non ha prodotto alcun risultato. Ho pensato che col fatto che si trova all'interno di un millis non ha prodotto i risultati sperati, quindi ho provato a modificare il programma ma ho solo peggiorato le cose 
Lascio i due programmi sperando che qualcuno possa capire dove sbaglio:
Codice modificato da me:
if (millis() - zero > tempo ){
zero = millis(); //Tiene in memoria l'ultimo lampeggio
switch (color) {
if(ultimo!=0){
case 0:
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, LOW);
}
else{
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
}
ultimo = 0;
break;
if(ultimo!=1){
case 1:
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
}
else{
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
}
ultimo = 1;
break;
if(ultimo!=2){
case 2:
digitalWrite(R, LOW);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
}
else{
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
}
ultimo = 2;
break;
if(ultimo!=3){
case 3:
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
}
else{
digitalWrite(R, 201);
digitalWrite(G, 43);
digitalWrite(B, 178);
}
ultimo = 3;
break;
}
}
Codice come mi aveva indicato torn24 :
if (millis() - zero > tempo ){
zero = millis(); //Tiene in memoria l'ultimo lampeggio
switch (color) {
if(ultimo!=0){
case 0:
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, LOW);
}
ultimo = 0;
break;
if(ultimo!=1){
case 1:
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
}
ultimo = 1;
break;
if(ultimo!=2){
case 2:
digitalWrite(R, LOW);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
}
ultimo = 2;
break;
if(ultimo!=3){
case 3:
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
}
ultimo = 3;
break;
if(ultimo!=4){
case 4:
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
}
ultimo = 4;
break;
if(ultimo!=5){
case 5:
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
}
ultimo = 5;
break;
if(ultimo!=6){
case 6:
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
}
ultimo = 6;
break;
}
Grazie
Leo
Non mi pare che hai usato l'esempio che ti ho proposto, tu fai in un modo diverso e sbagliato!.
Tu metti il case dello switch all'interno di un if(), lo switch non ti funzionerà.
Guarda bene l'esempio e guarda come lo hai fatto tu, io metto un if() dopo il case, tu metti il case dentro un if().
Ma almeno copiare bene, perché poi diventa frustrante fare certe osservazioni 
Scusa, hai perfettamente ragione, non mi ero proprio accorto!
Però anche così non cambia nulla 
if (millis() - zero > tempo ){
zero = millis(); //Tiene in memoria l'ultimo lampeggio
switch (color) {
case 0:
if(ultimo!=0){
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, LOW);
}
ultimo = 0;
break;
case 1:
if(ultimo!=1){
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
}
ultimo = 1;
break;
case 2:
if(ultimo!=2){
digitalWrite(R, LOW);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
}
ultimo = 2;
break;
case 3:
if(ultimo!=3){
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
}
ultimo = 3;
break;
case 4:
if(ultimo!=4){
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
}
ultimo = 4;
break;
case 5:
if(ultimo!=5){
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
}
ultimo = 5;
break;
case 6:
if(ultimo!=6){
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
}
ultimo = 6;
break;
}
}
Se può far comodo ecco lo sketch completo:
int pot = 0;
int R = 5;
int G = 6;
int B = 3;
int pR;
int pG;
int pB;
int Rv = LOW;
int Gv = LOW;
int Bv = LOW;
int Rf = 0;
int Gf = 0;
int Bf = 0;
int conta = 0;
int color;
long zero = 0;
#define tempo 1000
byte ultimo =0;
void setup() {
pinMode(man, INPUT);
pinMode(R, OUTPUT);
pinMode(G, OUTPUT);
pinMode(B, OUTPUT);
Serial.begin(9600);
}
void loop() {
pot = analogRead(A0);
pR = analogRead(A1);
pG = analogRead(A2);
pB = analogRead(A3);
Serial.println(pot);
color = random(8);
// 1
if (pot < 100){
if (millis() - zero > tempo ){
zero = millis();
switch (color) {
case 0:
if(ultimo!=0){
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, LOW);
}
else{
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
}
ultimo = 0;
break;
case 1:
if(ultimo!=1){
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
}
else{
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
}
ultimo = 1;
break;
case 2:
if(ultimo!=2){
digitalWrite(R, LOW);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
}
else{
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
}
ultimo = 2;
break;
case 3:
if(ultimo!=3){
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
}
else{
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, LOW);
}
ultimo = 3;
break;
}
}
}
// 2 **************** blink rosso
if (pot > 100 && pot < 200){
digitalWrite(G, LOW), digitalWrite(B, LOW);
if (millis() - zero > tempo ){
zero = millis();
if (Rv == LOW)
Rv = HIGH;
else
Rv = LOW;
digitalWrite(R, Rv);
}
}
// 3 **************** blink verde
if (pot > 200 && pot < 300){
digitalWrite(R, LOW), digitalWrite(B, LOW);
if (millis() - zero > tempo ){
zero = millis();
if (Gv == LOW)
Gv = HIGH;
else
Gv = LOW;
digitalWrite(G, Gv);
}
}
// 4 **************** blink blu
if (pot > 300 && pot < 400){
digitalWrite(R, LOW), digitalWrite(G, LOW);
if (millis() - zero > tempo ){
zero = millis();
if (Bv == LOW)
Bv = HIGH;
else
Bv = LOW;
digitalWrite(B, Bv);
}
}
// 5
if (pot > 400 && pot < 500){
}
// 6
if (pot > 500 && pot < 600){
}
// 7
if (pot > 600 && pot < 700){
digitalWrite(R, 10);
digitalWrite(G, 0);
digitalWrite(B, 0);
}
// 8
if (pot > 700 && pot < 800){
}
// 9
if (pot > 800 && pot < 900){
}
// 10 **************** fade
if (pot > 900){
int Rf = 255;
int Bf = 0;
int Gf = 0;
for( int i = 0 ; i < 255 ; i += 1 ){
Gf += 1;
Rf -= 1;
analogWrite( G, 255 - Gf );
analogWrite( R, 255 - Rf );
delay(5);
}
Rf = 0;
Bf = 0;
Gf = 255;
for( int i = 0 ; i < 255 ; i += 1 ){
Bf += 1;
Gf -= 1;
analogWrite( B, 255 - Bf );
analogWrite( G, 255 - Gf );
delay(5);
}
Rf = 0;
Bf = 255;
Gf = 0;
for( int i = 0 ; i < 255 ; i += 1 ){
Rf += 1;
Bf -= 1;
analogWrite( R, 255 - Rf );
analogWrite( B, 255 - Bf );
delay(5);
}
}
delay(10);
}
void rgb(int rosso, int verde, int blu){
digitalWrite(R, rosso);
digitalWrite(G, verde);
digitalWrite(B, blu);
}
Leo
Non c'entra nulla col tuo problema ma...
questo:
pot = analogRead(A0);
pR = analogRead(A1);
pG = analogRead(A2);
pB = analogRead(A3);
cambialo così 
pot = analogRead(A0); // lettura falsa (da buttare)
delay(2);
pot = analogRead(A0);
pR = analogRead(A1); // lettura falsa (da buttare)
delay(2);
pR = analogRead(A1);
pG = analogRead(A2); // lettura falsa (da buttare)
delay(2);
pG = analogRead(A2);
pB = analogRead(A3); // lettura falsa (da buttare)
delay(2);
pB = analogRead(A3);
così come hai messo ora il random tutte le volte che accendi arduino ripete esattamente la stessa sequenza,
per renderla un po più casuale aggiungi come ultima riga del setup
randomSeed(analogRead(a5);
supponendo che pot sia <100
e color = 0
entrerà nel primo case
ed essendo "ultimo=0" perchè l'hai impostato tu nelle prime righe, non eseguirà l'if ma salterà all'else
facendo:
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
dopodichè fai un'altro giro con un nuovo color mettiamo che sia 1
ultimo è = 0 per cui non essendo = 1 entri nell'if e fai
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
dopodichè fai un'altro giro con un nuovo color....
quindi tranne forse la prima volta eseguirai sempre e solo l'else dei tui if in quanto molto difficilmente color si ripeterà 2 volte di seguito.
per risolvere in tutti i case devi usare lo stesso valore di "ultimo" e controllare se è 0 oppure no
case 0:
if (ultimo != 0) {
digitalWrite(R, HIGH);
...
ultimo = 0;
} else {
digitalWrite(R, HIGH);
...
ultimo = 1;
}
break;
case 1:
if (ultimo != 0) {
digitalWrite(R, LOW);
...
ultimo = 0;
} else {
digitalWrite(R, HIGH);
...
ultimo = 1;
}
break;
nel fade vedo:
int Rf = 255;
int Bf = 0;
int Gf = 0;
for ( int i = 0 ; i < 255 ; i += 1 ) {
Gf += 1;
Rf -= 1;
analogWrite( G, 255 - Gf );
analogWrite( R, 255 - Rf );
delay(5);
}
non è più semplice
for ( int i = 0 ; i < 255 ; i += 1 ) {
analogWrite( G, 0 + i );
analogWrite( R, 255 - i );
delay(5);
}
anche per i seguenti...
Be cambia! Come ti ho mostrato io NON ESEGUE lo stesso case due volte consecutive
Tu usi if else, CHE è DIVERSO, se usi else succede che se hai lo stesso case consecutivo esegue il codice dell'else. Se ripete 10 volte il case 0: ripeterà 10 volte l'else del case zero !!!!
Guarda che piccole modifiche, piccole differenze cambiano l'esito del programma, e tu fai sempre qualcosa di diverso da quello che ti dicono! Se fai diversamente il programma si comporta diversamente!e un po mi sono stancato NON FUNZIONA PERCHE' FAI DIVERSAMENTE
Pensa anche cosa ti serve e cosa vuoi ottenere! Se hai bisogno di un if else, se non devi eseguire lo stesso codice due volte consecutive e altro... Forse uno switch non è la struttura di controllo adatta, forse dovresti usare un if e else if per valutare il colore dove utilizzare condizioni complesse! Lo switch non mi sembra adatto visto che ti servono tante condizioni!Inutile usare uno switch se poi devi porre delle condizioni if()
if(colore==0 && ultimo!=0){
ultimo=0;
}else if( condizione)
Patrick_M la tua soluzione dello switch() non mi torna...
Esempio:
Mi capita il caso 0, esegui if e ultimo diventa 0 zero -> se ricapita il caso zero eseguirà l'else
MA mettiamo che dopo il caso zero capiti il caso uno, ultimo vale zero, e sul caso uno eseguirà l'else
anche se dovrebbe eseguire il codice dell if().
torn24:
Be cambia! Come ti ho mostrato io NON ESEGUE lo stesso case due volte consecutiveTu usi if else, CHE è DIVERSO, se usi else succede che se hai lo stesso case consecutivo esegue il codice dell'else. Se ripete 10 volte il case 0: ripeterà 10 volte l'else del case zero !!!!
Guarda che piccole modifiche, piccole differenze cambiano l'esito del programma, e tu fai sempre qualcosa di diverso da quello che ti dicono! Se fai diversamente il programma si comporta diversamente!e un po mi sono stancato NON FUNZIONA PERCHE' FAI DIVERSAMENTE
Ti posso assicurare che ho provato anche il programma da te consigliato ma non ha funzionato. Nello sketch completo che avevo inviato c'era un altro programma perché ne sto provando diversi per riuscire a risolvere il problema.
Leo
torn24:
Patrick_M la tua soluzione dello switch() non mi torna...Esempio:
Mi capita il caso 0, esegui if e ultimo diventa 0 zero -> se ricapita il caso zero eseguirà l'else
MA mettiamo che dopo il caso zero capiti il caso uno, ultimo vale zero, e sul caso uno eseguirà l'else
anche se dovrebbe eseguire il codice dell if().
si , hai ragione era un miglioramento....parziale
Appena sono su pc provo tutto quello che mi avete consigliato e vi spiego per quale motivo secondo me il programma consigliato da torn24 non funziona.
Buona giornata
Leo
Ti posso assicurare che ho provato anche il programma da te consigliato ma non ha funzionato.
Avrai fatto qualcosa tu di diverso! Il codice non è interpretabile in modo diverso, ti puoi fare spiegare queste righe da chiunque e tutti ti diranno lo stesso comportamento.
Esegue un case solo se il precedente è diverso e non uguale a se stesso!
switch(variabile){
case 1:
if(ultimo!=1){ // ULTIMO è DIVERSO DA UNO ESEGUE IL CODICE
//Codice da eseguire col case
}
ultimo=1; // POI ULTIMO DIVENTA UNO E IL CODICE NON SARA PIU' ESEGUITO
break;
case 2:
if(ultimo!=2){
//Codice da eseguire col case
}
ultimo=2;
break;
case 3:
if(ultimo!=3){
//Codice da eseguire col case
}
ultimo=3;
break;
} :o
Parlo da principiante quindi potrei anche sparare un enorme cavolata, secondo me il tuo programma non funziona perché quando si verifica che un case si ripete due volte il programma rimane su quel case perché deve aspettare che siano trascorsi i 1000 ms del millis invece di passare a un altro case come sperato.
Spero di essermi spiegato.
Leo
Nov 09, 2018, 11:16 pm Last Edit: Nov 09, 2018, 11:17 pm by LeoTer01
Ciao a tutti,
vorrei sapere se c'è un modo per far si che uno stesso caso di uno switch case non si ripeta due volte consecutivamente.
Questa è la domanda del thread e la risposta si riferiva a quello!
Se il programma non funziona è per il codice che hai scritto tu non per quello che ho scritto io
Io non ho scritto millis() da nessuna parte!
Devo dire che io a 16 anni non sapevo niente di computer "ai miei tempi erano costosi e non potevo permettermeli" Nonostante che per la tua età dimostri una conoscenza superiore a molti tuoi coetanei "e quindi mi complimento con te", forse tra due e tre anni di sperimentazione nella programmazione riuscirai a trovare soluzioni migliori, anche perché risolviamo tuoi dubbi su spezzoni di programma,ma quasi sicuramente l'intero programma "di cui non so di cosa si tratti" potrebbe essere pensato in modo diverso per ottenere il risultato voluto
Non posso che darti ragione, probabilmente non mi sono spiegato bene io fin dall'inizio.
RICAPITOLANDO:
ho bisogno di sapere se c'è un modo per far si che i case qui sotto non si ripetano due volte consecutive:
switch (color) {
case 0:
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, LOW);
break;
case 2:
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
break;
case 3:
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
break;
case 4:
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
break;
case 5:
digitalWrite(R, LOW);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
break;
case 6:
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
break;
case 7:
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
break;
case 8:
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, LOW);
break;
}
Tenendo in cosiderazione il programma in cui sono contenuti:
int pot = 0;
int R = 5;
int G = 6;
int B = 3;
int pR;
int pG;
int pB;
int Rv = LOW;
int Gv = LOW;
int Bv = LOW;
int conta = 0;
int color;
long zero = 0;
#define tempo 1000
byte ultimo =0;
void setup() {
pinMode(R, OUTPUT);
pinMode(G, OUTPUT);
pinMode(B, OUTPUT);
Serial.begin(9600);
}
void loop() {
pot = analogRead(A0);
pR = analogRead(A1);
pG = analogRead(A2);
pB = analogRead(A3);
Serial.println(pot);
color = random(4);
// 1
if (pot < 100){
if (millis() - zero > tempo ){
zero = millis(); //Tiene in memoria l'ultimo lampeggio
switch (color) {
case 0:
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, LOW);
break;
case 2:
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
break;
case 3:
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
break;
case 4:
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
break;
case 5:
digitalWrite(R, LOW);
digitalWrite(G, LOW);
digitalWrite(B, HIGH);
break;
case 6:
digitalWrite(R, LOW);
digitalWrite(G, HIGH);
digitalWrite(B, HIGH);
break;
case 7:
digitalWrite(R, HIGH);
digitalWrite(G, HIGH);
digitalWrite(B, LOW);
break;
case 8:
digitalWrite(R, HIGH);
digitalWrite(G, LOW);
digitalWrite(B, LOW);
break;
}
}
}
// 2 **************** blink rosso
if (pot > 100 && pot < 200){
digitalWrite(G, LOW), digitalWrite(B, LOW);
if (millis() - zero > tempo ){
zero = millis(); //Tiene in memoria l'ultimo lampeggio
//Se il LED è spento lo accende e viceversa
if (Rv == LOW)
Rv = HIGH;
else
Rv = LOW;
digitalWrite(R, Rv);
}
}
// 3 **************** blink verde
if (pot > 200 && pot < 300){
digitalWrite(R, LOW), digitalWrite(B, LOW);
if (millis() - zero > tempo ){
zero = millis(); //Tiene in memoria l'ultimo lampeggio
//Se il LED è spento lo accende e viceversa
if (Gv == LOW)
Gv = HIGH;
else
Gv = LOW;
digitalWrite(G, Gv);
}
}
// 4 **************** blink blu
if (pot > 300 && pot < 400){
digitalWrite(R, LOW), digitalWrite(G, LOW);
if (millis() - zero > tempo ){
zero = millis(); //Tiene in memoria l'ultimo lampeggio
//Se il LED è spento lo accende e viceversa
if (Bv == LOW)
Bv = HIGH;
else
Bv = LOW;
digitalWrite(B, Bv);
}
}
// 5
if (pot > 400 && pot < 500){
}
// 6
if (pot > 500 && pot < 600){
}
// 7
if (pot > 600 && pot < 700){
}
// 8
if (pot > 700 && pot < 800){
}
// 9
if (pot > 800 && pot < 900){
}
// 10 **************** fade
if (pot > 900){
for( int i = 0 ; i < 255 ; i += 1 ){
analogWrite( G, 0 + i );
analogWrite( R, 255 - i );
delay(5);
}
for( int i = 0 ; i < 255 ; i += 1 ){
analogWrite( B, 0 + i );
analogWrite( G, 255 - i );
delay(5);
}
for( int i = 0 ; i < 255 ; i += 1 ){
analogWrite( R, 0 + i );
analogWrite( B, 255 - i );
delay(5);
}
}
delay(10);
}
Ringrazio poi Patrick_M per i suoi consigli, non capisco però quale miglioria possa dare al programma questo:
Patrick_M:
Non c'entra nulla col tuo problema ma...
questo:pot = analogRead(A0);
pR = analogRead(A1);
pG = analogRead(A2);
pB = analogRead(A3);
cambialo così ;)pot = analogRead(A0); // lettura falsa (da buttare)
delay(2);
pot = analogRead(A0);
pR = analogRead(A1); // lettura falsa (da buttare)
delay(2);
pR = analogRead(A1);
pG = analogRead(A2); // lettura falsa (da buttare)
delay(2);
pG = analogRead(A2);
pB = analogRead(A3); // lettura falsa (da buttare)
delay(2);
pB = analogRead(A3);
P.S. Tutto ciò mi servirebbe per creare dei giochi di luce per un faretto rgb "da discoteca" da me costruito.
Leo
Allora, é abbastanza semplice:
- aggiungo una variabile nella quale mi ricorderò il valore dell'ultimo case eseguito
- inserisco l'intero switch case nel corpo di un if che mi controlla seil valore del ricordo e quelli attuale sono differenti.
- nell'else di quell'if vi metto quello che il programma deve fare se dovrebbe ripetere un case (ammesso che serva)
- aggiorno il ricordo
Silente, a parte che la tua soluzione dovrebbe essere più veloce perché esegue solo un if(), se guardi il secondo post di questo thread, avevo posto una soluzione simile, dimmi se c'è motivo che non funzioni per favore! perchè proprio non capisco...
Non è molto diverso da quello che gli avevo proposto, io memorizzavo l'ultimo case, e condizionavo con if() ogni case. Tu invece memorizzi l'ultimo case e condizioni con un if() l'intero switch().
Visto che non si sa quale problema viene fuori, sono quasi sicuro che avrà problemi anche con la tua soluzione
LeoTer01:
RICAPITOLANDO:
ho bisogno di sapere se c'è un modo per far si che i case qui sotto non si ripetano due volte consecutive
A me sembra la domanda sbagliata per risolvere un problema sbagliato. Infatti le soluzioni corrette presentate non c'entrano nulla con il vero problema che rimane inalterato. A cosa serve non ripetere i case? A d avere un motivo luci diverso ad ogni ciclo? Se è così quello che c'è da fare in realtà è far si che la variabile color non sia mai uguale al ciclo precedente. Lo switch e i case non c'entrano nulla. Ci ho preso?