Pilotaggio RGB senza lampeggi o Fade

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.

Il nome scelto per una funzione non è determinante per l'esito del funzionamento. In sostanza si può scegliere un nome a piacere. In programmazione di distinguono due metodi detti get e set.
get prende o preleva o ancora legge una informazione.
set imposta configura cambia i valori.

La stessa distinzione la possiamo fare tra "read" e "write". Per scegliere il nome per la funzione userò quindi readnomefunzione se la mia funzione legge delle informazione. Userò writenomefunzione nel caso di scrittura.

Il nome completo della funzione (ma anche di variabili) fornisce al programmatore delle informazioni supplementari per questo motivo è bene usare un nome autodocumentante anziché xxx (nome valido per il compilatore) che non fornisce informazioni supplementari.

Se volessi usare la lingua Italiana al posto di setRgb_1 potrei scrivere impostaColoreRgb_1 e la funzione in questione apparirebbe come di seguito:

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

Però solo che conosce la lingua Italiana può ricavare informazioni supplementari dal nome di questa funzione, per cui visto che la lingua Inglese è concisa e universalmente conoscita in ambito tecnico scentifico il nome setRgb_1 risulta comprensibile da tutti.

Pensa alle informazioni supplementari che si ricavano dal nome della funzione "analogWrite", scrive delle informazioni analogiche anziché digitali e infatti esiste digitalWrite.

Ciao.

Buon Giorno,
vorrei ringraziare tutti per i preziosi suggerimenti che mi avete dato, probabilmente per voi non è piu di tanto ma per mè è Tantissimo Grazie Ancora.
Per coretezza allego lo sketch .

> /* 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
> 
> /* Pin 3, 5, 6, 9, 10, 11 sono Pin PWM */
> 
> 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   = 665;
> /* Il led si accende quando il valore ISTANTANEO supera il valore impostato  */
> // I valori dell fotodiodo con piena luce il valore è basso con il buio il valore è alto.
> // In senso Orario AUMENTA la SENSIBILITà e Viceversa
> 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); // Input = Entrata o Autput = Uscita
> 
>   //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 ); // Restituitsce un valore 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);
> }
> 
> void AccendiRGB_1 ( byte Rosso, byte Verde, byte Blu )  {
> 
>   analogWrite ( RGB_1_Rosso,    Rosso );
>   analogWrite ( RGB_1_Verde,    Verde );
>   analogWrite ( RGB_1_Blu,      Blu   );
> }
> 
> void AccendiRGB_2 ( byte Rosso, byte Verde, byte Blu )  {
> 
>   analogWrite ( RGB_2_Rosso,    Rosso );
>   analogWrite ( RGB_2_Verde,    Verde );
>   analogWrite ( RGB_2_Blu,      Blu   );
> }
> 
> /**********************************************************************************************************************/
> 
> //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.
>     
>     AccendiRGB_1 ( 255, 255, 255  );
>     AccendiRGB_2 ( 255, 255, 255  );
>   }
>   else  // Altrimenti
>   {
>     //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
>       
>       AccendiRGB_1 ( 242, 255,   155  );
>       AccendiRGB_2 ( 255, 255, 255  );
>     }
>     else  // Altrimenti
>     {
>       //Campanello premuto
>       
>       AccendiRGB_1 ( 255, 255, 255  );
>       AccendiRGB_2 ( 255, 0  , 255  );
>     }
>   }
> }

Spero di averlo inserito in maniera corretta lo sketch, non capisco perchè esce il testo scritto in rosso.

Ora provo riprendere per mano uno sketch che avevo abbandonato perchè non riuscivo più andare avanti, chissà di riuscirci questa volta.

Difetto del parser del sito. Il parser analizza ogni carattere, quando incontra due // consecutivi dovrebbe colorare ciò che segue ad esempio con il grigio e invece incontra il carattere ' apice singolo al quale non segue l'apice di chiusura e colora tutto in rosso.

Se elimini il carattere ' apice l'anomalia non si verifica.

{
   //C'è luce, quindi non acendo nulla.
// il mio commento senza apice

Strano, adesso non lo colora di rosso, mi sbagliavo.

Però compare un carattere strano. Comunque per postare il codice sorgente puoi premere CTRL-E (la E anche minuscola)

/* VARIABILI & COSTANTI ↓ */

Riedita il tuo post usando l'icona con la matita, seleziona nell'ide il codice copialo con CTRL-C, nel forum premi CTRL-E e poi CTRL-V.

Ciao.

... dopo aver marcato il codice con l'apposito bottone </>, troverete prima del codice come 3 puntini ed alla fine del codice di nuovo questa specie di tre puntini.

Andate alla riga dove si trovano i primi tre puntini (ovvero quella che da inizio alla parte codice) e, di seguito sulla stessa riga aggiungete " cpp" ovvero dovrete avere un qualche cosa come "... cpp".

In questo modo avrete detto al sistema che quel codice è scritto in C/C++ ed eviterà di interpretare in modo diverso alcune sequenze.

Guglielmo

P.S.: ... nel codice del post #30 l'ho aggiunto io

1 Like

Grazie Guglielmo questa è nuova per me.
Ciao.

... :slight_smile: ... credo che dopo i 3 puntini si possano mettere anche altri acronimi per indicare, al plugin per il codice di discourse, il linguaggio che stai usando così lui lo colora di conseguenza.

In teoria :grin: dovrebbe accettare:

Guglielmo

10 posts were split to a new topic: Comando per ritardo ad Elettrovalvola