Gioblu RBG lamp

Ecco l’ennesima lampada rbg, solo che questa l’ho costruita io :smiley:
A breve scriverò l’articolo con codice e schema. Per ora vi posto un video e il codice :smiley:

Scusate la pessima qualità del video, spero si capisca :smiley:
Ora che sul mio telefono ho rovesciato un bicchiere di spuma credo che i video saranno migliori :smiley:
2 funzioni del telecomando non le ho scritte per ora, non per mancanza di voglia ma per la poca utilità IMHO. Incrementare o ridurre la luminosità a me non serve :smiley:
Che ve ne pare? ho usato un bell espediente per cercare di creare tutti i colori possibili nelle funzioni di FADE e SMOOTH (che ho inteso come fade veloce e fade lento rispettivamente).

#include <IRremote.h>

int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
int pins[]={5,9,10};
int scala_c[]={255,0,0,255,115,15,255,0,70,255,0,95,255,0,215,255,0,255,0,100,255,10,140,215,0,150,115,0,225,50,0,255,0,0,255,0,0,255,0,255,255,0,255,255,0,255,255,255};
word col[] ={0x906F,0x10EF,0x50AF,0xB04F,0x30CF,0x708F,0xA857,0x28D7,0x6897,0x9867,0x18E7,0x58A7,0x8877,0x8F7,0x48B7,0xD02F};
word funzione[] = {0xA05F,0x20DF,0x609F,0xE01F,0xF00F,0xE817,0xD827,0xC837};
int rbg =0;
 int rbg_matrix[6][3] =
{
  {255, 0,  0 },
  { 0, 255, 0 },
  { 0,  0, 255},
  { 0, 255,255},
  {255, 0, 255},
  {255,255, 0 },
};
 int stat_prec=0;
 int stat_succ=0;
 int fading[] = {0,0,0};
boolean set = LOW;
long int tempo_delay = 0; 
int debounce = 30;
void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}

word decodifica(){
  word var = 0x0000;
 if (irrecv.decode(&results)) {
  var = (results.value);
 // Serial.println(var,HEX);
 //delay(50);
  return var;
  irrecv.resume();
 }
}

void loop() {
if (irrecv.decode(&results)) {
    colors();
    irrecv.resume();
 }
}

