Commander des leds de puissances : application éclairage velo

L’éclairage de velo peut avoir de nombreuses options.

D’ailleurs, le post suivant l’avait démontré, mais ce post est parti dans tous les sens

Donc, j’ai relancé 3 équipes d’étudiants d’IUT génie électrique de Soissons avec des options différentes en utilisant des micro differents n’utilisant que de nombreuses leds faibles puissance et faible angle émissivité pour augmenter la valeur de l’eclairement.

Pour synthétiser tout ce qu’il y avait sur le lien du forum précédent un blog a été créé

Les étudiants doivent présenter leurs méthodes, leurs résultats et des explications de leurs différents programmes pour faire un tuto pour que d’autres personnes réalisent un éclairage à led celon leurs besoins et connaitre les limites de leurs éclairages avec le dossier suivant

pour le but premiere année
https://www.fichier-doc.fr/2022/04/25/sae-eclairage-led-pwm-1er-annee-2022/

pour le BUT deuxieme année

Le dossier précèdent présente le cahier des charges, le typons, les schémas électrique et le choix des composants

Exemple pour l’ESP32 avec une résistance shunt de 0.1 ohms donc un ampli de 10 pour améliorer la précision de la mesure courant.

Voici le schéma electrique et le typon

le pcb

Voici les résultats avec l’éclairage utilisant un ESP32 avec 18 leds de 8° de 65candela demandant un courant de 0.9A.

Avec le programme en boucle ouverte suivant

//eclairage avant  TTGO+OLED+18 LED
#include <TFT_eSPI.h>
#include <SPI.h>
//  #include <EEPROM.h>


TFT_eSPI tft = TFT_eSPI();  // Invoke library

   #define S1       0    // fonctionne à 0L     BP gauche
   #define S2      35    // BP droite
   #define ADC_PIN 34    // tension batterie
   
RTC_DATA_ATTR   bool flag=0,flagT;    //save data sleep
RTC_DATA_ATTR   int  wakeup_reason;
RTC_DATA_ATTR float tensionbatt,consigne, courant, courant1, erreur;
RTC_DATA_ATTR unsigned int  PWM, compteur1;
RTC_DATA_ATTR byte compteur,i ;

RTC_DATA_ATTR float courantled ;


const int ledChannel = 1;



void setup() { 
pinMode(ADC_PIN, INPUT);   //mesure de la tension batterie 
pinMode(2, INPUT);         //mesure courant
pinMode(S2, INPUT_PULLUP);
pinMode(14, OUTPUT);   //mesure du temps à l'oscillo
pinMode(26, OUTPUT);

digitalWrite(14,1);
  
    tft.init();
    tft.setRotation(0); //format portrait a l'endroit
    Serial.begin(115200);
      
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(TFT_WHITE,TFT_BLACK); 
  analogReadResolution(12);   //12 bits 
 
ledcSetup(ledChannel, 64000, 10);     //PWM 64kHz  10bits

ledcAttachPin(32, 1);        //broche 32 PWM, chanel 1
PWM=1023;
ledcWrite(ledChannel,PWM);  //blocage transistor 

}



void loop() {
//comande de la LED en boucle ouverte
       if (digitalRead(S1)==0)  {PWM=PWM-20;delay(100);}
       if (digitalRead(S1)==1)  {compteur=0;}
       if (!(digitalRead(S2)))  {compteur;PWM=PWM+20;delay(100);}      //consigne=consigne-0.1;
if (PWM>=1023) {PWM=1023;} 
if (PWM<=10)  {PWM=20;}
       
       
 //si appuie du S2 plus de 15 secondes (15 fois la loop )alors mise en veuille pour recharge batterie           
     if (compteur>=15){
        esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);    //reveille par le RESET                 
        esp_deep_sleep_start();     //sleep le oled                                  
                      }
                          
//mise en veuille si batterie < à 3.2                             
/*   if (tensionbatt<=3.2) {
    esp_sleep_enable_ext0_wakeup(GPIO_NUM_0,0); 
    esp_deep_sleep_start();     //sleep le oled
    }                         
*/

  tensionbatt=analogRead(ADC_PIN);          //34 interne, pont diviseur par 2 (100Kohm)
  tensionbatt=(tensionbatt*2*3.63)/(4095);


 for (i=0; i <= 10; i++) {           //boucle de ?ms 
   if ( digitalRead(26)== 1 ) {digitalWrite(26,LOW);}  else {digitalWrite(26,HIGH);}
                   
courant=analogRead(2);        //resistance shunt de 0.1ohm*10 ampli
courant1=(courant/1400);   //mesure un courant max de 14.6A  

// Serial.print(courant,3);Serial.print(";");Serial.println(PWM);     

/*
erreur=consigne-courantled;
Integral= Integral+erreur*10;       //Integral= Integral+erreur*ki;
      if (Integral>=1023) Integral=1023;
      if (Integral<=0) {Integral=0;}
      PWM=Integral;
*/      

  ledcWrite(ledChannel,PWM);                            
 delay (50);    //1*50=>50ms
  }  //end for

//affichage tous les 50ms
  tft.setCursor(0, 0, 4);// (x,y,taille)  //durée 4ms
  tft.print(tensionbatt,2); 
  tft.println("=V");
  tft.print(courant1,3);
  tft.println("=If");
  tft.print(PWM);
  tft.println("=PWM    "); 

   
 }//end loop//eclairage avant  TTGO+OLED+18 LED
#include <TFT_eSPI.h>
#include <SPI.h>
//  #include <EEPROM.h>


TFT_eSPI tft = TFT_eSPI();  // Invoke library

   #define S1       0    // fonctionne à 0L     BP gauche
   #define S2      35    // BP droite
   #define ADC_PIN 34    // tension batterie
   
RTC_DATA_ATTR   bool flag=0,flagT;    //save data sleep
RTC_DATA_ATTR   int  wakeup_reason;
RTC_DATA_ATTR float tensionbatt,consigne, courant, courant1, erreur;
RTC_DATA_ATTR unsigned int  PWM, compteur1;
RTC_DATA_ATTR byte compteur,i ;

RTC_DATA_ATTR float courantled ;


const int ledChannel = 1;



