Benvenuti sul Forum di AcquaPortal, la più grande community italiana di acquariofilia!
Sul Forum di AcquaPortal puoi discutere con altri appassionati di acquariofilia, tenere un tuo Blog personale, inserire foto e video, chattare, ed aiutarci a creare un grande database con schede di pesci, invertebrati e prodotti di acquariofilia.
Per entrar a far parte della comunità occorre registrarsi.
Per farlo premi su
Al momento della registrazione ti verrà richiesto di accettare il Regolamento che ti consigliamo di leggere attentamente.
Ti consigliamo inoltre di leggere le FAQ per apprendere le funzionalità principali del forum.
Se invece sei un utente registrato e hai dimenticato i tuoi dati di accesso devi effettuare il Recupero dati.
Fai da te marinoPer parlare delle tecniche di costruzione artigianale, per presentare le vostre realizzazioni, e per avere informazioni su dove reperire materiale ed attrezzatura risparmiando tempo e denaro.
Ciao,
i due driver vanno entrambi bene, ma devi fare attenzione a quale corrente ti serve in uscita, secondo le specifiche dei tuoi led.
I meanwell escono a 1000 mA mentre gli altri a 700 mA.
Di cosa hanno bisogno i tuoi led?
Come alimentatore dipende dal wattaggio ma potresti usare una cosa del genere:
Ho fatto un piccolo schema del collegamento dei componenti
Ho trovato il codice che forse andrebbe bn ora te lo posto
Praticamente lo gia tradotto e non da errori quando clicco su test
Non lo ancora testato xk mi deve arrivare l arduino cmq il codice e stato fatto x i Mean
Quindi dovrei modificarlo.
Il controller dovrebbe effettuare alba e tramonto su due canali da sei led per canale bianco e blu.
Non è che ci daresti un occhio ciao
codice:
/*
originally written by Christian, cptbjorn@gmail.com
modified by Cesar, caddnima@gmail.com,
https://sites.google.com/site/caddnima/
Version 1.00, 2012-03-13
*/
#define DS1307_I2C_ADDRESS 0x68 // indirizzo utilizzato per l'orologio
#include "Wire.h" // libreria utilizzata
#include <LiquidCrystal.h> // libreria utilizzata
/* ******************************************************************************************************************** */
/* * * */
/* * Note: tempo per la rampa di discesa è lo stesso tempo per la rampa di salita. * */
/* * * */
/* ******************************************************************************************************************** */
const int relayPin1 = 2; // Pin arduino (non PWM) utilizzato per il relè 1
const int relayPin2 = 8; // Pin arduino (non PWM) utilizzato per il relè 2
int relayState1 = LOW;
int relayState2 = LOW;
long previousMillis1 = 0;
long previousMillis2 = 0;
long interval1 = 30000; // Quanti millisecondi per accendere e spegnere per RELAY1
long interval2 = 50000; // Quanti millisecondi per accendere e spegnere per RELE'2
/* ******************************************************************************************************************** */
/* * * */
/* * Note: tempo per la rampa di discesa è lo stesso tempo per la rampa di salita. * */
/* * * */
/* ******************************************************************************************************************** */
/* ********************************************************************************* */
/* * * */
/* * Note: time for ramp down is the same as time for ramp up. * */
/* * * */
/* ********************************************************************************* */
int ontime = 10 ; // Che ora si desidera che il blu per iniziare a decollare??
int blueramptime = 60 ; // Quanti minuti vuoi l'azzurro a far decollare?
int whiteramptime = 180 ; // Dopo l'azzurro, quanti minuti vuoi che il bianco di rampa di salita?
int photoperiod = 240 ; // Dopo il bianco, quanti minuti vuoi che rimanga a intensità max?
int blue = 3; // Che Arduino pin PWM si sta utilizzando per l'azzurro?
int white = 11; // Che Arduino pin PWM che si sta utilizzando per il bianco?
int bluemin = 0 ;
int whitemin = 0 ;
int bluepercent[11] = { 0, 1, 2, 5, 8 ,12, 18, 27, 44, 80, 255 };
int whitepercent[11] = { 0, 1, 2, 5, 8 ,12, 18, 27, 44, 80, 255 };
/* ********************************************************************************* */
/* * * */
/* * the line below is needed if you are using meanwell ELN60-48P, for pwm * */
/* * these are the values in 10% increments * */
/* * [11] is not the arduino pin but the number of steps used from 0 to 255 * */
/* * just remove // sign below for the blue and white * */
/* * and add // sign above for the blue and white * */
/* * * */
/* ********************************************************************************* */
//int bluepercent[11] = { 0, 26, 52, 78, 103, 128, 154, 180, 205, 230, 255 };
//int whitepercent[11] = { 0, 26, 52, 78, 103, 128, 154, 180, 205, 230, 255 };
// int pwm_one = 10; // Extra pin PWM per un uso futuro (ricambio)
// int pwm_one = 9; // Extra pin PWM per un uso futuro (ricambio)
/* ********************************************************************************* */
/* * * */
/* * Spilli originariamente Arduino 8, 9, 4, 5, 6, 7 sono utilizzati, * */
/* * Devo usare diversi pin Arduino non PWM, così posso riservato il PWM * */
/* * Spilli per altro uso * */
/* * * */
/* ********************************************************************************* */
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
/* ******************************************************************************************************************** */
/* * * */
/* * R T C C L O C K D S 1 3 0 7 * */
/* * * */
/* ******************************************************************************************************************** */
byte decToBcd(byte val) // Convertire numeri decimali normali decimale codificato in binario
{
return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val) // convertire in codice binario decimale a normali numeri decimali
{
return ( (val/16*10) + (val%16) );
}
// 1) Imposta la data e l'ora del DS1307
// 2) Avvia l'orologio
// 3) Imposta la modalità di un'ora all'orologio 24 ore
// Presuppone che si sta passando in numeri validi
void setDateDs1307(byte second, // 0-59
byte minute, // 0-59
byte hour, // 1-23
byte dayOfWeek, // 1-7
byte dayOfMonth, // 1-28/29/30/31
byte month, // 1-12
byte year) // 0-99
{
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.send(0);
Wire.send(decToBcd(second)); // 0 al bit 7 inizia l'orologio
Wire.send(decToBcd(minute));
Wire.send(decToBcd(hour)); // Se si vuole 12 ore am / pm è necessario impostare
// Bit 6 (necessario anche per cambiare readDateDs1307
Wire.send(decToBcd(dayOfWeek));
Wire.send(decToBcd(dayOfMonth));
Wire.send(decToBcd(month));
Wire.send(decToBcd(year));
Wire.endTransmission();
}
// Ottiene la data e l'ora dal DS1307
void getDateDs1307(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
// Resettare il puntatore registro
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.send(0);
Wire.endTransmission();
Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
// Alcuni di questi hanno bisogno di maschere perché alcuni bit sono bit di controllo
*second = bcdToDec(Wire.receive() & 0x7f);
*minute = bcdToDec(Wire.receive());
*hour = bcdToDec(Wire.receive() & 0x3f); // Necessità di cambiare questo caso 12 ore am / pm
*dayOfWeek = bcdToDec(Wire.receive());
*dayOfMonth = bcdToDec(Wire.receive());
*month = bcdToDec(Wire.receive());
*year = bcdToDec(Wire.receive());
}
/* ******************************************************************************************************************** */
/* * * */
/* * D E F I N E : O N E S E C O N D * */
/* * * */
/* ******************************************************************************************************************** */
void onesecond() //funzione che viene eseguita una volta al secondo, mentre il programma è in esecuzione
{
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
lcd.setCursor(0, 0);
if(hour>0)
{
if(hour<=12)
{
lcd.print(hour, DEC);
}
else
{
lcd.print(hour-12, DEC);
}
}
else
{
lcd.print("12");
}
lcd.print(":");
if (minute < 10) {
lcd.print("0");
}
lcd.print(minute, DEC);
lcd.print(":");
if (second < 10) {
lcd.print("0");
}
lcd.print(second, DEC);
if(hour<12)
{
lcd.print("am");
}
else
{
lcd.print("pm");
}
lcd.print(" ");
delay(1000);
}
/* ******************************************************************************************************************** */
/* * * */
/* * D E F I N E : R E L A Y 1 * */
/* * * */
/* ******************************************************************************************************************** */
void relay1() //funzione per accendere e spegnere RELAY 1.
{
unsigned long currentMillis = millis();
if(currentMillis - previousMillis1 > interval1)
{
previousMillis1 = currentMillis;
if (relayState1 == LOW)
relayState1 = HIGH;
else
relayState1 = LOW;
digitalWrite(relayPin1, relayState1);
}
}
/* ******************************************************************************************************************** */
/* * * */
/* * D E F I N E : R E L A Y 2 * */
/* * * */
/* ******************************************************************************************************************** */
void relay2()
{
unsigned long currentMillis2 = millis();
if(currentMillis2 - previousMillis2 > interval2)
{
previousMillis2 = currentMillis2;
if (relayState2 == LOW)
relayState2 = HIGH;
else
relayState2 = LOW;
digitalWrite(relayPin2, relayState2);
}
}
/* ******************************************************************************************************************** */
/* * * */
/* * S E T U P * */
/* * * */
/* ******************************************************************************************************************** */
void setup() {
pinMode(relayPin1, OUTPUT); // Imposta il pin digitale come output:
pinMode(relayPin2, OUTPUT); // Imposta il pin digitale come output:
/* ******************************************************************************************************************** */
/* * * */
/* * S E T U P - D I S P L A Y * */
/* * * */
/* ******************************************************************************************************************** */
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
Wire.begin();
second = 56;
minute = 57;
hour = 23;
dayOfWeek = 6; // Sunday is 0
dayOfMonth = 26;
month = 2;
year = 11;
/* ********************************************************************************* */
/* * * */
/* * Questo è dove si imposta il tempo... * */
/* * 1) modificare il secondo, minuto, ora, etc sopra * */
/* * 2) rimuovere // sotto * */
/* * 3) e caricare questo schizzo per il tuo arduino * */
/* * 4) dopo aver caricato lo schizzo, mettere il//nuovo * */
/* * 5) e caricare questo schizzo di nuovo al tuo arduino e salvare * */
/* * * */
/* ********************************************************************************* */
//setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
analogWrite(blue, bluemin);
analogWrite(white, whitemin);
lcd.begin(16, 2); // Impostare il numero del display LCD di righe e colonne:
// lcd.print("12:00 80.6"); // Stampa un messaggio sul display LCD.
// lcd.print(char(223));
lcd.setCursor(0, 1);
lcd.print("blue:");
lcd.print(33*bluemin/85);
lcd.setCursor(8, 1);
lcd.print("white:");
lcd.print(33*whitemin/85);
}
/* ******************************************************************************************************************** */
/* * * */
/* * LOOP * */
/* * * */
/* ******************************************************************************************************************** */
void loop()
{
onesecond();
relay2();
relay1();
/* ******************************************************************************************************************** */
/* * * */
/* * L O O P - D I MINUZIONE F U N ZIONI * */
/* * * */
/* ******************************************************************************************************************** */
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
int daybyminute = ((hour * 60) + minute); //Converte ora del giorno per un singolo valore in minuti
int bluerampup;
if (daybyminute >= (ontime*60))
bluerampup = (((ontime*60) + blueramptime) - daybyminute);
else
bluerampup = blueramptime;
int whiterampup;
if (daybyminute >= (ontime*60 + blueramptime))
whiterampup = (((ontime*60) + blueramptime + whiteramptime) - daybyminute);
else
whiterampup = whiteramptime;
int whiterampdown;
if (((ontime * 60) + photoperiod + blueramptime + whiteramptime) <= daybyminute)
whiterampdown = (((ontime*60) + photoperiod + blueramptime + 2*whiteramptime) - daybyminute);
else
whiterampdown = whiteramptime;
int bluerampdown;
if (((ontime * 60) + photoperiod + blueramptime + 2*whiteramptime) <= daybyminute)
bluerampdown = (((ontime*60) + photoperiod + 2*blueramptime + 2*whiteramptime) - daybyminute);
else
bluerampdown = blueramptime;
/* ******************************************************************************************************************** */
/* * * */
/* * L O O P - F A D E I N * */
/* * * */
/* ******************************************************************************************************************** */
if (daybyminute >= (ontime*60))
{
if (daybyminute <= ((ontime*60) + blueramptime + (whiteramptime))) // se il tempo è nella gamma di fade in, inizia la dissolvenza in + (whiteramptime/10 * 9))
{
// Dissolvenza LED blu in dal minimo al massimo.
for (int i = 1; i <= 10; i++) // impostazione del valore ib per il 10% di incremento. Inizia con 0%
{
analogWrite(blue, bluepercent[i]);
lcd.setCursor(5, 1);
lcd.print(i);
lcd.print(" ");
int countdown = ((bluerampup*60)/10); // Calcola secondi per passo successivo
while (countdown>0)
{
onesecond(); // aggiornamenti una volta al secondo
countdown--;
relay2();
relay1();
}
}
// Dissolvenza LED bianchi in dal minimo al massimo.
for (int i = 1; i <= 10; i++) // impostazione del valore ib per il 10% di incremento. Inizia con 0%
{
analogWrite(white, whitepercent[i]);
lcd.setCursor(14, 1);
lcd.print(i);
lcd.print(" ");
int countdown = ((whiterampup*60)/10); // cCalcola secondi per passo successivo
while (countdown>0)
{
onesecond(); // aggiornamenti una volta al secondo
countdown--;
relay2();
relay1();
}
}
}
}
/* ******************************************************************************************************************** */
/* * * */
/* * L O O P - M A X V A L U E * */
/* * * */
/* ******************************************************************************************************************** */
if (daybyminute >= ((ontime * 60) + blueramptime + whiteramptime))
{
if ( daybyminute < ((ontime * 60) + blueramptime + whiteramptime + photoperiod)) // se il tempo è nella gamma di fotoperiodo, accendere le luci al valore massimo dissolvenza
{
analogWrite(blue, 255);
lcd.setCursor(5, 1);
lcd.print(10);
lcd.print(" ");
analogWrite(white, 255);
lcd.setCursor(14, 1);
lcd.print(10);
lcd.print(" ");
}
}
/* ******************************************************************************************************************** */
/* * * */
/* * L O O P - F A D E O U T * */
/* * * */
/* ******************************************************************************************************************** */
if (((ontime * 60) + photoperiod + blueramptime + whiteramptime) <= daybyminute)
{
if (((ontime * 60) + photoperiod + 2*whiteramptime + 2*blueramptime) >= daybyminute)
{
// Dissolvenza LED bianchi fuori da max a min in incrementi di 1 punto:
for (int i = 10; i >= 0; i--) // impostare i valore per il 10% di incremento. Inizia con il 10%
{
analogWrite(blue, 255);
lcd.setCursor(5, 1);
lcd.print(10);
lcd.print(" ");
analogWrite(white, whitepercent[i]);
lcd.setCursor(14, 1);
lcd.print(i);
lcd.print(" ");
int countdown = ((whiterampdown*60)/10); // Calcola secondi per passo successivo
while (countdown>0)
{
onesecond(); // aggiornamenti una volta al secondo
countdown--;
relay2();
relay1();
}
}
// fade blue LEDs out from max to min in increments of 1 point:
for (int i = 10; i >= 0; i--) // impostare i valore per il 10% di incremento. Inizia con il 10%
{
analogWrite(blue, bluepercent[i]);
lcd.setCursor(5, 1);
lcd.print(i);
lcd.print(" ");
int countdown = ((bluerampdown*60)/10); // Calcola secondi per passo successivo
while (countdown>0)
{
onesecond(); // aggiornamenti una volta al secondo
countdown--;
relay2();
relay1();
}
}
}
}
} // END LOOP
Ultima modifica di GenjoSanzo; 28-07-2014 alle ore 10:26.
Per quello che hai preso, quanto è il voltaggio in output? Quanti volts si ciuccia il driver (generalmente attorno ai 3V)? I power led da 3w generalmente usano 3.2-3.6V l'uno. Se alimenti a 24V, se il driver ne usa effettivamente 3, te ne rimangono 21. 21/3.6 = 5.8 led quindi meno dei 6 led che vorresti mettere secondo il tuo disegnino. Questo nella peggiore delle ipotesi ovviamente, ma 10 led te li scordi in ogni caso.
E prima che mi dici "ok allora cambio alimentatore", non prenderne uno da 35V altrimenti è probabile che fai lavorare troppo il driver e lo bruci.
Meanwell tutta la vita :D
ora il problema più grande è il codice xk potrei fare poi 3 canali da 5 led e prendere un altro driver
poi l'alimentatore lo puoi portare a 25,5 per cui basta sul sito del arduino mi hanno detto che andava bn
cmq l'uscita del driver è 2/3
Io ti riporto solamente quanto mi è stato detto da un mio amico ingegnere elettronico che avevo contattato quando volevo farmi un circuito simile al tuo. Poi quindi ho optato per i meanwell.
Il codice credo (non me ne intendo di programmazione) tu debba adattarlo al circuito, quindi devi prima definire questo.
0-48
Modalità lineare