void colors(){
if (irrecv.decode(&results)) {
  switch(funz()){
case 0:
  //if(decodifica() == funzione[0]){
    Serial.println("funzione 0");
    if(rbg<255) rbg+=17;
    else rbg =0;
 // }
  break;
  case 1:
//  if(decodifica() == funzione[1]){
   Serial.println("funzione 1");
    if(rbg>-255) rbg-=17;
    else rbg = 0;
    
  //}
  break;
  case 2:
  rbg_clear();
  Serial.println("funzione OFF");
  break;
  case 3:
  //Bottone On premuto Funzione testing led
 Serial.println("funzione TEST");
   rbg_clear();
      for(int i =0;i<3;i++){
            for(int a = 0; a < 256; a +=5){
              analogWrite(pins[i],a);
              delay(10);
             }
            for(int a = 255; a>0; a -= 5){
              analogWrite(pins[i],a);
              delay(10);  
           } 
          rbg_clear(); 
        }   
 break;
 case 4:
   //funzione FLASH
 Serial.println("funzione FLASH");
  set = LOW;
  while(set == LOW){
  if (irrecv.decode(&results)) {
  if(funz() == 2) {
    set = HIGH;
  }
  else{
    set == LOW;
  }
   irrecv.resume();
    } 
  for(int i =0;i<3;i++)
    analogWrite(pins[i],scala_c[rnd()]);
    delay(100);
    rbg_clear();
  }
 
 break;
  
 case 5:
  Serial.println("funzione STROBE");
 //funzione STROBE
  set = LOW;
  while(set == LOW){
  if (irrecv.decode(&results)) {
  if(funz() == 2) {
    set = HIGH;
  }
  else{
    set == LOW;
  }
   irrecv.resume();
    } 
  for(int i =0;i<3;i++)
    analogWrite(pins[i],255);
    delay(25);
    rbg_clear();
    delay(25);
  }
 
 break;
 case 6:
    Serial.println("funzione FADE");
  //funzione FADE
  set = LOW;
  while(set == LOW){
  if (irrecv.decode(&results)) {
  if(funz() == 2) {
    set = HIGH;
  }
  else{
    set == LOW;
  }
   irrecv.resume();
    }
stat_succ = random(0,5);
  if(stat_succ != stat_prec){
 for(int i =0;i<3;i++){
 analogWrite(pins[i],rbg_matrix[stat_prec][i]);
  if(rbg_matrix[stat_succ][i] < rbg_matrix[stat_prec][i]) fading[i]= -5;
  if(rbg_matrix[stat_succ][i] == rbg_matrix[stat_prec][i]) fading[i]= 0;
  if(rbg_matrix[stat_succ][i] >rbg_matrix[stat_prec][i]) fading[i]= 5;
      }
int o =0;      
 while(o<52){
   if (irrecv.decode(&results)) {
  if(funz() == 2) {
    set = HIGH;
  }
  else{
    set == LOW;
  }
   irrecv.resume();
    }
   for(int i = 0; i<3; i++){
     analogWrite(pins[i],(rbg_matrix[stat_prec][i]+fading[i]*o));
       }
     delay(200);
    o+=5;
     }
     stat_prec = stat_succ;
   } 
  }
  break;
  case 7:
    Serial.println("funzione SMOOTH");
  //funzione SMOOTH
  set = LOW;
  while(set == LOW){
  if (irrecv.decode(&results)) {
  if(funz() == 2) {
    set = HIGH;
  }
  else{
    set == LOW;
  }
   irrecv.resume();
    }
stat_succ = random(0,5);
  if(stat_succ != stat_prec){
 for(int i =0;i<3;i++){
 analogWrite(pins[i],rbg_matrix[stat_prec][i]);
  if(rbg_matrix[stat_succ][i] < rbg_matrix[stat_prec][i]) fading[i]= -1;
  if(rbg_matrix[stat_succ][i] == rbg_matrix[stat_prec][i]) fading[i]= 0;
  if(rbg_matrix[stat_succ][i] >rbg_matrix[stat_prec][i]) fading[i]= 1;
 }

    int o=0;
 while(set == LOW && o<256){
 if (irrecv.decode(&results)) {
  if(funz() == 2) {
    set = HIGH;
  }
  else{
    set == LOW;
  }
   irrecv.resume();
    }
    for(int i = 0; i<3; i++){
     analogWrite(pins[i],(rbg_matrix[stat_prec][i]+fading[i]*o));
       }
     delay(50);
     o++;
     }
     stat_prec = stat_succ;
   } 
  }
  break;
 default:
   Serial.println("funzione COLOUR PURO");
    for(int a=0;a<16;a++){
       if(decodifica() == col[a]){
       for(int i =0;i<3;i++){
         int colore = scala_c[i*16+a];
          analogWrite(pins[i],colore);
        }
       }
      }
      irrecv.resume();
    }
  }
}
//Funzione generatrice di un numero casuale da 0 a 47
int rnd(){
 int rand = random(0,47);
 return rand;
}
//Funzione che spenge tutti i colori
void rbg_clear(){
  for(int i = 0; i<3;i++){
    analogWrite(pins[i],0);
  }
}
// Funzione che assegna ad ogni tasto funzione un numero da 0 a 7
// per entrare nei vari case ed 8 per entrare nel default
int funz(){
   if (irrecv.decode(&results)) {
   word tmp = 0x0000;
   tmp = decodifica();
   int w =0;
   while(funzione[w] != tmp) {
     if(millis() - tempo_delay > debounce){ // da un piccolo delay per evitare segnali indesiderati
      tempo_delay = millis();
       if(w<8) w++;
       else return 8;
     }
   }return w;
    irrecv.resume();
       }
       
      }

In pratica durante il fading io ho 6 possibili stati (non ho considerato tutto acceso o tutto spento perchè esteticamente sono brutti :D).
Questi sei stati li ho messi in una matrice
int rbg_matrix[6][3] =
{
{255, 0, 0 },
{ 0, 255, 0 },
{ 0, 0, 255},
{ 0, 255,255},
{255, 0, 255},
{255,255, 0 },
};
in pratica io parto da uno stato che è lo 0 sempre, (ma volendo potrei partire da uno stato random :D), se lo stato precedente è diverso dal successivo “fado” incrementando o diminuendo la luminosità a seconda dei valori nella matrice. Gli stati sono le righe della matrice.

In questo modo dovrei poter generare casualmente tutti i colori possibili (eccetto bianco e nero) con un led rbg!
Naturalmente dentro alla lampada c’è un arduino in modalità standalone! ;D yeah!

molto carina ti posso chiedere dove hai preso la sfera? di che materiale si tratta. l'alimentazione la prendi dalla presa?

Avevo una palla da 12 cm che mi aveva procurato un amico del forum, mi si è rotta e ho ricomprato questa all Obi di Montevarchi :D La scheda è alimentata da un LM7805, quindi puoi alimentare la scheda con tensioni maggiori di 5v e minori di 40 :D io uso un alimentatore da 12V, 1A ma l'integrato scalda parecchio quindi ti consiglierei un 9v 500mA :D in generale il led dovrebbe ciucciare 1w e il micro qualche milliwatt quindi anche in questo caso sarebbe tutto sovradimensionato.

Pur avendo già una lampada RGB comprata, è una delle cose che avrei voluto fare con Arduino.. Che led RGB hai usato?

prolight da 1w :smiley: li trovi su ebay!
io ho comprato una lampada rbg per il telecomando, poi l’ho smontata per vedere com’era dentro e l’ho buttata via, tanto era un troiaio assurdo fatto dai peggiori cinesi in circolazione :smiley: però il telecomando spacca!

