RGB da seriale

Buona domenica a tutti.. Come da titolo sto cercando di far funzionare un led RGB comandato dalla seriale. Ormai penso di essere arrivato ad un buon punto, ma mi sto scontrando con la mia incapacità di mandare in loop un percorso specifico. Ho utilizzato switch per definire le variabili ed avere i vari colori fissi, ma quando faccio un percorso con la rotazione di tutti i colori dovrebbe ricominciare da capo.. :0 è un po' lunghetto. Spero che qualcuno di voi ci capisca qualcosa. Grazie in anticipo.

//Sketch eseguito per un led RGB con anodo in comune

const int R = 11;                              //definizione costante Red
const int G = 10;                              //definizione costante Green
const int B = 6;                               //definizione costante Blue
int a;                                         //definizione variabile a dove memorizzo il valore seriale
char b;
const int timea = 200;                         //definizione di un tempo per delay successivi
const int timeb = 200;

void setup()
{
  pinMode(R, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(B, OUTPUT);

  Serial.begin(9600);

}

void loop()
{

  
  if (Serial.available()>0)                  //Se esiste un dato sulla seriale
  {
  a = Serial.read( );
    
  switch (a) {
    
  case 65:{                                  //Grado 0 solo ROSSO
    analogWrite(R, 128);
    analogWrite(G, 255);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 66:{                                  //Grado 10 scende il ROSSO mentre sale il BLU
    analogWrite(R, 139);
    analogWrite(G, 255);
    analogWrite(B, 234);
    delay(timea);
    break;
  }
  case 67:{                                  //Grado 20
    analogWrite(R, 149);
    analogWrite(G, 255);
    analogWrite(B, 213);
    delay(timea);
    break;
  }
  case 68:{                                 //Grado 30
    analogWrite(R, 160);
    analogWrite(G, 255);
    analogWrite(B, 191);
    delay(timea);
    break;
  }
  case 69:{                                 //Grado 40
    analogWrite(R, 171);
    analogWrite(G, 255);
    analogWrite(B, 170);
    delay(timea);
    break;
  }
  case 70:{                                 //Grado 50
    analogWrite(R, 181);
    analogWrite(G, 255);
    analogWrite(B, 149);
    delay(timea);
    break;
  }
  case 71:{                                 //Grado 60
    analogWrite(R, 192);
    analogWrite(G, 255);
    analogWrite(B, 128);
    delay(timea);
    break;
  }
  case 72:{                                 //Grado 70
    analogWrite(R, 203);
    analogWrite(G, 255);
    analogWrite(B, 106);
    delay(timea);
    break;
  }
  case 73:{                                 //Grado 80
    analogWrite(R, 213);
    analogWrite(G, 255);
    analogWrite(B, 85);
    delay(timea);
    break;
  }
  case 74:{                                 //Grado 90
    analogWrite(R, 224);
    analogWrite(G, 255);
    analogWrite(B, 64);
    delay(timea);
    break;
  }
  case 75:{                                 //Grado 100
    analogWrite(R, 235);
    analogWrite(G, 255);
    analogWrite(B, 43);
    delay(timea);
    break;
  }
  case 76:{                                 //Grado 110 
    analogWrite(R, 245);
    analogWrite(G, 255);
    analogWrite(B, 21);
    delay(timea);
    break;
  }
  case 77:{                                 //Grado 120   BLU al massimo
    analogWrite(R, 255);
    analogWrite(G, 255);
    analogWrite(B, 0);
    delay(timea);
    break;
  }
  case 78:{                                 //Grado 130   scende il BLU e sale il VERDE
    analogWrite(R, 255);
    analogWrite(G, 234);
    analogWrite(B, 21);
    delay(timea);
    break;
  }
  case 79:{                                 //Grado 140
    analogWrite(R, 255);
    analogWrite(G, 213);
    analogWrite(B, 43);
    delay(timea);
    break;
  }
  case 80:{                                 //Grado 150
    analogWrite(R, 255);
    analogWrite(G, 191);
    analogWrite(B, 64);
    delay(timea);
    break;
  }
  case 81:{                                 //Grado 160
    analogWrite(R, 255);
    analogWrite(G, 170);
    analogWrite(B, 85);
    delay(timea);
    break;
  }
  case 82:{                                 //Grado 170
    analogWrite(R, 255);
    analogWrite(G, 149);
    analogWrite(B, 106);
    delay(timea);
    break;
  }
  case 83:{                                 //Grado 180
    analogWrite(R, 255);
    analogWrite(G, 128);
    analogWrite(B, 128);
    delay(timea);
    break;
  }
  case 84:{                                 //Grado 190
    analogWrite(R, 255);
    analogWrite(G, 106);
    analogWrite(B, 149);
    delay(timea);
    break;
  }
  case 85:{                                 //Grado 200
    analogWrite(R, 255);
    analogWrite(G, 85);
    analogWrite(B, 170);
    delay(timea);
    break;
  }
  case 86:{                                 //Grado 210
    analogWrite(R, 255);
    analogWrite(G, 64);
    analogWrite(B, 191);
    delay(timea);
    break;
  }
  case 87:{                                 //Grado 220
    analogWrite(R, 255);
    analogWrite(G, 43);
    analogWrite(B, 213);
    delay(timea);
    break;
  }
  case 88:{                                 //Grado 230
    analogWrite(R, 255);
    analogWrite(G, 21);
    analogWrite(B, 234);
    delay(timea);
    break;
  }
  case 89:{                                 //Grado 240   VERDE al massimo
    analogWrite(R, 255);
    analogWrite(G, 0);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 90:{                                 //Grado 250 scende il VERDE  sale il ROSSO
    analogWrite(R, 244);
    analogWrite(G, 21);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 97:{                                 //Grado 260
    analogWrite(R, 234);
    analogWrite(G, 43);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 98:{                                 //Grado 270
    analogWrite(R, 223);
    analogWrite(G, 64);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 99:{                                 //Grado 280
    analogWrite(R, 212);
    analogWrite(G, 85);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 100:{                                 //Grado 290
    analogWrite(R, 202);
    analogWrite(G, 106);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 101:{                                 //Grado 300
    analogWrite(R, 191);
    analogWrite(G, 128);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 102:{                                 //Grado 310
    analogWrite(R, 180);
    analogWrite(G, 149);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 103:{                                 //Grado 320
    analogWrite(R, 170);
    analogWrite(G, 170);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 104:{                                 //Grado 330
    analogWrite(R, 159);
    analogWrite(G, 191);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 105:{                                 //Grado 340
    analogWrite(R, 148);
    analogWrite(G, 213);
    analogWrite(B, 255);
    delay(timea);
    break;
  }
  case 106:{                                 //Grado 350
    analogWrite(R, 138);
    analogWrite(G, 234);
    analogWrite(B, 255);
    delay(timea);
    break;
  }

scusate ma era troppo lungo e non potevo inserirlo.. questa è la continuazione

  case 110:{                                 //BIANCO
  analogWrite(R, 170);
  analogWrite(G, 0);
  analogWrite(B, 100);
  delay(timea);
  break;
  }
  case 111:{                                  //percorso 1
    analogWrite(R, 128);
    analogWrite(G, 255);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 139);
    analogWrite(G, 255);
    analogWrite(B, 234);
    delay(timeb);
    analogWrite(R, 149);
    analogWrite(G, 255);
    analogWrite(B, 213);
    delay(timeb);
    analogWrite(R, 160);
    analogWrite(G, 255);
    analogWrite(B, 191);
    delay(timeb);
    analogWrite(R, 171);
    analogWrite(G, 255);
    analogWrite(B, 170);
    delay(timeb);
    analogWrite(R, 181);
    analogWrite(G, 255);
    analogWrite(B, 149);
    delay(timeb);
    analogWrite(R, 192);
    analogWrite(G, 255);
    analogWrite(B, 128);
    delay(timeb);
    analogWrite(R, 203);
    analogWrite(G, 255);
    analogWrite(B, 106);
    delay(timeb);
    analogWrite(R, 213);
    analogWrite(G, 255);
    analogWrite(B, 85);
    delay(timeb);
    analogWrite(R, 224);
    analogWrite(G, 255);
    analogWrite(B, 64);
    delay(timeb);
    analogWrite(R, 235);
    analogWrite(G, 255);
    analogWrite(B, 43);
    delay(timeb);
    analogWrite(R, 245);
    analogWrite(G, 255);
    analogWrite(B, 21);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 255);
    analogWrite(B, 0);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 234);
    analogWrite(B, 21);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 213);
    analogWrite(B, 43);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 191);
    analogWrite(B, 64);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 170);
    analogWrite(B, 85);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 149);
    analogWrite(B, 106);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 128);
    analogWrite(B, 128);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 106);
    analogWrite(B, 149);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 85);
    analogWrite(B, 170);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 64);
    analogWrite(B, 191);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 43);
    analogWrite(B, 213);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 21);
    analogWrite(B, 234);
    delay(timeb);
    analogWrite(R, 255);
    analogWrite(G, 0);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 244);
    analogWrite(G, 21);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 234);
    analogWrite(G, 43);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 223);
    analogWrite(G, 64);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 212);
    analogWrite(G, 85);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 202);
    analogWrite(G, 106);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 191);
    analogWrite(G, 128);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 180);
    analogWrite(G, 149);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 170);
    analogWrite(G, 170);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 159);
    analogWrite(G, 191);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 148);
    analogWrite(G, 213);
    analogWrite(B, 255);
    delay(timeb);
    analogWrite(R, 138);
    analogWrite(G, 234);
    analogWrite(B, 255);
    delay(timeb);
    break;
  }  
}
}
}

