Salut,
J'ai en projet de faire un variateur de tube Fluo.
C'est quelque chose de très peu répandu.
Je l'ai déjà vu dans des salles d'opérations.
Je l'utilise sur du matériel de terrarium.
Je dirai que peu de personnes savent que cela est possible.
Néanmoins, je souhaiterai créer un projet piloté par un arduino me permettant de gérer une période d'allumage progressif, une période d'allumage pleine, une période d'allumage dégressif.
J'ai aussi besoin de connaître la partie électronique.
que cherche tu a faire le systeme du balaste dimable ou le systeme de gestion du ballaste?
car ballaste dimmable effectivement on en trouve pas mal .
le systeme de gestion quand a lui peut piloter les balaste en fonction des type de protocole du systeme dimable
0-10V
DALI
KNX
bref c'est sur ça qu'il faut travailler!
emple d'un systeme dimable via commande 0-10V (ce sont des ballaste qui ne s'eteignent pas totalement a 0V)
Yep!
Les lampes à économie d'énergie intègre un ballast électronique miniature. Ce peut-être un point de départ intéressant si le budget est serré. Il faut simplement respecter la puissance et le type de ballast, T5 ou T8.
Il existe déjà quelques pistes sur internet avec les mots clés 'arduino, dimmable, ballast'
Projet sympa 
@+
Zoroastre.
Salut,
Pour te donner une idée voilà ce que j'ai pondu.
Je suis loin d'être chevronné, alors fait tes premiers essais.
Valeurs a paramétrées:
- heure de depart en secondes (curHMSec = clk.hour() * 3600L + clk.minute() * 60L + clk.second()
- Temps de fonctionnement.
- Temps de gradation. (au demarrage et avant arret)
- puissance maxi de chaque lampe
- puissance mini de chaque lampe (pour gérer l'offset du démarrage du ballast 1-10v)
Note: le ballast se coupe lorsque l'on passe en dessous de puissance mini.
Pour ma part j'ai acheté a Londres des ballasts 1-10v de 2x80W a 16 € pièces frais de port inclus. (ebay)
void lighting()
{
/********************************/
/********* ECLAIRAGE 1 **********/
/********************************/
// On recupere le bon temps de gradation de l'eclairage
long light1getDimmingTime = getDimmingTime( EEPROM.readInt(EElightOperatingTime1)*60L, EEPROM.readInt(EElightDimmingTime1)*60L );
/****** MODE AUTMATIQUE ******/
if ( EEPROM.readBit(EEautoManuLight1,0) == 1 )
light1Pwm = lightSetPwmAuto( 1, EEPROM.readInt(EElightStartTime1)*60L, light1getDimmingTime, EEPROM.readInt(EElightOperatingTime1)*60L, EEPROM.readByte(EElight1PwmOffset), EEPROM.readByte(EElightPwmMax1));
/******** MODE MANUEL ********/
if ( EEPROM.readBit(EEautoManuLight1,0) == 0 )
light1Pwm = lightSetPwmManu( 1, EEPROM.readByte(EElight1PwmOffset), EEPROM.readByte(EElightPwmMax1), EEPROM.readBit(EEmanuelLightOnOff1,0));
/********************************/
/********* ECLAIRAGE 2 **********/
/********************************/
// On recupere le bon temps de gradation de l'eclairage
long light2getDimmingTime = getDimmingTime( EEPROM.readInt(EElightOperatingTime2)*60L, EEPROM.readInt(EElightDimmingTime2)*60L );
/****** MODE AUTMATIQUE ******/
if ( EEPROM.readBit(EEautoManuLight2,1) == 1 )
light2Pwm = lightSetPwmAuto( 2, EEPROM.readInt(EElightStartTime2)*60L, light2getDimmingTime, EEPROM.readInt(EElightOperatingTime2)*60L, EEPROM.readByte(EElight2PwmOffset), EEPROM.readByte(EElightPwmMax2));
/******** MODE MANUEL ********/
if ( EEPROM.readBit(EEautoManuLight2,1) == 0 )
light2Pwm = lightSetPwmManu( 2, EEPROM.readByte(EElight2PwmOffset), EEPROM.readByte(EElightPwmMax2), EEPROM.readBit(EEmanuelLightOnOff2,1));
/********************************/
/********* ECLAIRAGE 3 **********/
/********************************/
// On recupere le bon temps de gradation de l'eclairage
long light3getDimmingTime = getDimmingTime( EEPROM.readInt(EElightOperatingTime3)*60L, EEPROM.readInt(EElightDimmingTime3)*60L );
/****** MODE AUTMATIQUE ******/
if ( EEPROM.readBit(EEautoManuLight3,2) == 1 )
light3Pwm = lightSetPwmAuto( 3, EEPROM.readInt(EElightStartTime3)*60L, light3getDimmingTime, EEPROM.readInt(EElightOperatingTime3)*60L, EEPROM.readByte(EElight3PwmOffset), EEPROM.readByte(EElightPwmMax3));
/******** MODE MANUEL ********/
if ( EEPROM.readBit(EEautoManuLight3,2) == 0 )
light3Pwm = lightSetPwmManu( 3, EEPROM.readByte(EElight3PwmOffset), EEPROM.readByte(EElightPwmMax3), EEPROM.readBit(EEmanuelLightOnOff3,2));
/********************************/
/********* ECLAIRAGE 4 **********/
/********************************/
// On recupere le bon temps de gradation de l'eclairage
long light4getDimmingTime = getDimmingTime( EEPROM.readInt(EElightOperatingTime4)*60L, EEPROM.readInt(EElightDimmingTime4)*60L );
/****** MODE AUTMATIQUE ******/
if ( EEPROM.readBit(EEautoManuLight4,3) == 1 )
light4Pwm = lightSetPwmAuto( 4, EEPROM.readInt(EElightStartTime4)*60L, light4getDimmingTime, EEPROM.readInt(EElightOperatingTime4)*60L, EEPROM.readByte(EElight4PwmOffset), EEPROM.readByte(EElightPwmMax4));
/******** MODE MANUEL ********/
if ( EEPROM.readBit(EEautoManuLight4,3) == 0 )
light4Pwm = lightSetPwmManu( 4, EEPROM.readByte(EElight4PwmOffset), EEPROM.readByte(EElightPwmMax4), EEPROM.readBit(EEmanuelLightOnOff4,3));
}
// Calcul du temps de gradation
long getDimmingTime(long operatingTime, long dimmingTime)
{
// Si "le temps de progression de l'eclairage" est plus petit que "le temps de fonctionnement"
if ( (dimmingTime * 2 ) <= (operatingTime ) )
// Le temps de progression sera le temps de progression definit
return ( dimmingTime );
else
// Sinon le nouveau temps de progression sera "le temps de fonctionnement / 2"
return ( (operatingTime ) / 2 );
}
// Applique la bonne puissance aux eclairages en mode auto
byte lightSetPwmAuto(byte id, long startTime, long getDimmingTime, long operatingTime, byte pwmMin, byte pwmMax )
{
// Declaration des sorties
int lightPin, ballastPin;
// Pwm de l'eclairage
long lightPwm = 0;
// Heure de la fin de la gradation d'allumage
long endTimeIgnitionDimming = startTime + getDimmingTime;
// Heure de la fin de l'eclairage
long endTime = startTime + operatingTime;
// Heure du debut de la gradation d'extinction
long startTimeExtinctionDimming = endTime - getDimmingTime;
// Periode de gradation d'allumage
if ( (curHMSec >= startTime) && (curHMSec <= endTimeIgnitionDimming) )
lightPwm = map(curHMSec, startTime, endTimeIgnitionDimming, pwmMin, pwmMax);
// Periode de fonctionnement a pwmMax
else if ((curHMSec > endTimeIgnitionDimming) && (curHMSec < startTimeExtinctionDimming))
lightPwm = pwmMax;
// Periode de la gradation d'extinction
else if ((curHMSec >= startTimeExtinctionDimming) && (curHMSec <= endTime))
lightPwm = map(curHMSec, startTimeExtinctionDimming, endTime, (long)pwmMax, (long)pwmMin);
// Periode en dehors des plages de fonctionnement
else
lightPwm = 0;
if (id == 1) {
lightPin = ECL1;
ballastPin = BALLAST1;
}
if (id == 2) {
lightPin = ECL2;
ballastPin = BALLAST2;
}
if (id == 3) {
lightPin = ECL3;
ballastPin = BALLAST3;
}
if (id == 4) {
lightPin = ECL4;
ballastPin = BALLAST4;
}
// On applique la pwm
analogWrite(lightPin, lightPwm);
if ((byte)lightPwm >= pwmMin)
digitalWrite(ballastPin, MARCHE_RELAIS);
else
digitalWrite(ballastPin, ARRET_RELAIS);
#ifdef DEBUG_LIGHT
Serial.print(F("-> light"));
Serial.print(id);
Serial.println(F("Auto"));
Serial.print(F(" |-> Actual Time curHMSec :"));
Serial.println(curHMSec);
Serial.print(F(" |-> startTime :"));
Serial.println(startTime);
Serial.print(F(" |-> dimmingTime :"));
Serial.println(getDimmingTime);
Serial.print(F(" |-> endTimeIgnitionDimming :"));
Serial.println(endTimeIgnitionDimming);
Serial.print(F(" |-> endTime :"));
Serial.println(endTime);
Serial.print(F(" |-> startTimeExtinctionDimming :"));
Serial.println(startTimeExtinctionDimming);
Serial.print(F(" |-> pwmMax :"));
Serial.println(pwmMax);
Serial.print(F(" |-> pwmMin :"));
Serial.println(pwmMin);
Serial.print(F(" |-> lightPwm :"));
Serial.println(lightPwm);
if (lightPwm >= pwmMin)
Serial.println(F(" |-> Marche relais"));
else
Serial.println(F(" |-> Arret relais"));
Serial.println(F(""));
#endif
return (byte)lightPwm;
}
// Applique la bonne puissance aux eclairages en mode manuel
byte lightSetPwmManu(byte id, byte pwmMin, byte pwmMax, boolean modeManuelStatus)
{
// Declaration des sorties
int lightPin, ballastPin;
// Pwm de l'eclairage
byte lightPwm = 0;
if (id == 1) {
lightPin = ECL1;
ballastPin = BALLAST1;
}
if (id == 2) {
lightPin = ECL2;
ballastPin = BALLAST2;
}
if (id == 3) {
lightPin = ECL3;
ballastPin = BALLAST3;
}
if (id == 4) {
lightPin = ECL4;
ballastPin = BALLAST4;
}
// Manuel ON
if (modeManuelStatus == 1)
lightPwm = pwmMax;
// Manuel OFF
if (modeManuelStatus == 0)
lightPwm = 0;
// On applique la pwm
analogWrite(lightPin, lightPwm);
if (lightPwm >= pwmMin)
digitalWrite(ballastPin, MARCHE_RELAIS);
else
digitalWrite(ballastPin, ARRET_RELAIS);
#ifdef DEBUG_LIGHT
Serial.print(F("-> light"));
Serial.print(id);
Serial.println(F("Manu"));
Serial.print(F(" |-> pwmMax :"));
Serial.println(pwmMax);
Serial.print(F(" |-> pwmMin :"));
Serial.println(pwmMin);
Serial.print(F(" |-> lightPwm :"));
Serial.println(lightPwm);
if (lightPwm >= pwmMin)
Serial.println(F(" |-> Marche relais"));
else
Serial.println(F(" |-> Arret relais"));
Serial.println(F(""));
#endif
return lightPwm;
}
Heloderma-kris:
que cherche tu a faire le systeme du balaste dimable ou le systeme de gestion du ballaste?car ballaste dimmable effectivement on en trouve pas mal .
le systeme de gestion quand a lui peut piloter les balaste en fonction des type de protocole du systeme dimable
0-10V
DALI
KNXbref c'est sur ça qu'il faut travailler!
emple d'un systeme dimable via commande 0-10V (ce sont des ballaste qui ne s'eteignent pas totalement a 0V)https://www.youtube.com/watch?v=zzFkW6QfpCc&list=UUSpV586KkTKbix6tiNgu8_A
Salut merci pour ta réponse,
Effectivement c'est un système dimmable ou dimming.
Par contre quel est la différence entre :
0-10V
DALI
KNX
?
Dali, KNX ce sont des marques, mais en gros le pilotage, enfin c'est surtout l'interface électronique que tu devras mettre en place entre l'arduino et le ballast qui changera.
Niveau coût, le ballast le moins chère sera du (1-10v non pwm) comme je t'est envoyé par mp.
Moi j'ai utilisé des petites carte toute faite pour interfacé l'ensemble. (google: maitech 0-10v)
Sinon si tu veux faire ta propre carte, j'ai vu sur le net un schémas complet pour gérer les ballasts 1-10v et qui contient en plus l'extinction du ballast par relais. (cela te fait gagné 2 lignes de code et 2 sorties sur l'arduino).
http://img99.xooimage.com/views/3/1/8/conv-pwm-0-10v-et-relais-410d24c.jpg/
Avec se schéma la tu peux ajusté le signal de la pwm et de la commutation du relais (1v) pour l'extinction de la lampe. Je vais faire la carte prochainement je pense... Ou si tu t'y met je veux bien que tu en face 2 
et moi je t'aide pour le code! Bon dil je pense?
l'avantage et ou inconvégnient du DALI c'est sont coté bus , mais avec une bonne programation objet et une bonne librairie ça permet de piloté avec tres peut de fils ( donc I/O) de l'arduino beaucoup de systeme.
ce qui n'est pas le cas d'un syteme 0-10V car celui ci te prendra une Sortie PWM par ballaste a géré individuelement
bonne explication du systeme DALI
cours:
http://sitelec.org/cours/abati/dali/dali.htm
et enfin exemple Arduino +librairie
Pas mal en faite! Je connaissais pas... Niveau tarif ça se tiens...
Il faut après acheté une petite interface dali pour intercalé entre les 2.
Oh bas je vais changé mes ballasts, un nouveau joujou a piloté! Whouais!!!
Bon en attendant, je retourne me noyé dans malloc, PROGMEM... 