Go Down

Topic: centralina led acquario (Read 1 time) previous topic - next topic

giak

Mar 29, 2013, 08:49 pm Last Edit: Mar 29, 2013, 11:52 pm by leo72 Reason: 1
costruire centralina rgb

costruire centralina rgb

CIAO a tutti, sono nuovo e pochissimo pratico di elettronica, vorrei realizzare per il mio acquario una Centralina per fare alba/giorno/tramonto/notte con strisce Led RGB, tutto in due canali, 1 canale per led rgb 5050 5 metri 75 w (ma a me servono tre metri) e 1 canale striscia da 25 cm. led blu notturna. che permette di simulare in maniera dinamica sia i colori che le variazioni graduali dell'illuminazione
evitando lo stress di una luce improvvisa nell'acquario e donare un effetto
cromatico naturale all'intera vasca, di solito in un acquario mediamente
illuminato è sufficiente 1cm di striscia RGB ogni litro d'acqua.
Quindi
1 canale per tre metri di strisce rgb
1 canale per notturno
Io ho già fatto una centralina, mi ha aiutato gentilmente con molta pazienza daniele in un sito, ma ha solo 1 canale rgb quando faccio il notturno si accendono tre metri e sono troppi e lui8 non sapeva mettere il display che vorrei visualizzare, con lui non riesco ad avere più un contatto. Per questo mi serve n nuovo circuito.

Ho a disposizione Arduino duemilanove e un display. (link del display)
http://ecommerce.euroa.it/it/optoelettronica-led-e-display/331-lcd-shield-for-arduino-16x2-blue-led-backlight.html
acido, saldatore basetta, software arduino, alimentatore 8A e il codice che mi ha fatto , mi serve un circuito stampato, componenti da saldare e rettificare il programma per mettere il display.
Vi allego il sito di quello che ho fatto.     http://www.grix.it/forum/forum_thread.php?ftpage=1&id_forum=1&id_thread=328985&tbackto=
Qui è l'esempio


Esempio:

Le tre strisce insieme si accendono ( poi vediamo meglio gli orari) fanno alba/giorno/tramonto poi si dissolve e in sequenza parte la blu fino al giorno dopo che si dissolve, poi contemporaneamente si spegne e parte l'alba.

luna crescente ----> blu ----------------> in 20min --|
alba ----------------> celeste ------------> in 25min | 1:15h
\\\mattina ----------> bianco ------------> in 30min --|
\\\giorno -----------> bianco 100% ----> in 7h
\\\tramonto --------> bianco ------------> in 30min --|
crepuscolo---------> rosso --------------> in 15min |1:15h
sera -----------------> magenta ----------> in 10min |
luna calante--------> blu ----------------> in 20min --|b

la funzione del display a 5 pulsanti e vorrei:

Attenzione non sono necessari alimentatori dimmerabili.