Lele88ita: Come da titolo sto cercando di far funzionare un led RGB comandato dalla seriale.

Comandato attraverso la seriale da chi? I soggetti sono due, Arduino legge un dato da seriale e in base alla lettera spedita pilota i led. Ma chi spedisce? Quale programma è il secondo soggetto? Il problema potrebbe essere in questo programma che spedisce. Anche lui è da postare.

hai ragione.per ora da pc con il monitor seriale poi sarà da bluetooth con un cellulare..

Non serve nessun programma stratosferico per spedite i dati seriali. Lo fa direttamente dal serial monitor.
Tornando al problema originale è normale che non riparte daccapo perché lo switch arrivato al break esce, ed al giro successivo non ci sono dati nel buffer seriale.
Devi cambiare la logica di funzionamento

ho provato a mettere un while ma non capisco bene come fare..

ragiona su quello che ti ho detto, lo switch non parte al nuovo giro di loop perche' il primo if e' falso quando non si inviano dati seriali, quindi ad esempio potresti copiare di volta in volta l'ultimo case in un array di dati da mandare in loop quando i dati seriali non sono presenti

Non sapevo che da Monitor si potesse anche spedire. Buono a sapersi.

X il programma, fatemi capire, da seriale dici quale tipo di colore/sequenza vuoi, ma poi quella sequenza arduino la deve continuare a fare? Da seriale cambi solo il tipo di sequenza, non continui da seriale a sparare comandi, giusto. Ora ho capito cosa vuoi fare.