void setup() { 
pinMode(ADC_PIN, INPUT);   //mesure de la tension batterie 
pinMode(2, INPUT);         //mesure courant
pinMode(S2, INPUT_PULLUP);
pinMode(14, OUTPUT);   //mesure du temps à l'oscillo
pinMode(26, OUTPUT);

digitalWrite(14,1);
  
    tft.init();
    tft.setRotation(0); //format portrait a l'endroit
    Serial.begin(115200);
      
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(TFT_WHITE,TFT_BLACK); 
  analogReadResolution(12);   //12 bits 
 
ledcSetup(ledChannel, 64000, 10);     //PWM 64kHz  10bits

ledcAttachPin(32, 1);        //broche 32 PWM, chanel 1
PWM=1023;
ledcWrite(ledChannel,PWM);  //blocage transistor 

}



void loop() {
//comande de la LED en boucle ouverte
       if (digitalRead(S1)==0)  {PWM=PWM-20;delay(100);}
       if (digitalRead(S1)==1)  {compteur=0;}
       if (!(digitalRead(S2)))  {compteur;PWM=PWM+20;delay(100);}      //consigne=consigne-0.1;
if (PWM>=1023) {PWM=1023;} 
if (PWM<=10)  {PWM=20;}
       
       
 //si appuie du S2 plus de 15 secondes (15 fois la loop )alors mise en veuille pour recharge batterie           
     if (compteur>=15){
        esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);    //reveille par le RESET                 
        esp_deep_sleep_start();     //sleep le oled                                  
                      }
                          
//mise en veuille si batterie < à 3.2                             
/*   if (tensionbatt<=3.2) {
    esp_sleep_enable_ext0_wakeup(GPIO_NUM_0,0); 
    esp_deep_sleep_start();     //sleep le oled
    }                         
*/

  tensionbatt=analogRead(ADC_PIN);          //34 interne, pont diviseur par 2 (100Kohm)
  tensionbatt=(tensionbatt*2*3.63)/(4095);


 for (i=0; i <= 10; i++) {           //boucle de ?ms 
   if ( digitalRead(26)== 1 ) {digitalWrite(26,LOW);}  else {digitalWrite(26,HIGH);}
                   
courant=analogRead(2);        //resistance shunt de 0.1ohm*10 ampli
courant1=(courant/1400);   //mesure un courant max de 14.6A  

// Serial.print(courant,3);Serial.print(";");Serial.println(PWM);     

/*
erreur=consigne-courantled;
Integral= Integral+erreur*10;       //Integral= Integral+erreur*ki;
      if (Integral>=1023) Integral=1023;
      if (Integral<=0) {Integral=0;}
      PWM=Integral;
*/      

  ledcWrite(ledChannel,PWM);                            
 delay (50);    //1*50=>50ms
  }  //end for

//affichage tous les 50ms
  tft.setCursor(0, 0, 4);// (x,y,taille)  //durée 4ms
  tft.print(tensionbatt,2); 
  tft.println("=V");
  tft.print(courant1,3);
  tft.println("=If");
  tft.print(PWM);
  tft.println("=PWM    "); 

   
 }//end loop
4 Likes

On attend les résultats !!

1 Like

Mise en place d'une régulation du courant pour contrôler les LEDS.

Les LEDs sont alimentées par une batterie qui varie entre 3V et 4.2V c'est pour cela (afin de ne pas subir cette variation de luminosité) que nous utilisons un contrôle en courant des leds.

Pour réaliser cette régulation nous pouvons séparer en plusieurs taches notre système :

  • Mesure du courant dans la LED
  • Filtrage du courant
  • Correction du système

Notre système se schématise de la manière suivante :

Mesure du courant dans la LED

Pour lire l'intensité nous utilisons la broche analogique 2 (voir schéma Proteus du premier poste).
L'acquisition peut se faire donc avec le code suivant :

#DEFINE ANALOG_INTENSITY 2
...
int newVSAOP = analogRead(ANALOG_INTENSITY);
newVSAOP = (newVSAOP / 1.24);//Pour avoir des mA
newVSAOP = constrain(newVSAOP, 0, 5000);// pour éviter les erreurs de mesure

Nous observons l'intensité en mA.

Cette intensité est très perturbé à cause de notre hacheur cadencé à 64kHz qui se trouve juste à coté.

Il faut donc filtrer le courant affins d'avoir une mesure cohérente.

Filtrage du courant

Pour filtrer nous allons utiliser un filtre numérique passe bas du second ordre. Celui-ci à la fonction de récurrence y(n)=(x(n)+x(n−1)+19y(n−1))∗0.0476. Il a une fréquence de coupure de 15Hz.
Voici le code permettant ce filtrage :

double x1_var = 0;
double y1_var = 0;
double filter(double in)
{
    double y = (in+x1_var+19.0*y1_var)*0.0476;
    x1_var = in;
    y1_var = y;
    return y;
}

Et voici le filtrage en fonctionnement

On observe une plus grande stabilité du courant ce qui va faciliter sa régulation.

Maintenant qu'il est possible de mesurer le courant nous pouvons mettre en place la régulation en intensité de la led.

Correction du système

La régulation de courant dans la led est simple à implémenter en voici le code.

void regulation(uint16_t consigne, uint16_t intensite)//en mA
{
    int erreur = consigne - intesite;
    int pwmE = PWM_MAX - global.current_PWM;
    int pwm = pwmE + (erreur / 100);
    pwm = PWM_MAX - constrain(pwm, 0, PWM_MAX);
}

Dans notre code nous divisons l'erreur par 100 cette division est le gain correcteur Ki.
Cette régulation est rapide, elle est exécutée à une fréquence de 4000Hz environ.

Plus simplement il permet de gérer l'influence de l'erreur sur notre système un gain trop grand accélère la correction du système mais le rend possiblement oscillant (instable).

Sur notre système de lampe de vélo voici à quoi ressemble notre régulation des leds.


En rouge il y a l'intensité, en bleu la consigne et en vert la PWM.
Nous observons bien que le système arrive correctement à suivre la consigne.

Clignotement

Il est possible maintenant dans notre boucle de se servir de la consigne pour faire clignoter la led.
Dans la loop nous pouvons modifier la consigne entre 0 et 400mA pour faire varier la luminosité.

void loop(){
  consigne = 0;
  delay(950);
  consigne  = 400;
  delay(50);
}

Autres

Le code complet pour la régulation sous forme d'une tâche RTOS(uniquement pour les ESP32) est disponible ici.
Si vous utilisez ce code il suffit de modifier les lignes suivantes en fonction de vos paramètres

#define BROCHE_INTENSITY 2 //broche de la mesure de l'intensité.
#define PWM_MAX 1023 //résolution de la PWM
#define PWM_CHANNEL 0 //Canal de la pwm

