Pilotaggio RGB senza lampeggi o Fade

Buona Sera,

Ho scritto un semplice Sketch in qui accendo manualmente ( inserendo il valore nella sua cella ) i 3 led singolarmente prima il Rosso spengo il rosso accendo il verde spengo il verde sccendo il blù.
Allego il semplice sketch;

/*********************************************************************************************************************/

/*  Variabili & Costanti  */

/* Piedinatura componenti */
const byte RGB_1_Rosso      = 9;   //PWM
const byte RGB_1_Verde      = 10;  //PWM
const byte RGB_1_Blu        = 11;  //PWM

const byte Led_2_Arduino    = 13;  // Led inegrato in Arduino NON è PWM

/*********************************************************************************************************************/

//mettere il codice di installazione qui, per eseguire una volta: ↓.
void setup() {

  /* Imposto i pin DIGITALI( PWM ) come porte APERTE ( OUTPUT ) */
  pinMode ( RGB_1_Rosso,      OUTPUT );
  pinMode ( RGB_1_Verde,      OUTPUT );
  pinMode ( RGB_1_Blu,        OUTPUT );

  pinMode ( Led_2_Arduino,    OUTPUT );

}

/**********************************************************************************************************************/

//inserire il codice principale qui, per eseguire ripetutamente: ↓.
void loop() {

  /*Accendere l'RGB ( HIGH o 1( ALTO è 5V )( è la tensione sul pin )*/
  /* Spegne l'RGB portandolo a LOW o 0 ( BASSO, 0v.)*/
  
  digitalWrite ( RGB_1_Rosso,      1 ); // Il Led con  ANODO al Comune a 0 si Accende ed a 1 si Spegne
  digitalWrite ( RGB_1_Verde,      1 ); // Il Led con  ANODO al Comune a 0 si Accende ed a 1 si Spegne
  digitalWrite ( RGB_1_Blu,        1 ); // Il Led con  ANODO al Comune a 0 si Accende ed a 1 si Spegne

  digitalWrite ( Led_2_Arduino,    0 );

}

/************************************************** F I N E ******************************************************/

E fino a qui è tutto OK Ora il problema è come scrivere il codice per dirgli di mescolare i colori, se volessi per Es.
il Viola
Ciano
Rosa
Arancio Ecc......
come potrei fare, al momento non ho nessuna base su cui apogiarmi per iniziare.
Fino ad ora sono andato a Tentativi che non hanno portato a nulla.
Se ci fosse un buon Anima che potrebbe fare un Es. o Consigliare come Iniziare.....

Per fare i vari colori devi miscelare le 3 componenti RGB.
Qui spiega come funziona lo spazio colore rgb

Edit:
Se invece della digitalWrite usi la analogWrite con valori da 0 a 255 puoi ottenere tutte le sfumature che vuoi

Questo link può tornati utile.
Ovviamente come ha specificato @nid69ita dovrai usare analogWrite al posto di digitalWrite.

Con i 3 led accesi alla massima intensità dovresti avere
il bianco (o quasi).

Dimenticavo, in passato ho trovato delle librerie, prova a cercarle tramite arduino IDE.
Ciao.


Buona Sera,
Credo di esserci Riuscito,
pensate si possa migliorare lo sketch?