Beh però a volte le cinesate sono utili per riutilizzare dei componenti/circuiti a poco prezzo ;D

questo è lo schemettino che feci tempo fa! cliccate per ingrandire!

eeee grazzieeee! Anche io ho un led rgb da 2 mesi e volevo fare una lampada semplice!!

Ci saranno delle foto delal circuiteria?

Per la sfera io ho una dritta.

Esistono delle lampade a "basso consumo" che sono acquistabili a forma di sfera. Ecco, la sfera e' applicata avvitata sopra una lampadina a "basso consumo" , che si presenta come quelle normali lunghe a tubi. Basta prendere la lampadina originale, svitare la sfera per avere una lampadina e una sfera separate. La sfera e' ottima perche' di solito e' satinata e diffonde bene i led in genere.

Fede

Molto carina Calamaro. Ciao

ma secondo voi vengono tutte le possibili combinazioni di colori oppure no?

non ho capito calamaro? non hai provato con altri valori oltre il 255? mentre fadi passi attraverso molti colori (aumenti con passo 17) la scala di rgb è composta da tre componenti modificabili in 256 valori per componente. quindi puoi fare 16,7 milioni di colori. come fadi ora puo' essere un modo, ma puoi fadare in vari modi. abbassando la luminosità e fadare un nuovo colore, oppure andando in bianco (255,255,255) e poi passi a un altro. prova a fare delle prove come ti piace di più.

Io quando ho fatto qualche prova coi led RGB alla fine mi sono accorto che basta miscelarne 2 alla volta per ottenere una lampada semplice e sufficientemente colorata. (Nel mio blog ho messo il codice che avevo scritto.)

Una curiosità.. Forse un pò OT.. Nella mia lampada RGB tipo quella della Philips, non c'è un led RGB ma 4 led separati, di cui 2 rossi.. C'è una ragione per cui debbano essercene 2 rossi?

i 2 rossi mi sa che sono per bilanciare i colori mi sa…
uhm per tornare alle funzioni che ho scritto in pratica dovrebbero fare sta cosa
In Fade io ho scazzato :smiley: volevo fare dei passi di 5 invece faccio dei passi da 25 :frowning:
Mentre in smooth dovrebbe funzionare tutto a modino!

    Serial.println("funzione SMOOTH");
  //funzione SMOOTH
  set = LOW;
  while(set == LOW){
  if (irrecv.decode(&results)) {
  if(funz() == 2) {
    set = HIGH;
  }
  else{
    set == LOW;
  }
   irrecv.resume();
    }
stat_succ = random(0,5);

In pratica qui imposto una variabile di Set per entrare e uscire dal while e controllo che non mi arrivi un off, poi do allo stato successivo un numero random da 0 a 5

  if(stat_succ != stat_prec){
 for(int i =0;i<3;i++){
 analogWrite(pins[i],rbg_matrix[stat_prec][i]);
  if(rbg_matrix[stat_succ][i] < rbg_matrix[stat_prec][i]) fading[i]= -1;
  if(rbg_matrix[stat_succ][i] == rbg_matrix[stat_prec][i]) fading[i]= 0;
  if(rbg_matrix[stat_succ][i] >rbg_matrix[stat_prec][i]) fading[i]= 1;
 }

Qui controllo se lo stato generato è uguale a quello precedente e nel caso fossero diversi scrivo il precedente sul led, poi controllo la direzione del fade. Ovvero spento → acceso oppure acceso → spento oppure fermo

    int o=0;
 while(set == LOW && o<256){
 if (irrecv.decode(&results)) {
  if(funz() == 2) {
    set = HIGH;
  }
  else{
    set == LOW;
  }
   irrecv.resume();
    }
    for(int i = 0; i<3; i++){
     analogWrite(pins[i],(rbg_matrix[stat_prec][i]+fading[i]*o));
       }
     delay(50);
     o++;
     }
     stat_prec = stat_succ;
   } 
  }

qui entro in un while solo se Set è low e o<256. Quindi ricontrollo se viene premuto OFF poi scrivo sul led il valore del fading moltiplicato per o sommato al valore dello stato precedente.
In pratica faccio quello che ho disegnato nel primo post con gimp.
Non vado da 0 a 255 di botto, ci vado fadedando :smiley: non so se mi sono spiegato.
Quando ho scritto questo codice mi sono scervellato non poco, magari era una cosa semplicissima da fare. Comunque quando l’ho vista funzionare mi sono gasato un monte!

Valgono tutti i colori chiari, il marrone non lo puoi fare...

uhm capito, anche se il marrone non mi piace :D ma scusa eh il marrone non si fa con arancio e viola o blu e arancio tipo? non avendoci il giallo comunque il marrone non lo potrei fare o sbaglio?

Ma teoricamente con i 3 colori RGB non si possono fare TUTTI i colori? ::)

no, il giallo il rosso e il blu sono fondamentali se non ricordo male... ora mi fa fatica andare a cercare :D

ah ragazzi quello schema è sbagliato :D se ho tempo posto quello corretto :D