Et dans votre void setup() lancer la tâche de régulation de la manière suivante

void setup(){
	...
	initRegulation();
	...
}

Liens utiles

Calcul des coefficients pour un filtre Butter Worth ici
Logiciel de Tracage série ici

Le code complet

#include <Arduino.h>

#define BROCHE_INTENSITY 2
#define PWM_MAX 1023
#define PWM_CHANNEL 0



TaskHandle_t capteurHandle = NULL;

uint16_t regulation(uint16_t consigne, uint16_t intensite);
double filtre(double in);

uint16_t intensite,consigne;

void _taskRegulation(void *args)
{
    uint8_t compteur = 0;
    unsigned long lastTime = micros();
    for (;;)
    {
        int newVSAOP = analogRead(BROCHE_INTENSITY);
        newVSAOP = (newVSAOP / 1.24);
        newVSAOP = constrain(newVSAOP, 0, 5000);
        // filtre numérique intensité
        double intent = filtre(newVSAOP);
        intensite = intent;

        // TODO : Régulation
        
        uint16_t pwm_global = regulation(400,intensite);

        ledcWrite(PWM_CHANNEL, pwm_global);
    }
    vTaskDelete(capteurHandle);
}

void initRegulation()
{
    analogReadResolution(12);
    xTaskCreate(_taskRegulation, "REGU_TASK", 4096, NULL, 1, &capteurHandle);
}



// y(n)=(x(n)+x(n−1)+19y(n−1))∗0.0476
double x1_var = 0;
double y1_var = 0;
double filtre(double in)
{
    double y = (in + x1_var + 19.0 * y1_var) * 0.0476;
    x1_var = in;
    y1_var = y;
    return y;
}


uint16_t regulation(uint16_t consigne, uint16_t intensite)//en mA
{
    int erreur = consigne - intensite;
    int pwmE = PWM_MAX - ledcRead(PWM_CHANNEL);
    int pwm = pwmE + (erreur / 100);
   return PWM_MAX - constrain(pwm, 0, PWM_MAX);
}
void setup(){
//my code
  initRegulation();
}
void loop(){
  consigne = 0;
  delay(950);
  consigne  = 400;
  delay(50);
  affichage();
}

//Pour l'affichage de l'intensité
TFT_eSPI tft = TFT_eSPI(135, 240);
void affichage(){
   tft.drawString("       ", (tft.width() / 2) - (tft.textWidth("       ") / 2), 230);
   String power = (String(global.intesite) + "mA");
    tft.drawString(power.c_str(), (tft.width() / 2) - tft.textWidth(power) / 2, 230);
}
4 Likes

Voici une étude que nous avons faite sur un hacheur :


Ci-dessous les réponses aux questions.
Question 1 :

Avec le tableau :
Vseuil = 0.92.5=2.125V
Power = 0.4
0.4=0.156W
Lux = 0.31100=308lux
lumen = lux/2
Surface avec Surface=*r² avec r=tan(4°)*0.4m = 0.027
⇒ 0.5 lumens

Question 2 :

Pabs = 2.250.05 = 0.113W
Pabs = 0.26
0.4 = 0.104W

Question 3 :

24led0.113=2.7W
3.7
2.5 = 9.25W.h
Autonomie = 9.25/2.7= 3.42W
lumen = lux/2Surface
⇒ 308
piRayon² = 3082pi0.4²tan²(4²)0.4²tan²(4²) = 154pi0.4tan²(4²) = 15.9 lumens

Question 4 :

R = UrI= (4.2-2.25)/(2.40.05) = 1.66
P = R
I² = 1.661.2² = 2.39W
= Pu/Pabs = (2.25
1.2)/(4.2*1.2) = 52% à 73% avec 3V

4 Likes

4 Likes


Réponses aux questions :

Question 5 :

C’est un hacheur abaisseur.
→ Plus la fréquence est grande et plus il sera facile de lisser le courant et baisser la valeur de l’inductance.
I = (U-E)/(4*L)*a/f

Question 6 :

Puissance perdue = Pp = RdsaId²a = 0.00111.2²0.758 = 0.12W ⇒ Négligeable
Chute de tension = Vdsa = RdsaId = 0.0111.2 = 0.13V

C'est pénible, lorsque l'on est nouveau on ne peut pas publier + de 3 publications et 2 images de suite.
Donc comment avancer ???!!

4 Likes

#Projet de régulation d'une LED de puissance via un ARDUINO

Carte utilisée: ARDUINO PRO MINI (ATMEGA 328)

Le sujet proposé a pour but de réguler une LED de puissance afin d'obtenir, quel que soit le niveau de la batterie, pour avoir un éclairage d'intensité constante.

I) Boucle ouverte :

Pour commencer le projet nous débutons avec la boucle ouverte qui a pour but de faire fonctionner la LED avec différents modes, que ce soit d’intensité comme de de fonctionnement (clignotant, continu), cela en essayant d’avoir une consommation la plus réduite possible.

Le 1er objectif qu’on se fixe sur cette partie est de piloter la PWM afin de commander la LED. On a donc commencé par faire un programme simple :

include <Arduino.h>
#define PWM 6
void setup() {  
pinMode(PWM,OUTPUT);
TCCR0B = (TCCR0B & 0b11111000) | 0x01; //Assignation du Timer 0 à la PWM
(64Khz)
}

void loop(){
analogWrite(PWM,127) ; // Pilotage de la sortie PWM avec un rapport 
//cyclique de 0.5. En effet les valeurs possibles pour la PWM sont comprises 
//entre 255 et 0 où à 255 la PWM est à l’arrêt et à 0 le rapport cyclique 
//est de 1.
}

On obtient lors de la simulation de ce programme :

On récupère ici la tension de sortie de la PWM.

Le 2nd objectif est d’améliorer le premier afin d’y intégrer un mode clignotant en plus du mode continu. Pour cela nous avons eu l’idée d’utiliser une interruption du timer 1 pour compter afin d’obtenir 50 ms allumé pour 950ms éteint. En plus on veut rajouter une fonction permettant de changer la valeur de la PWM afin d’avoir différentes intensité (Autant courant que lumineux). Cette fonction sera activable via un bouton poussoir et un autre sera utiliser pour passer du mode continu au mode clignotant.

Programme:

#include <Arduino.h>
#include <TFT_eSPI.h>
#include <TimerOne.h>
#include <LowPower.h>