`/*  Variabili & Costanti  */

/* Piedinatura componenti */
const byte RGB_1_Rosso      = 9;  
const byte RGB_1_Verde      = 10; 
const byte RGB_1_Blu           = 11;  

const byte Led_2_Arduino    = 13; 

//mettere il codice di installazione qui, per eseguire una volta: ↓.
void setup() {

  pinMode ( RGB_1_Rosso,      OUTPUT );
  pinMode ( RGB_1_Verde,      OUTPUT );
  pinMode ( RGB_1_Blu,        OUTPUT );
  pinMode ( Led_2_Arduino,    OUTPUT );
}
//inserire il codice principale qui, per eseguire ripetutamente: ↓.
void loop() {
digitalWrite ( Led_2_Arduino,   1 );
 RGB_1 ( 255, 0, 0 );
}
void RGB_1( int Rosso, int Verde, int Blu )  {
  analogWrite ( RGB_1_Rosso,   Rosso );
  analogWrite ( RGB_1_Verde,   Verde );
  analogWrite ( RGB_1_Blu,       Blu );
}



````Testo preformattato`
````Testo preformattato`

Un algoritmo si da per scontato che sia sempre migliorabile anche quando non abbiamo idea di come migliorarlo.

Un codice sorgente può essere migliorati in due modi principali:

  1. Il codice viene modificato per svolgere le stesse funzioni impegnando meno risorse (cioè meno RAM, FLASH memory ecc)

  2. Il codice può essere modificato per renderlo più comprensibile o quanto meno possibile ambiguo.

Quando un algoritmo è semplice come il tuo vengono in mente solo modifiche che rientrano principalmente nel punto 2, ma come mostro di seguito conivolgono anche il punto 1.

Prima però una premessa; ci hanno insegnato che un algoritmo ha un inizio ed una fine e tu correttamente lo hai evidenziato. Tuttavia l'architettura software usata da arduino è conosciuta con il termine "superloop" dove a seguire la fine c'è l'inizio, in sostanza è come un anello nello specifico il termine è "ciclo infinito", quindi dopo la tua ultima istruzione verrà eseguita la seguente:

digitalWrite ( Led_2_Arduino, 1 );

Ora le modifiche riguarda sia il punto 1 e 2.
Perchè usare int quando il valore che gli assegniamo sta comodamente dentro un solo byte?
Inoltre il tipo di dato int occupa due byte e possiamo assegnargli valori negativi (cioè con il memo davanti), io da osservatore del tuo programma complesso cado nell'errore da deduzione, cioè vedo int è deduco che assumera numeri negativi. Ovviamente non accade ciò quando il programma conta poche righe come in questo caso.

Quindi la modifica migliora la comprensione del codice e in più risparmio risorse all'interno della memoria stack, cioè con una fava due piccioni. :grinning:

Altre modifiche riguardanti il punto due si basano su convenzioni del tipo, le costanti sono sempre in maiscolo, i nomi di funzione seguono il camel case, cioè pinMode e non pinmode, analogWrite, digitalWrite ecc.

Seguendo le convenzioni si è anche coerenti con le funzioni già presenti nelle librerie arduino.

Ma visto la brevità del codice questo risulta comprensibile anche non seguendo le convenzioni.

Ciao.

@58019378 in conformità al REGOLAMENTO , punto 7, cortesemente edita il tuo post poco sopra (quindi NON scrivendo un nuovo post, ma utilizzando il bottone a forma di piccola matita :pencil2: che si trova in basso del tuo post), seleziona TUTTA la parte di codice e premi l'icona </> nella barra degli strumenti per contrassegnarla come codice.

Inoltre, così com'è, esso non è molto leggibile ... assicurati di averlo correttamente indentato nell'IDE prima di inserirlo (questo lo si fa premendo ctrlT su un PC o cmd T su un Mac all'intero del IDE). Per maggiori informazioni ... punto 17.2 del succitato regolamento. Grazie.

Guglielmo


@Maurotec : prima di rispondere, corrtesemente, aiuta a far rispettare il REGOLAMENTO per la parte del codice ... grazie :slight_smile:

Buon Giorno,

Sopra ho sperimentato come dare il comando per accendere l'RGB e funziona, ora il comando per dirgli di lasciarlo spento come si potrebbe compilare il comando ?

Sto sempre aspettando che sistemi il codice come chiesto QUI ... :roll_eyes:

Guglielmo

P.S.: Ti ricordo che, purtroppo, fino a quando non sarà sistemato il codice, nel rispetto del suddetto regolamento nessuno ti potrà rispondere, quindi ti consiglio di fare il tutto al più presto. :wink:

Salve,
chiedo scusa per l'ignoranza ma non ho proprio capito che devo fare, non è che non voglio farlo è che se non capisco cosa fare non lo posso fare.

Se leggi con attenzione il mio messaggio lo capisci ... si tratta di sistemare il codice nell'IDE con la corretta indentatura, di editare il post e di inserire il codice correttamente indentato marcandolo come codice (bottone </>).

Guglielmo

Boooo, qualcosa è cambiato non so se sia sufficente quello che è sucesso e se lo si deve anche trasferire piu in su non trovo il comando.

Uh?...
Mi sembra che vada bene...

Questa non l'ho capita...

Il post N° 12 quello che ho dovuto sistemare lo sketch fa accendere il led RGB, poi ce il comando per far accendere il led N°13 di arduino, quest ultimo cambiando valore da 1 a 0 il led si spegne o si accende.
Diversamente il led RGB momentaneamente non ha questa possibilità perchè rimane sempre acceso una volta caricato lo sketch.
Vortrei inserirgli il comando per poterlo anche spegnere ( non a intermittenza, tutto spento).

Che peccato, :sob: :sob:

mi devo arrendere abbandono il progetto per impossibilita di continuare dal momento che non riesco trovare risposta per i comandi che servono per prosegire.
Pazienza...... :sob:

Accendere un led rgb nei vari colori è davvero troppo semplice per non riuscire a finire un progetto...
Per ogni pin (R - G - B) usi la analogWrite come ti è stato detto. I valori vanno da 0 a 255 dove 0 vuol dire led spento e 255 vuol dire led acceso alla massima luminosità. I valori intermedi produrranno luminosità progressive.

Apparentemente sembra che ci sia riuscito anche se la parte dei comandi che accendono gli RGB non mi piace cosi comè, sò e sono sicuro che si potrebbe convertire quello che ho scritto con il codice Void che semplificherebbe lo sketch solo che ancora non ho trovato come va digitato al interno dello sketch ci ho provato ma non mi funziona.


* VARIABILI & COSTANTI ↓ */
//       TIMERS
unsigned long previousMillis_A          = 0 ;
unsigned long previousMillis_B          = 0 ;

// Intervallo di misurazione livello luce
const unsigned long interval_A          = 5000;

// Intervallo di accensione led rosso dopo il rilascio del PULSANTE
const unsigned long interval_B          = 2000;

//       PIEDINATURA
/* Piedinatura componenti */

// N° pin analogico dell fotodiodo A0
const byte pin_Analogico                 = A0;


//Definizione pin primo RGB
const byte RGB_1_Rosso      = 11;  
const byte RGB_1_Verde      = 10;  
const byte RGB_1_Blu        =  9;  


//Definizione pin secondo RGB
const byte RGB_2_Rosso       =  6;  
const byte RGB_2_Verde       =  5;  
const byte RGB_2_Blu         =  3;  

//Pulsante campanello
const byte pulsante_1       = 2;

//Limite Fotodiodo
const int LimiteFotodiodo = 660;

int valLumen              = 0;

byte vecchio_stato;

//mettere il codice di installazione qui, per eseguire una volta: ↓.
void setup()  {

  Serial.begin (9600 );

  pinMode (pulsante_1,         INPUT); 

  //Imposto i pin digitali come porte aperte (Output).

  pinMode ( RGB_1_Rosso,      OUTPUT );
  pinMode ( RGB_1_Verde,      OUTPUT );
  pinMode ( RGB_1_Blu,        OUTPUT );

  pinMode ( RGB_2_Rosso,      OUTPUT );
  pinMode ( RGB_2_Verde,      OUTPUT );
  pinMode ( RGB_2_Blu,        OUTPUT );
}
void LetturaFotodiodo ()  {

  valLumen = analogRead  (pin_Analogico ); //  Valore restituito tra 0 - 1023
  Serial.print ("SensoreFotoDiodo : ");
  Serial.print (valLumen);
  Serial.println (" ☼ ");
}
byte Premuto (byte pin)
{
  if (digitalRead (pin))
  {
    delay (5);
    return (digitalRead (pin));
  }
  return (0);
}
//inserire il codice principale qui, per eseguire ripetutamente: ↓.
void loop() {

  //Letura fotodiodo
  if ( millis () - previousMillis_A >= interval_A )
  {
    LetturaFotodiodo ();
    previousMillis_A = millis();
  }
  if (vecchio_stato == 0)
  {
    //Campanello non premuto
    if (Premuto (pulsante_1))
    {
      //Campanello appena premuto
      vecchio_stato = 1;
    }
  }
  if (vecchio_stato == 1)
  {
    //Campanello premuto
    if (!Premuto (pulsante_1))
    {
      //Campanello appena rilasciato
      vecchio_stato = 2;
      previousMillis_B = millis();
    }
  }
  if (vecchio_stato == 2)
  {
    //Campanello rilascato
    if (millis() - previousMillis_B > interval_B)
    {
      //Intervallo di sicurezza superato
      vecchio_stato = 0;
    }
  }
  if ( LimiteFotodiodo > valLumen )

  {
    //C'è luce, quindi non acendo nulla.

    analogWrite( RGB_1_Rosso,   255 );
    analogWrite( RGB_1_Verde,   255 );
    analogWrite( RGB_1_Blu,     255 );

    analogWrite( RGB_2_Rosso,   255 );
    analogWrite( RGB_2_Verde,   255 );
    analogWrite( RGB_2_Blu,     255 );
  }
  else 
  {
    //Fa buio, quindi accendo il bianco se NON sto premendo il campanello, e il rosso se lo sto premendo o lo ho appena premuto;
    if (vecchio_stato == 0)
    {
      //Campanello non premuto

      analogWrite( RGB_1_Rosso,    0 );
      analogWrite( RGB_1_Verde,    255 );
      analogWrite( RGB_1_Blu,      0 );

      analogWrite( RGB_2_Rosso,    255 );
      analogWrite( RGB_2_Verde,    255 );
      analogWrite( RGB_2_Blu,      255 );
    }
    else 
    {
      //Campanello premuto
      {
        analogWrite( RGB_1_Rosso,  255 );
        analogWrite( RGB_1_Verde,  255 );
        analogWrite( RGB_1_Blu,    255 );

        analogWrite( RGB_2_Rosso,   212 );
        analogWrite( RGB_2_Verde,  255 );
        analogWrite( RGB_2_Blu,     127 );
      }
    }
  }
}

Qualche suggerimento su come inserire il void?
Io ci riproverò ma magari con un piccolo consiglio su come fare forse diventerebbe meno complicato, ho una mezza idea su come dovrebbe andare scritto solo che ancora non funziona.

Fai così...
RGB_1 (0,0,0);

Per essere un principiante scrivi codice molto leggibile, cioè c'è chi dopo anni ancora non identa il codice nonostante si chieda di premere CTRL-T e questo vuole dire che non danno peso alla legibilità. Quindi io non getterei così facilmente la spugna fossi in te e come vedi porta pasienza che qualcuno prima o poi interviene.

Ciao.

Nel commento dici una cosa e nel codice fai l'opposto. Riguardo alla funzione void di cui parli forse ti riferisci a quella che avevi postato nel primo codice. La puoi copiare da qui e incollarla.

void setRgb_1 ( byte r, byte g, byte b ) {
    analogWrite( RGB_1_Rosso,   r );
    analogWrite( RGB_1_Verde,   g );
    analogWrite( RGB_1_Blu,   b );
}

Nel punto in cui vuoi chiamare la funzione in questione scrivi:

setRgb_1 (255, 255, 255);  // li accende tutti e 3 alla massima luminosità

oppure per spegnerli:

setRgb_1 ( 0, 0, 0 ); // spegne tutti i 3 led

Ciao.

Buon Giorno Maurotec,
la ringrazio per la risposta ed aver risposto.
Io il codice con il void lo avevo provato e non mi funzionava ora vista la sua risposta ho notato che ha messo setRGB_1, le posso chiedere per cosa sta il set davanti al nome? non lo avevo mai visto.