Il pulsante ha più funzioni:
1) Scambia da automatico a manuale e viceversa
2) Blocca la luminosità scelta una volta terminato il ciclo automatico
3) Interrompe il ciclo automatico permettendo il controllo manuale rapido
(serve per lavorare a piena luminosità in caso di necessità immediata in pieno
ciclo automatico mentre alla pressione successiva riprende dal punto in cui è
stato interrotto.
vorrei sare i pulsanti del dislay.

La manopola permette la regolazione manuale della luminosità (RGB in
simultanea = BIANCA).
P.S. ricordate che mi dovete dire passo passo come i bambini.


Code: [Select]
// CENTRALINA RGB PER ACQUARIO
//    DATA:   12/12/23
//    AUTORE: Daniele Lombardi
//
// Collegando l'alimentazione l'orario viene impostato alle ore 00:00 e passa alla modalità automatico.
//
// Quando è spento:
// una pressione rapida accende le luci e passa alla modalità automatico.
//
// In modalità automatico:
// una pressione rapida passa alla modalità sempre acceso;
// una pressione di 3 secondi passa alla modalità programmazione;
// una pressione di 8 secondi spegne le luci.
//
// In modalità sempre acceso:
// una pressione rapida passa alla modalità automatico.
//
// In modalità programmazione:
// una pressione breve fa avanzare l'orario di 30 minuti;
// una pressione di 2 secondi fa retrocedere l'orario di 1 ora;
// una pressione di 5 secondi passa alla modalità automatico.

#define ROSSO  3
#define VERDE  5
#define BLU    6
#define POT    0
#define BUTTON 2

#define BREVE 80

#define SPENTO         0
#define AUTOMATICO     1
#define SEMPRE_ACCESO  2
#define PROGRAMMAZIONE 3

#define T_TIME unsigned long
#define MINUTE 60000
#define DAY    86400000

#define N_TRX  8
//                 trx   bian  trx   gior  trx   bian  trx   nott
word ttime[] = { 800,  900, 1330, 1400, 1800, 1830, 2100, 2200};
byte rlum[]  = {   9,  255,  255,  249,  249,  255,  255,    9};
byte glum[]  = {  12,  140,  140,  251,  251,  140,  140,   12};
byte blum[]  = {  75,   39,   39,  255,  255,   39,   39,   75};
//              nott  bian  bian  gior  gior  bian  bian  nott

byte mode = AUTOMATICO;
word lum  = 0;

T_TIME lTime = 0;
T_TIME dTime = 0;

void aggiornaOrario() {
 T_TIME cTime = millis();
 T_TIME elapsed;
 if (cTime > lTime) {              //Verifica se c'è stato overflow
   elapsed = cTime - lTime;                     //No overflow, il tempo trasccorso è uguale alla differenza
 } else {
   elapsed = (4294967295 - lTime) + 1 + cTime;  //Overflow, aggiunge il conteggio perso
 }
 dTime = (dTime + elapsed) % DAY;  //Ricalcola l'orario giornaliero
 lTime = cTime;                    //Salva l'ultimo tempo di aggiornamento
}

byte interpola(T_TIME t1, byte v1, T_TIME t2, byte v2, T_TIME tx) {
 double r = ((double)v1) + (((double)v2) - ((double)v1)) * (((double)tx) - ((double)t1)) / (((double)t2) - ((double)t1));
 if (r < 0) return 0;
 if (r > 255) return 255;
 return (byte) r;
}

T_TIME wct2time(word wct) { //Converte un "word coded time" in millisecondi
 return MINUTE * ((wct / 100) * 60 + wct % 100);
}

byte cercaFase(T_TIME t) {  //Restituisce l'indice di inizio transiszione
 byte i;
 if (t < wct2time(ttime[0])) return N_TRX - 1;
 for (i = 1; i < N_TRX; i++) {
   if (t < wct2time(ttime[i])) return i - 1;
 }
 return N_TRX - 1;
}

void refresh() {
 aggiornaOrario();
 lum = analogRead(POT) >> 2;  //Scala il range a 0-255
 byte i1 = cercaFase(dTime);  //Calcola l'indice di inizio transizione
 byte i2 = (i1 + 1) % N_TRX;  //Calcola l'indice di fine transizione
 T_TIME t1 = wct2time(ttime[i1]);
 T_TIME t2 = wct2time(ttime[i2]);
 analogWrite(ROSSO, (lum * interpola(t1, rlum[i1], t2, rlum[i2], dTime)) >> 8);
 analogWrite(VERDE, (lum * interpola(t1, glum[i1], t2, glum[i2], dTime)) >> 8);
 analogWrite(BLU  , (lum * interpola(t1, blum[i1], t2, blum[i2], dTime)) >> 8);
}

unsigned int readButton(int btn) {
 T_TIME s = millis();
 while (digitalRead(btn)) {}
 return (unsigned int) (millis() - s);
}

void setup() {
 pinMode(ROSSO, OUTPUT);
 pinMode(VERDE, OUTPUT);
 pinMode(BLU  , OUTPUT);
 pinMode(BUTTON, INPUT);
}

void loop() {
 unsigned int pressione = readButton(BUTTON);
 switch (mode) {
   case SPENTO:
     analogWrite(ROSSO, 0);
     analogWrite(VERDE, 0);
     analogWrite(BLU  , 0);
     if (pressione > BREVE) mode = AUTOMATICO;
     break;
   case AUTOMATICO:
     refresh();
     if        (pressione > 6000) {    //8 secondi
       mode = SPENTO;
     } else if (pressione > 1500) {    //3 secondi
       mode = PROGRAMMAZIONE;
     } else if (pressione > BREVE) {
       mode = SEMPRE_ACCESO;
     }
     break;
   case SEMPRE_ACCESO:
     lum = analogRead(POT) >> 2;  //Scala il range a 0-255
     analogWrite(ROSSO, lum);
     analogWrite(VERDE, lum);
     analogWrite(BLU  , lum);
     if (pressione > BREVE) mode = AUTOMATICO;
     break;
   case PROGRAMMAZIONE:
     refresh();
     if        (pressione > 3000) {    //5 secondi
       mode = AUTOMATICO;
     } else if (pressione > 900) {     //2 secondi
       dTime = dTime - 60 * MINUTE;
       if (dTime > DAY) dTime = DAY - 60 * MINUTE;  //Previeni overflow
     } else if (pressione > BREVE) {
       dTime = (dTime + 30 * MINUTE) % DAY;
     }
     break;
 }
}


edit: per favore includi il codice usando gli appositi tag

Go Up