#define PWM 6
#define BPR 10
#define BPM 11
#define TG 2
int count=0;
int m=1,n=1;
int speed=127;
int p=0,p2=0;
   
   
void Tint() { //programme D'interruption pour compter
switch (n){// Mode cligno et continu

case 1:    count++;
if (count<95){
    analogWrite(PWM,255);
}

if (count >=95 && count <98){
    analogWrite(PWM,speed);
}
if(count>98){
    count=0;
    } Serial.println(speed);break;

case 2:
analogWrite(PWM,speed);
Serial.println(speed);
break;


}
}








void setup() {  
    Serial.begin(19200);
pinMode(PWM,OUTPUT);
pinMode(BPR,INPUT_PULLUP);
pinMode(BPM,INPUT_PULLUP);
pinMode(TG,OUTPUT);
Timer1.initialize(10000);           // initialize timer1, and set a 0,1 second period =>  100 000  pour 0.01s  10 000
Timer1.attachInterrupt(Tint);

TCCR0B = (TCCR0B & 0b11111000) | 0x01; //64kHz Timer 0

}

void loop(){
if (digitalRead(BPM) ==LOW ) {
p++;
if (p>=75){
m++;                  //incrementation des modes 
if (m>3) m=1;

switch (m) {
case 1:speed=127;   break;
case 2:speed=195;   break;
case 3:speed=240;   break;
}
p=0;
}

}
if (digitalRead(BPR) == LOW  ) {
p2++;
if (p2>=75){
n++;                  //incrementation des modes 
if (n>2) n=1;
p2=0;
}
}

  
}

Ce programme fonctionne très bien en boucle ouverte mais possède tout de même des limites qui vont nous empêcher de l'utiliser dans notre quête de basse consommation et de régulation.

Comment ce fait il que un nouveau compte soit bloquer juste parce qu'on veut poster ?? Vraiment pas ouf ça.

4 Likes

Le projet lié au tutoriel

Voici le projet complet disponible sur mon GitHub.
Le minimal requis pour ce code est un TTGO T-Display ESP32 avec 1Mo de ROM minimum.
Ce projet comprends les fonctionnalités suivantes :

  • [x] Régulation en intensité du système
  • [x] Gestion de la batterie
  • [x] Système de coupure en cas de batterie faible
  • [x] Sauvegarde de l'état du système
  • [x] Affichage "Jolie" des informations de la régulation
  • [x] Interface "User friendly" pour les modes de la lampe

Améliorations possibles:

  • Mettre en place une gestion de la led en BLE ou en Wifi
  • Si mise en place du Wifi Permettre les mises à jour OTA(Over The Air)

Voici des photos du système:


Nomenclature

Article Prix Lien
TTGO 11€ lien
Led 0.75€ Lien
Bobine 0.8€ lien
Diode 0.067€ Lien
PCB 2€ Fait main
Total 14.56€
4 Likes

bravo - belle documentation !

(idéalement éditez vos posts contenant du code pour les indenter, ce sera plus lisible)

1 Like

PARTIE 2 : REGULATION EN BOUCLE FERMEE

####Objectif : Réguler la LED en fonction de la tension de batterie et Consommer le moins possible.

Le principe est de récuperer sur une sortie analogique la tension délivrée est de la convertir en intensité. Ensuite on fait varier le rapport cyclique de la PWM de sorte à se rapprocher d'une consigne défini par les différents modes de puissances.

  • Ic -> consigne en intensité

  • Integral -> correction à appliquer sur le rapport cyclique de la PWM

  • Ki -> Facteur de vitesse d'asservissement (il permet de déterminé la vitesse à laquelle on régule. Attention plus ce facteur est grand plus faible est la précision)

  • erreur -> Différence entre la consigne et le courant.

Concernant le mode de veille, on se rend vite compte que les interruptions ne sont pas simple d'utilisation lors ce qu'on met en place un Sleep mode. Cela est due au fait qu'il faut gérer les paramètres de mise en veille. Nous avons donc choisi la faciliter en revsistant le programme:
Il utilise maintenant aucune interruption car nous utilisons comme Timer le temps d'une loop.

On obtient :

#include <Arduino.h>
#include <TFT_eSPI.h>
#include <TimerOne.h>
#include <SimpleSleep.h>


#define PWM 6
#define BPR 10
#define BPM 11
#define TG 2

float Vbatt;
float Vled;
float Iled;
float Ialim;
float I=0,erreur=0,ki=10,Ic=0.4,Integral=150;
int count=0,p=0,p2=0;
int m=1,n=1;
int8_t speed=127;
SimpleSleep Sleep;




void setup() {  
    Serial.begin(19200);
pinMode(PWM,OUTPUT);
pinMode(BPR,INPUT_PULLUP);
pinMode(BPM,INPUT_PULLUP);
pinMode(TG,OUTPUT);
TCCR0B = (TCCR0B & 0b11111000) | 0x01; //64kHz Timer 0
analogReference(INTERNAL);// ref 1.1V
analogWrite(PWM,255);

}


void loop(){

I=analogRead(A3); //récupération de la tension avant conversion
I=I/465;       //1.1V/(1024*0.5ohms)    mesure du courant max 2.2A


Vbatt=analogRead(A0);       //1.1*4.2/1024
Vbatt=Vbatt*0.00451;







  if (digitalRead(BPM) ==LOW ) {
      p++;
if (p>=20){
  
  m++;                  //incrementation des modes 
  if (m>3) m=1; 

  switch (m) { // Différentes consignes de régulation
  case 1:Ic=0.4;   break;   
  case 2:Ic=0.2;   break;
  case 3:Ic=0.1;   break;
     }
     p=0;
}

  } 
  if (digitalRead(BPR) == LOW  ) {
p2++;
if (p2>=20){
  n++;                  //incrementation des modes 
  if (n>2) n=1; 
 p2=0;
  }
 }
  digitalWrite(TG, !digitalRead(TG));

switch (n){

case 1:    count++;
if (count==0){
    analogWrite(PWM,255); 
   Sleep.lightlyFor(950);// Mise en place d'un mode veille permettant un moins haute conso durant les phase éteintes
count++;
}
if (count>0 || count <230){
      analogWrite(PWM,255);
  count++;
}

if (count >=230 && count <250){
  erreur=Ic-I; //Calcul de l'erreur par rapport à la consigne
Integral= Integral+(erreur*ki); // Intregral correspond à la correction à apporter
if (Integral<=1)Integral=1;//Limite de la PWM avant arrêt
if (Integral>200)Integral=200;// Limite de la PWM pour ne pas avoir un courant trop important
speed=255-Integral;// Correction du rapport cyclique
    analogWrite(PWM,speed);
}
if(count>249){
    count=0;
    

  }  Serial.println(speed);
Serial.println(I);
Serial.println(speed);

 break;

case 2:
erreur=Ic-I;// Ici même régulation mais en continu
Integral= Integral+(erreur*ki); 
if (Integral<=1)Integral=1;
if (Integral>186)Integral=186;
speed=255-Integral;
analogWrite(PWM,speed);
Serial.print(I,3);Serial.print(",");
Serial.print(Ic,3);Serial.print(",");
Serial.print(speed);Serial.print(",");
Serial.print(erreur,3);Serial.print(",");
Serial.println(m);
break;


}
digitalWrite(2, !digitalRead(2));
}