Prova a pensarla così: il codice è già in un while infinito, in quanto la loop è un ciclo infinito. Solo che tu fai qualcosa SOLO se c'e' un dato da seriale, come ha ben detto Testa. Non dovresti fare tutto quella roba nella if.

nid69ita:
Non sapevo che da Monitor si potesse anche spedire. Buono a sapersi.

E’ quella riga in alto: scrivi e spedisci con invio. Puoi selezionare anche se spedire o meno il carattere di invio (\n o \n, \r o quel che è a seconda del sistema), ovviamente è un carattere extra e devi considerarlo lato Arduino.

prova questo codice:

//Sketch eseguito per un led RGB con anodo in comune

const int R = 11;                              //definizione costante Red
const int G = 10;                              //definizione costante Green
const int B = 6;                               //definizione costante Blue
int a;                                         //definizione variabile a dove memorizzo il valore seriale
char b;
const int timea = 200;                         //definizione di un tempo per delay successivi
const int timeb = 200;

boolean bPercorso = false;

void setup()
{
  pinMode(R, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(B, OUTPUT);

  Serial.begin(9600);

}

void loop()
{
 if (Serial.available()>0)                  //Se esiste un dato sulla seriale
 {
    a = Serial.read( );
    bPercorso = false; // pre imposto a falso il percorso
    if ((a>=64) && (a<=77)){
      analogWrite(R, (map (a, 64, 77,128,255) ));
      analogWrite(G, 255);
      analogWrite(B, (map (a, 64, 77,255,0) ));
    }
    if ((a>=78) && (a<=89)){
      analogWrite(R, 255 );
      analogWrite(G, (map (a, 78, 89,234,0) ));
      analogWrite(B, (map (a, 78, 89,21,255) ));
    }
    if ((a>=90) && (a<=106)){
      analogWrite(R, (map (a, 90, 106,244,138) ));
      analogWrite(G, (map (a, 90, 106,21,234) ));
      analogWrite(B, 255);
    }
    if (a == 110){
      analogWrite(R, 170);
      analogWrite(G, 0);
      analogWrite(B, 100);
    }
    if (a == 111){
      bPercorso = true; // sono in modalità percorso
      percorso();
    }
    delay(timea); // non sto a ripeterlo in ogni if, lo metto alla fine e vale per tutti
  }else{
    if (bPercorso){
      percorso();
    }
  }
}
  
void percorso()
{
    for (int i=1; i < 13; i++){ // da 1 a 12
    	analogWrite(R, (map (i, 1, 12,128,255) ));
        analogWrite(G, 255);
        analogWrite(B, (map (i, 1, 12,255,0) ));
    	delay(timeb);	
    }	
    for (int i=1; i < 13; i++){ // da 1 a 12
    	analogWrite(R, 255 );
        analogWrite(G, (map (i, 1, 12,234,0) ));
        analogWrite(B, (map (i, 1, 12,21,255) ));
    	delay(timeb);	
    }
    for (int i=1; i < 13; i++){ // da 1 a 12	
    	analogWrite(R, (map (i, 1, 12,244,138) ));
    	analogWrite(G, (map (i, 1, 12,21,234) ));
    	analogWrite(B, 255);
        delay(timeb);
    }
}

usando il map ho ridotto un po’ il codice.
praticamente guarda se ci sono dati sulla seriale, se non ci sono controlla se è in modalità percorso lumino, in caso positivo allora chiama la funzione percorso, e quindi si ripete in continuazione.
il percorso luminoso viene interrotto quando si imposta un nuovo valore, attenzione però che l’interruzione avviene solo dopo aver finito una sequenza, questo perchè il codice legge sulla seriale solo ad inizio loop.

lollotek: prova questo codice:

usando il map ho ridotto un po' il codice. praticamente guarda se ci sono dati sulla seriale, se non ci sono controlla se è in modalità percorso lumino, in caso positivo allora chiama la funzione percorso, e quindi si ripete in continuazione. il percorso luminoso viene interrotto quando si imposta un nuovo valore, attenzione però che l'interruzione avviene solo dopo aver finito una sequenza, questo perchè il codice legge sulla seriale solo ad inizio loop.

Si sembrerebbe la soluzione. in pausa pranzo do un occhiata.. vi ringrazio tutti per la rapidità di risposta.. a dopo

Allora.... è molto buona come soluzione, faccio un po fatica a capire il senso preciso dei comandi, ma ci siamo.. solo 2 cose. Non si riesce a impostare che esce immediatamente dal percorso? Se voglio aggiungere un secondo percorso aggiungo un altra funzione booleana?

Lele88ita: Non si riesce a impostare che esce immediatamente dal percorso?

Il metodo sarebbe quello di avere una variabile globale che guarda a che punto è il percorso, ed ad ogni ciclo fa un solo write, così ritorna subito a rileggere la seriare.

Lele88ita: Se voglio aggiungere un secondo percorso aggiungo un altra funzione booleana?

al posto di una booleana potresti usare un int, tipo statoPercorso: statoPercorso = 0 -> non fare il percorso statoPercorso = 1 -> fai percorso 1 statoPercorso = 2 -> fai percorso 2

così è anche più flessibile se ne vuoi aggiungere altri mano a mano..

nel frattempo ho capito come funziona il tuo sketch.. sono riuscito a mettere un'altra funzione booleana e attivare un secondo void.. :D dove fa i colori random.. e onestamente mi sembra sia meglio che finisce il percorso prima di uscire. quindi direi che per ora siete stati d'aiuto tutti, specialmente lollotek. GRAZIE.