//4 ms


Résultat sur le montage réel :

Relevés (à 10cm) :

  • Pour la consigne Ic =0.4A on obtient 2500Lux

  • Pour la consigne Ic =0.2A on obtient 1480Lux

  • Pour la consigne Ic =0.1A on obtient 990Lux

Pour récupérer les comptes rendu, images , fichiers et le projet :
(ATTENTION PROJET SOUS VS CODE)

5 Likes

Sélection des composants :

Voici le document Word complété nous servant de support pour nous aider lors de la réalisation du projet.
Certaines questions relatives aux choix des composants ainsi que la nomenclature.

On y retrouve donc :

  • choix du processeur

  • choix du transistor

  • choix de la LED

  • les questions sur le choix de l'inductance

  • choix de la diode de roue libre

  • choix des capteurs de température

  • choix de l'interrupteur

  • la nomenclature et les prix

4 Likes

Nous avons soutenu ce projet devant un jury, voici un extrait de notre présentation ainsi que le code en annexe !

/*
=================================================================
=                                                               =
=         Programmé par L'Empereur De Guadeloupe (C)2022                 =
=                                                               =
=================================================================

*/

int broche_PWM = 6; // Déclaration de la Pin 10 Arduino

byte Valeur_PWM = 255; // Variable PWM image de la consigne de 0 à 255

int bouton_DEC = 11;
int etatbouton_DEC;


int bouton_INC = 10;
int etatbouton_INC;

int mode; // Mode de fonctionnement
int puissance; // puissance de fonctionnement

int compteur;

// WARNING MIN VAL PWM = 127


void setup() {
  Serial.begin(19200);
    pinMode(broche_PWM, OUTPUT); // Pin 10 Arduino en sortie PWM
    pinMode(bouton_DEC,INPUT_PULLUP);// Déclaration du bouton en input
    pinMode(bouton_INC,INPUT_PULLUP);// Déclaration du bouton en input

    analogWrite(broche_PWM,255);
    analogWrite(5,255); // Init lampe coté 
    TCCR0B = (TCCR0B & 0b11111000) | 0x01;   // Fréquence de hachage

    mode = puissance = 0;
   
}

void loop() {

     etatbouton_DEC = digitalRead(bouton_DEC);     
     if(etatbouton_DEC==LOW){     // Mode de puissance
          puissance = puissance + 1;
          while(!digitalRead(bouton_DEC));
     }


     etatbouton_INC = digitalRead(bouton_INC);     
     if(etatbouton_INC==LOW){
          mode = mode + 1;
          while(!digitalRead(bouton_INC));
     }


        // Choix de la puissance avec le bouton DEC
         switch (puissance) {
              case 0:             // Low power (OFF)
                Valeur_PWM=255;
                break;
              
              case 1:
                Valeur_PWM=230;   // Medium powwer 
                break;
              
               case 2:
                Valeur_PWM=200;   // Max power
                break;

               case 3:
                Valeur_PWM=180;   // Max power
                break;

              default : puissance = 0;
        }


        switch (mode) {
              case 0:             // Mode Normal
                 analogWrite(broche_PWM,Valeur_PWM); // A changer en fin de simulation 
                 break;
   *           
              case 1:             // Mode Cligno
                 compteur = compteur + 1 ;^^
                 if (compteur>=65){
                    analogWrite(broche_PWM,Valeur_PWM); // A changer en fin de simulation 
                    if (compteur>=68  ) compteur = 0;
                  }
                  else analogWrite(broche_PWM,255); // A changer en fin de simulation 
                break;



              case 2:             // Mode Cligno
                 compteur = compteur + 1 ;
                 if (compteur>=20){
                    analogWrite(broche_PWM,Valeur_PWM); // A changer en fin de simulation 
                    if (compteur>=19) compteur = 0;
                  }
                  else analogWrite(broche_PWM,255); // A changer en fin de simulation 
                break;


                

                default : mode = 0;
        }
        Serial.println("mode : " + String(mode) + " | puissance : " + String(puissance));

        // Protection Over Current
        if (Valeur_PWM < 170) Valeur_PWM=255;
}
3 Likes

programme en boucle ouverte

int valeur_PWM = 254;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(57600);
  pinMode(6, OUTPUT);

}

void incdec_PWM () {
  if (Serial.available() > 0) {
    if (Serial.read() == '-') {
      if (valeur_PWM <= 0) valeur_PWM = 0;
      else {
        valeur_PWM = valeur_PWM - 1;
        analogWrite(6, valeur_PWM);
      }
    }
    if (Serial.read() == '+') {
      if (valeur_PWM >= 254) valeur_PWM = 254;
      else {
        valeur_PWM = valeur_PWM + 1;
        analogWrite(6, valeur_PWM);
      }
    }
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  incdec_PWM();
  Serial.println(valeur_PWM);

}

programme pour sleep mode :

un counter 8bit peut compter jusqu'a 256, un compteur 16 bits peut aller jusqu'a 65536.

timeout_calc

le prescaler peut être configurer pour avoir un rapport de
(1:1) (1:8) (1:64) (1:256) (1:1024)

16 bit Timer1 no prescaler (1:1)
Overflow period = 1/16Mhz x 1 x 2^16 = 4.09 milliseconds

16 bit Timer1 with prescaler of (1:1024)
Overflow period = 1/16Mhz x 1024 x 2^16 = 4.09 seconds.

en utilisant le prescaler (1:1024) on peut avoir un overflow de 4.09 seconds

registre de controle :

TCCR1B - CS10, CS11 & CS12 - control du timer et selection des bits du prescaler.

#include <avr/sleep.h>
#include <avr/power.h>


volatile int f_timer = 0;

ISR(TIMER1_OVF_vect)
{
  /* set the flag. */
  if (f_timer == 0)
  {
    f_timer = 1;
  }
}

void enterSleep(void)
{
  set_sleep_mode(SLEEP_MODE_PWR_DOWN); //sleep mode power down
  sleep_enable();
  /* Disable all of the unused peripherals. This will reduce power
     consumption further and, more importantly, some of these
     peripherals may generate interrupts that will wake our Arduino fromsleep!*/
  power_adc_disable();
  power_spi_disable();
  power_timer0_disable();
  power_timer2_disable();
  power_twi_disable();
  /* Now enter sleep mode. */
  sleep_mode();
  /* The program will continue from here after the timer timeout*/
  sleep_disable(); /* First thing to do is disable sleep. */
  /* Re-enable the peripherals. */
  power_all_enable();
}


void setup()
{
  Serial.begin(57600);
  /* Don't forget to configure the pin! */
  pinMode(6, OUTPUT);
  /*** Configure the timer.***/
  /* Normal timer operation.*/
  TCCR1A = 0x00;
  /* Clear the timer counter register.
     You can pre-load this register with a value in order to
     reduce the timeout period, say if you wanted to wake up
     ever 4.0 seconds exactly. */
  TCNT1 = 0x0000;
  /*Configure the prescaler for 1:1024, giving us a
     timeout of 4.09 seconds.*/
  TCCR1B = 0x05;
  /*Enable the timer overlow interrupt. */
  TIMSK1 = 0x01;
}


void loop()
{
  if (f_timer == 1)
  {
    f_timer = 0;
    /* Toggle the LED */
    digitalWrite(6, !digitalRead(6));
    /* Re-enter sleep mode. */
    enterSleep();
  }
}

voici le résultat
sleepmode_gif

programme mesure tension batterie au borne de la carte Arduino pro

void setup() {
  analogReference(INTERNAL);    // use the 1.1 V internal reference for battery level measuring
  Serial.begin(57600);
  pinMode(A2, OUTPUT);
  // some code
}

const long InternalReferenceVoltage = 1062;  // Adjust this value to your board's specific internal BG voltage


int getBandgap ()
{
  // REFS0 : Selects AVcc external reference
  // MUX3 MUX2 MUX1 : Selects 1.1V (VBG)
  ADMUX = bit (REFS0) | bit (MUX3) | bit (MUX2) | bit (MUX1);
  ADCSRA |= bit( ADSC );  // start conversion
  while (ADCSRA & bit (ADSC))
  { }  // wait for conversion to complete (toss this measurement)
  ADCSRA |= bit( ADSC );  // start conversion
  while (ADCSRA & bit (ADSC))
  { }  // wait for conversion to complete
  int results = (((InternalReferenceVoltage * 1024) / ADC) + 5) / 10;
  return results;
} // end of getBandgap


void loop() {
  int bandgap = getBandgap();
  float bandgapprcnt = ((bandgap*100)/3.3)/100;
  Serial.print("Battery prcnt="); Serial.print(bandgapprcnt); Serial.println("%");
}

voici le résultat

3 Likes

Étude boucle ouverte en simulation et en réel en mode continu d’éclairage

2 Likes

Étude boucle ouverte en simulation et en réel en mode continu d’éclairage

#include <SoftwareSerial.h>
#include <TimerOne.h>
#define led2   13       // 13
 
byte PWM=0;
int temps=0;
int temps1=0;

float Vbatt;
float I=0,erreur=0,kp=1,ki=7.5,Ic=1,Integral=200;


bool envoie;


void callback()  {    //1ms
 temps++;
 temps1++;
 if (temps1>100)  {envoie=1; temps1=0;}   //envoie des données toutes les 0.1secondes
}  //fin callback



void setup() {
pinMode(led2, OUTPUT);   //
pinMode(6, OUTPUT);      //PWM
//pinMode(6, OUTPUT); 
Serial.begin(9600);

analogWrite(6,255);
//analogWrite(6,255);

 Timer1.initialize(1000);           // initialize timer1, and set a 0,1 second period =>  100 000  pour 0.01s  10 000
 Timer1.attachInterrupt(callback);   // attaches callback() as a timer overflow interrupt

analogReference(INTERNAL);  //1.1V 

//   TCCR0B = (TCCR0B & 0b11111000) | 0x01;      //pin 5 et 6  64khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet              
   TCCR0B = (TCCR0B & 0b11111000) | 0x03;         //1000 hz                 
}


void loop() {  
// avec le transitor canal P, PWM inversé
I=analogRead(A3);
I=I*0.002148;       //1.1/(1024*0.5)    mesure du courant max 2.2A

PWM=0;
analogWrite(6,PWM);    //PWM 3led power 0.1Watt
digitalWrite(10,11);
if (envoie==1) {
Vbatt=analogRead(A0);       //1.1*4.2/1024
Vbatt=Vbatt*0.00451;
Serial.print("V=");Serial.print(Vbatt,2);Serial.print(";");
Serial.print("I=");Serial.print(I,3);Serial.println(";");

envoie=0;
}

} // fin loop   

2 Likes

Le but du projet est de commander des LEDS avec un Arduino nano. On s'intéresse ici à la gestion des modes (continue, éteint, clignotement) et la mesure du courant.

Le programme suivant permet de choisir entre les 3 modes de fonctionnement ainsi que 3 intensités différentes :

#include <TimerOne.h>
byte PWM;                     // valeur de la PWM comprise entre 0 et 255
byte cpt_mode = 0;            // compteur pour choisir le mode de fonctionnement
byte cpt_intensite = 0;       // compteur d'intensité pour l'intensité des LED
boolean clignotement = true;  
int BP_intensite = 10;        
int bpintensite = 0;
int BP_mode = 11;
int bpmode = 0;

void setup() {
  Serial.begin(9600) ;
  pinMode(BP_mode, INPUT_PULLUP);          //PIN bouton_mode
  pinMode(10, INPUT_PULLUP);               // PIN Bouton intensité
  pinMode(6, OUTPUT);                      // PIN Sortie de la PWM
  Timer1.initialize(1000000);              // Timer 1 initialisé à cette valeur pour rentrer dans l'intérruption toute les 1s
  Timer1.attachInterrupt(blinkLED);       // interruption nommé BlinkLED
  interrupts();                           // autorisation de l'intérruption
  TCCR0B = (TCCR0B & 0b11111000) | 0x00;  // ligne néccesaire pour que la simulation ISIS ne plante pas
}

void blinkLED(void)
{
  clignotement = !clignotement;

  ///////////Choix du mode en fonction de l'état du compteur mode///////////
  
  switch (cpt_mode) {
    case 0 :                                         // si cpt_mod = 0 les LED sont en mode continue
      analogWrite(6,PWM);            
      Serial.println("mode continue");
      break;
    case 1 :
      Serial.println("mode cligno_off");            // si cpt_mod = 1 les leds clignotent à une fréquence de 1Hz
      if (clignotement) {       // mode cligno
        analogWrite(6, 255); 
      } else {
        analogWrite(6,PWM);
      }
      break;
    case 2 :                                       // si cpt_mod = 2 les leds sont éteintes
      analogWrite(6, 255);                         // mode éteint : la PWM est à 255, elle reste à l'état bas.
      Serial.println("mode éteint");
      break;
  }


  ///////////Choix de l'intensité lumineuse///////////
  // 3 intensités différentes sont possibles en fonction de la valeur du cpt_intensite
  switch (cpt_intensite) {
    case 0: 
      PWM = 180;
      Serial.println("intensité 1");
      break;
    case 1:
      PWM= 195;
      Serial.println("intensité 2");
      break;
    case 2:
      PWM = 240;
      Serial.println("intensité 3");
      break;
  }
}

/////////// Gestion des boutons poussoirs pour choisir le mode et l'intensité lumineuse des LED///////////

void loop() {

  bpmode = digitalRead(BP_mode);                 // lecture de l'état du bouton poussoir
  if (!bpmode) {                                 // si le bouton est appuye on incrémmente
    cpt_mode ++;  

    if (cpt_mode == 3) {
      cpt_mode = 0;
    }
    while (!digitalRead(BP_mode));              // permet de s'assurer que le compteur ne s'incremmente qu'une fois lorsqu'on appuye sur le bouton
  }

  bpintensite = digitalRead(BP_intensite);      // lecture de l'état du bouton poussoir
  if (!bpintensite) {                           // si le bouton est appuye on incrémmente 
    cpt_intensite ++;
    if (cpt_intensite == 3) {
      cpt_intensite = 0;
    }
    while (!digitalRead(BP_intensite));        // permet de s'assurer que le compteur ne s'incremmente qu'une fois lorsqu'on appuye sur le bouton
  }
}

Ce programme fonctionne en simulation mais ne permet de choisir que 3 intensité.
L'intensité augmente lorsqu'on diminue la valeur de la PWM. Mais si on diminue trop cette valeur, on risque d'abimer les LEDS.
Le programme suivant permet donc de mesurer le courant dans les LED en fonction de la PWM. On va alors chercher pour quel valeur de PWM le courant dans les LEDS est égal à 0.5A.
Les 2 boutons poussoirs permettent d’augmenter ou de diminuer de 1 la valeur de la PWM. Le courant sera visualisé sur le terminal.

bool bpplus;  
bool bpmoins;
int PWM = 255;
float N;   // valeur numérique de I
float I;  // intensity 

void setup() {
  Serial.begin(57600) ;
  pinMode(10,INPUT_PULLUP);              // -- PWM ==> intensité lumineuse ++
  pinMode(11,INPUT_PULLUP);              // ++ PWM ==> intensité lumineuse --
  pinMode(6, OUTPUT);                    // sortie PWM       
  Serial.println("depart");
TCCR0B = (TCCR0B & 0b11111000) | 0x01;  // ligne nécessaire pour que la simulation ISIS ne plante pas  1 : (64KHz)

analogWrite(6,255);                     //initialisation de la PWM à la valeur 255
analogReference(INTERNAL) ;   //1.1V tension de référence internal
}

////////////// variation de la PWM en fonction de 2 boutons poussoirs 
void loop() {

  
   bpplus = digitalRead(10);         
    if (bpplus == 0){
        PWM--;
    if(PWM <=175 ){PWM = 175;}
        while(!digitalRead(10));
                    }
    
    bpmoins = digitalRead(11);          
    if (bpmoins ==0){
        PWM++;

      if(PWM >= 255  ){
        PWM =255 ;
        }
        while(!digitalRead(11));
  }
  
  N=analogRead(A3);         // lecture du courant sur la broche A3
  I = (N*1.1)/1024;          // 1,1 ==> 2^10 car le convertisseur AN est codé sur 10 bits  
  analogWrite(6,PWM);      // écriture de la valeur de la PWM sur la broche 6 
  Serial.print(PWM);  
  Serial.print(",");
  Serial.print("I=");Serial.println(I,5);
}

On relève alors la valeur du courant sur la broche A3.
Remarque : La commande " analogReference(INTERNAL)" permet de mettre la tension de référence à 1.1V
Le convertisseur analogique numérique de l'Arduino est codé sur 10 bits. Pour obtenir la valeur de notre courant on effectue donc le calcul suivant : (valeur_analogique.1.1)/1024

Les résultats sont les suivants :

PWM Courant
239 0.00215
210 0.03545
185 0.06016

Problème : Arrivé à une certaine valeur de la PWM, la valeur du courant devient imprécise à cause des perturbations engendrées par la bobine du montage.

On va donc utiliser un filtre numérique pour supprimer ces perturbations :

#include <TimerOne.h>

boolean ETAT = true;

bool bpplus;

bool bpmoins;

int PWM = 255;

float N; // valeur numérique de I

float I,I_corrige; // intensity

  

float entree=0;

float entree1=0;

float entree2=0;

float sortie=0;

float sortie1=0;

float sortie2=0;

float out=0;

const float fe = 400;

const float fc = 10;

float a1;

float a2;

const float b1 =2;

const float b2 =1;

float denominateur;

float Gain;

  

void setup() {

Serial.begin(57600) ;

pinMode(10,INPUT_PULLUP); // -- PWM ==> intensité lumineuse ++

pinMode(11,INPUT_PULLUP); // ++ PWM ==> intensité lumineuse --

pinMode(6, OUTPUT); // sortie PWM

pinMode(2, OUTPUT);

Serial.println("depart");

// TCCR0B = (TCCR0B & 0b11111000) | 0x01; // ligne néccesaire pour que la simulation ISIS ne plante pas 1 : (64KHz)

denominateur=(fe*fe+fe*fc*PI*sqrt(2)+fc*fc*PI*PI);

a1=(fc*fc*PI*PI-fe*fe)*2/denominateur;

a2=(fe*fe*fe*fe+(fc*fc*fc*fc*PI*PI*PI*PI))/(denominateur*denominateur) ; //pow(base, exponent)

Gain=(1+2+1)/(1+a1+a2);

  

analogWrite(6,255); //initialisation de la PWM à la valeur 255

analogReference(INTERNAL) ; //1.1V tension de refenrence inernal

}

  
  

////////////// variation de la PWM en fonction de 2 boutons poussoirs

void loop() {

ETAT = !ETAT;

if(ETAT == true){

digitalWrite(2,LOW);

}else if(ETAT == false){

digitalWrite(2,HIGH); // calcul du temps du programme pour determiner la valeur de la fréquence d'échantiollonnage

}

  

N=analogRead(A3); //convertisseur 10 bits sous 5V

I = (N*1.1)/1024;

  

entree2=entree1; //entree(n-2)

entree1=entree;

entree = I;

sortie2=sortie1; //sortie(n-2)

sortie1=sortie; //sortie(n-1)

sortie=(entree+entree1*b1+entree2*b2-sortie1*a1-sortie2*a2) ;

out=(sortie/Gain);

I_corrige = out;

//Serial.print("I=");

Serial.print(I*10,3);Serial.print(",");

//Serial.print("I_cor=");

Serial.print(I_corrige*10,3);Serial.println(',');

bpplus = digitalRead(10);

if (bpplus == 0){

PWM=PWM-10;

//if(PWM <=175 ){PWM = 175;}

while(!digitalRead(10));

}

bpmoins = digitalRead(11);

if (bpmoins ==0){

PWM= PWM + 10;

  

//if(PWM >= 255 ){PWM =255 ;}

while(!digitalRead(11));

}

analogWrite(6,PWM); // écriture de la valeur de la PWM sur la broche 6

// Serial.print(PWM);
}

Un topic sur les filtres à déjà était réalisé : Filtre numerique RII, RIF….digital filter...FFT...atmega328, ESP32

La période d'échantillonnage dépend de la dure d'une cycle entier de notre programme. Pour connaitre la durée total de notre programme on fait un toggle en entrée et en sortie de la loop puis on observe avec l'oscilloscope ISIS la durée de celle-ci.
On trouve une durée de 2.5ms ==> Fe = 400 Hz
On choisit une fréquence de coupure de 10Hz. Cette valeur dépend du théorème de Shannon : Fe > 2Fmax
Dans notre cas, on prend Fe = 10.Fmax.

Après avoir ajouté le filtre dans notre programme, on observe le courant sur le terminal Arduino :


La courbe en bleu correspond au courant sans filtre. En rouge, il s’agit du courant filtré. On remarque que le courant est beaucoup plus stable en sortie du filtre. Le filtre est donc fonctionnel.

On peut maintenant connaitre la valeur du courant en fonction de la PWM :
PWM

PWM Courant
245 0.05
215 0.2
145 0.31
115 0.35
95 0.48

**Perspectives d'études : **
Il reste maintenant à faire la boucle fermer afin que l'intensité des LED ne diminue pas lorsque la batterie diminue.

2 Likes

Vu que je ne pouvais insérer plus de 3 photos dans le forum, j'ai finalement fait un dossier word dont le lien est ci-dessous.

Vous allez y trouver une partie des programmes ainsi que des questions théoriques.

1 Like

hello, c'est quoi ce lien........................??? on ne sait pas ce qu'on télécharge.

je quitte.

On attend les résultats !!

Suite à la récupération d’une matrice de (12 leds séries et 8 parallèles)*3 parties indépendantes donc 288 leds cob au totale sur un support souple monté sur une plaque d’aluminium

Voici l’éclairage en fonction de la consommation

L’objectif a été d’utiliser cette matrice de led rouge sur un vélo électrique qui a une batterie LFP 24S dont la tension varie de 88V à 60V.

Donc les 3 parties indépendantes ont été mises en série pour avoir une tension de seuil autour de 60V.

Etant donné que le courant est faible, une résistance de limitation a été utilisé pour avoir un courant d’environ 50mA à 80V.

Arduino fait juste le clignotement de la matrice de la led via un transistor pour mieux interpeller et minimiser la chaleur pour augmenter l’efficacité lumineuse

Il faut juste un régulateur de tension 5V pour alimenter l’Arduino qui permet d’avoir une alimentation USB de 3A pour charger un smartphone

Voici le schéma électrique qui est très simple car il n’y a pas de régulation, ni d’hacheur

Voici le programme qui est très simple

//#include <SoftwareSerial.h>
//#include <TimerOne.h>
#include <avr/wdt.h>      //https://passionelectronique.fr/watchdog-arduino/


int  temps;

void setup() {
pinMode(6, OUTPUT);      //PWM
pinMode(13, OUTPUT);      //  led

Serial.begin(9600);        //
  // TCCR0B = (TCCR0B & 0b11111000) | 0x01;      //pin 5 et 6  64khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet
  // TCCR0B = (TCCR0B & 0b11111000) | 0x02;  // 7812 Hz    60mA
  //  TCCR0B = (TCCR0B & 0b11111000) | 0x03;  //1000Hz 
wdt_enable(WDTO_2S);  
}  // fin setup 

void loop() {
//temps++, 
//Serial.println(temps); 
digitalWrite(6,1);digitalWrite(13,1);      
//analogWrite(6,PWM);   //PWM 8 bits   donc 255 rapport cyclique= 1 et 127 =duty cycle 0.5
delay (100);
wdt_reset();
digitalWrite(6,0);digitalWrite(13,0);  
delay (1000);


} // fin loop  

Bizarre le clignotement des leds est perçu avec une rémanence différente pour des leds de 3Watt, led faibles puissance inferieure 0.2W et les matrice cob…)

Au début, on a cru que chaque type led avait un condensateur non négligeable et que l’éclairage augmentait doucement et s’éteignaient avec la même constante de temps de 0.1s environ.

Donc, on a mis un capteur de lumière TEMT 6000 sur un oscilloscope à 25cm de l’éclairage.

Mais il n’y a pas de constante de temps des leds comme on peut l’observer sur la figure suivante


Donc, c’est bien un problème de perception humaine

Donc, a dû mettre 200ms allumé et 1seconde éteint ce qui permet d’abaisser l'incrément de température de (1s/0.2s=5) plus faible par rapport à l’incrément de température en continu du tableau.

cet eclairage est tres performant et il est tres facile à realiser et à mettre en oeuvre.

Les batteries des vélos électriques vendus dans le commerce sont souvent en 36V avec une sortie électrique de 12V pour l’éclairage. Une sortie 5V pour l’éclairage aurait pu être utilisé et aurait pu servir pour le smartphone.