Arduino Forum

International => Français => Réalisations et Projets Finis => Topic started by: iutgeiisoissons on Jan 16, 2019, 03:12 pm

Title: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Jan 16, 2019, 03:12 pm
Voici une publication pour les choix de la programmation d'un éclairage arrière de 3W avec Arduino qui reprend toutes les problématiques de ce post
https://www.fichier-pdf.fr/2019/03/06/arduino--led-eclairage-velo-v2/


https://www.fichier-doc.fr/2019/03/11/iut-geii-soissons-2019-arduino-regulation-led-v2-sivert/


Les leds de puissance doivent être régulé en courant par l'intermédiaire d'un hacheur
Voici 2 articles scientifiques qui en parlent
http://www.fichier-pdf.fr/2017/06/14/eclairage-velo-revue-2017-light-bike/
http://www.fichier-pdf.fr/2017/06/14/led-regulation-hystereris-eclairage-pour-velo/
https://docplayer.fr/65126810-Convertisseur-regulateur-de-led-blanche-de-10-a-100w.html


Sur ce forum, il est possible de commander tous les éléments pour créer son éclairage
http://velorizontal.bbfr.net/t16874p525-eclairage-a-del-pour-velo-led-light-for-bike-light-emitting-diode

Dans un premier temps, nous allons voir comment gérer un éclairage arrière qui est constitué d'une led principale de 3W et de 3 petites leds de 0.1W.
Un BP poussoir permet de gérer les différentes puissances et le clignotement par une routine d'interruption extérieure.  Ce BP permettra de mettre en veille et reveiller l'Arduino.
Un afficheur LCD est utilisé juste pour verifier la programmation.
2 batteries 2.5A.H série 18650 seront utilisées pour alimenter la carte Arduino et le hacheur qui fera varier le courant dans la led.
L'affichage de l'état de charge  SOC (state of charge) est déterminé approximativement en fonction de la tension OCV (open circuit voltage) par linéarisation.

Avec la pente a et b correspondant à l'équation suivante sachant que pour Umax=8.4V le  SOCmax sera de 100% et pour Umini=6V pour SOCmini de 5%:

(https://i89.servimg.com/u/f89/17/56/35/17/a131.jpg) (https://servimg.com/view/17563517/5776)


Un capteur de température LM35 permettra de diminuer de mode, si la température du dissipateur de la led devient trop grande à cause de la température ambiante.


On peut observer sur la figure suivante la liste des entrées sorties et la simulation sous ISIS qui est telechargeable sur ce lien.

https://drive.google.com/open?id=16xHdWM1WZgy7pqlgEqLEWeQsasbsGW7F

(https://i89.servimg.com/u/f89/17/56/35/17/a221.jpg) (https://servimg.com/view/17563517/5775)

Voici l'Algo pour gérer la led de 3W
Code: [Select]

Routine interruption toutes les 1ms qui permet de gérer le temps

Routine d'interruption extérieur par le bouton poussoir active les diffèrent mode de 0 à 6.
Mode 0 :  (0A)
Mode 1 : régulation de courant led P 0.35A (0.75W) mais clignotement de toutes les leds avec une période de 1s et un rapport cyclique de 0.4.
Mode 2 : régulation de courant  led P 0.7A (1.5W) avec clignotement
Mode 3 : régulation de courant led P  1.4A  (3W) avec clignotement
Mode 4 : régulation de courant led P 0.35A (0.75W) sans clignotement
Mode 5 : régulation de courant  led P 0.7A (1.5W) sans clignotement
Mode 6 : régulation de courant  led P 1.4A (3W) sans clignotement

Main
Tous les 100ms
Affichage du courant de consigne
Mesure du courant et réajustement de la PWM pour avoir le courant désiré
Mesure de la tension de 2 batterie lithium série dont la tension varie de 8.4V (100% chargé) à 6V (0% de charge)
Affichage de l'état de charge avec 4 leds
Mesure de la temperature
Si la température est supérieure à une certaine temperature minimisation de puissance


le programme en Piece Jointe


Perspectives :
Pour préserver la durée de vie de la batterie
Lorsque l'état de charge sera inférieur à  40% alors le mode 4 sera activé
Lorsque l'état de charge sera inférieur à 30% alors le mode 1 sera activé
Lorsque l'état de charge sera inférieur à 10% alors l'éclairage sera éteint et l'Arduino en veuille.


Utilisation d'un mode veuille, pour minimiser la consommation de l'Arduino lorsque l'éclairage n'est pas activé pour ne pas mettre d'interrupteur entre l'Arduino et la batterie.
https://pandauino.com/fr/comment-economiser-lenergie-dune-carte-arduino/


Gérer un accéléromètre qui détectera si le vélo ne bouge plus et dans ce cas au bout de 2 minutes, il éteindra la lumière et se mettra en veuille
un capteur MPU6050 pourra etre utilisé
https://www.instructables.com/id/MPU6050-Arduino-6-Axis-Accelerometer-Gyro-GY-521-B/

Réguler le courant de 3 leds rouge à 0.2W pour avoir une puissance lumineuse constante et ne plus avoir de perte d'énergie dans la résistance de limitation de courant R3.


le driver CH340 de nos arduinos peut etre telechargé ici
http://www.wch.cn/download/CH341SER_EXE.html
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: iutgeiisoissons on Jan 28, 2019, 09:46 pm
Pour un courant led de 3A, la puissance utile dans une led blanche qui a une tension de seuil de 3V
P=tension de seuil*Iled=3V*3A=9W

Pour ce  courant de 3A,  les pertes dans le transistor bipolaire PNP TIP127
P=Vce sat*Iled*PWM=1V*3A*0.5=1.5W   sachant que la PWM varie en fonction de la tension de la batterie
La puissance dans le diode de roue libre est egale à l'equation suivante
P=Ud seuil*Iled*(1-PWM)=0.3V*3A*(1-0.5)=0.45W  

Ces 2 puissances sont relativement important par rapport à la puissance utile dans la led.

Donc, pour ameliorer les performances du hacheur, pour augmenter l'autonomie de l'eclairage et  pour minimiser l'encombrement des dissipateur, un transistor MOS surdimensionné a été choisi

En appliquant filtres dans farnell, le transistor  FDD4243 a été choisi en fonction de son prix faible et de ces performances
https://fr.farnell.com/on-semiconductor/fdd4243/mosfet-canal-p-40v-14a-to-252/dp/2323170

Le FDD4243 pouvant supporter 23A avec une résistance RDS on=0.036Ω  pour 0.25€ boitier CMS TO252.
La résistance thermique jonction ambiant d'un boitier to252 simple couche est de 132°C/W
http://rohmfs.rohm.com/en/products/databook/applinote/ic/power/linear_regulator/to252-3_rth_bd4xxm5fp_an-e.pdf
Donc la puissance max dissipable sans dissipateur
Pdissipable=(TJontoin max-Tambiante)/RTHja=(150-25)°C/ 132°C/W)=1Watt
Avec une surface de cuivre de 200mm^2, alors la resistance RTHJA=70°C et permettra de dissiper 2W.

Alors qu'un boitier TO220 a une résistance thermique environ 62°C/W aurait été plus facile à utiliser mais le prix minimum est de 0.85€ pour le transistor IRF9540.

https://fr.farnell.com/infineon/irf9540npbf/trans-mosfet-canal-p-to-220-100v/dp/8648620?MER=sy-me-pd-mi-alte

Mais quel est la puissance que devra dissiper le transistor ?
La puissance théorique  perdue dans ce transistor FDD4243 sans prendre en compte les pertes à la commutation
P=Rds on*Iled^2* PWM =0.12*3A^2*PWM =1.35W,    il faudra
Les pertes à la commutation théorique sont négligeables comme on peut l'observer sur la figure suivante
P=Ubattery* Iled*(trise+tfall)*FrequenceHachage/2=8V*3A*(26+14)*10^-9*32khz/2=0.015W


Le choix de la diode Switch-mode Power Rectifier ,

MBRS320T3G supportant 4A en boitier    DO-241 à 0.14€ pourrait etre utilisé.
https://fr.farnell.com/w/c/semiconducteurs-composants-discrets/diodes/diodes-schottky/prl/resultats?courant-if-moy-=4a&st=diode%204A&sort=P_PRICE

Mais une MBRD835LT4G supportant 8A en boitier    TO-252 à 0.2€ est plus pertinent car elle chauffera moins
http://www.farnell.com/datasheets/2353974.pdf?_ga=2.243937932.867156930.1548826576-1436130221.1548826576&_gac=1.251268402.1548832333.EAIaIQobChMIrIvPhvqU4AIVSIXVCh3j6wdsEAAYASAAEgLzqvD_BwE

Avec le transistor MOS, le courant dans la led, n'est plus le meme en fonction de la PWM.
Un réajustement des valeurs du correcteur integral a du etre fait.

Pour la mise en veuille, on a utilisé la bibliothèque low-power,
https://github.com/rocketscream/Low-Power
Le réveil se fait par interruption extérieur en mode 5.
Mais, pour réactiver le timer1, on a du faire un reset par l'intermédiaire de la biblioteque wachdog avr/wdt.h.
on aurait pu aussi réactiver le timer1, en faisant un reset par l'intermédiaire de la sortie A5 q

L'algorithme  a donc changer

Code: [Select]



Timer1 Routine interruption toutes les 1ms qui permet de gérer le temps

Routine d'interruption extérieur par le bouton poussoir active les diffèrent mode de 0 à 5.
Mode 1 : régulation de courant led P 0.35A (0.75W) mais clignotement de toutes les leds avec une période de 1s et un rapport cyclique de 0.4.
Mode 2 : régulation de courant  led P 0.7A (1.5W) avec clignotement
Mode 3 : régulation de courant led P  1.4A  (3W) avec clignotement
Mode 4 : mode 4
Mode 5 : reset

Main
Si mode 4 mise, arret PWM et mise en veuille de l'arduino

Tous les 100ms
Affichage du courant de consigne
Mesure du courant et réajustement de la PWM pour avoir le courant désiré
Mesure de la tension de 2 batterie lithium série dont la tension varie de 8.4V (100% chargé) à 6V (0% de charge)
Affichage de l'état de charge avec 4 leds
Mesure de la temperature
Si la température est supérieure à une certaine temperature minimisation de puissance


un lien pour telecharger  le fichier ISIS
https://drive.google.com/open?id=16xHdWM1WZgy7pqlgEqLEWeQsasbsGW7F

(https://i89.servimg.com/u/f89/17/56/35/17/a142.jpg) (https://servimg.com/view/17563517/5818)



Perspectives :


Si la connaissance de l'état de charge des batteries est facilement déterminée pas la tension avec les éléments 18650 li-ion, ce n'est pas possible de le faire avec des batteries Lipofer car la tension reste constante malgré la diminution du SOC
Par conséquent, la consommation du courant doit être déterminée (A.h). Or dans ce cas, la résistance de mesure du courant dans la led doit se faire mais aussi celle absorbée par l'Arduino.
Donc, la mesure du courant doit se faire avec une résistance shunt sur l'alimentation avec des ponts diviseurs à la place de le faire sur la masse.

Il est serait idiot que l'Arduino gère la charge des 2 batteries.
En effet, Le chargeur extérieur étant limité à 1A avec une tension identique à la tension seuil des 2 éléments donc 8.4V, donc ce n'est pas valable de réguler le courant de charge avec l'Arduino.
De plus, un BMS est obligatoire pour d'équilibrer les 2 cellules, mais aussi arrêter l'alimentation du système si la batterie est trop déchargée pour ne pas la détruire

Attention avec le programme suivant, si les 3 leds sont commandé par la PWM broche 11 et si leur puissance lumineuse peut varier grâce à la PWM, il y a toujours les pertes dans la résistance R3 de limitation de courant. Pour ne plus avoir ces pertes, il faut obligatoirement réaliser un hacheur abaisseur.

En mode 3, ou la puissance de la led est la plus importante, à la place de réguler le courant à 1.5A, il serait possible de réguler la température à 90°C ce qui permettrait d'avoir la puissance lumineuse

Mais tous ceux-ci seront d'autres histoires….



Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: hbachetti on Jan 29, 2019, 11:41 am
Salut.

Aurais-tu un schéma plus précis ?
Dans ton code je vois que tu utilises la référence VCC pour la mesure de la batterie. Je suppose que tu alimentes l'ARDUINO à travers un régulateur ?

Question : pourquoi une NANO alors qu'une PRO MINI serait bien plus économe en énergie ?

@+
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: iutgeiisoissons on Jan 30, 2019, 09:33 am
la batterie alimente directement la tension Vin de l'arduino par l'intermédiare du regulateur interne de l'arduino LM2940 fournit le 5V.

j'ai modifié le programme dans le post précedent et isis....
et ajouté,  un lien pour telecharger  le fichier ISIS

Nous avons utilisé l'arduino nano, car nous en avions d'avance……

Mais très bonne idée, dans la version finale d'utiliser la version pro mini que je ne connaissais pas….
Car la différence de consommation entre le pro mini et l'Arduino nano….doit etre de 15mA car  le pro mini n'a pas le convertisseur USB RS232
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: hbachetti on Jan 30, 2019, 11:22 am
Quote
Car la différence de consommation entre le pro mini et l'Arduino nano….doit etre de 15mA car  le pro mini n'a pas le convertisseur USB RS232
Exactement.

J'ai réuni pas mal d'infos ICI (https://riton-duino.blogspot.com/2018/02/arduino-pro-mini-basse-consommation.html) au sujet de la PRO MINI :
- réduction de la consommation
- mode veille
- chargement
- etc.
Il y a des versions 5V ou 3.3V.
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: iutgeiisoissons on Feb 01, 2019, 06:05 pm
Génial, le site et la consommation, superbe travail
https://riton-duino.blogspot.com/2018/02/arduino-pro-mini-basse-consommation.html

si j'ai bien compris, la carte arduino et mini peuvent fonctionner sans regulateur de 1.8V à  5.5V donc sur la plage de  tension dune  batterie lithium  qui varie de 4.2V à 3.3V. et cela permet de minimiser la consommation car le regulateur demande 5mA.
Dans ce cas, les 2 batteries lithium ion 18650 devrait etre mis en  //.
Par contre, il va falloir utiliser une tension de reference pour la Conversion analogique si la tension d'alimentation change.
il faut changer de capteur de temperature LM35 qui a besoin de 4V minimum par une PT1000

Suite aux perspectives précédentes, la led peut être commandé en régulation de température ce qui permet de la commander pour le maximum de sa puissance.

Le schéma automatique de la régulation de courant  qui s'imbrique dans la regulation de température est le suivant :
(https://i89.servimg.com/u/f89/17/56/35/17/a229.jpg) (https://servimg.com/view/17563517/5821)

Exemple : La consigne de température maximum du dissipateur a été  choisi de 100°C sachant le dissipateur ou est placé la led est de 15°C/W à 0km/h mais passe à 7°C/W avec une vitesse de 20km/h.
Donc avec une température ambiante de 25°C, la puissance maximale dans la led en fonction de la vitesse sera de
Pmax=(100°C-25°C)/15°C/W=4.33W    à la vitesse de 0 km/h
Pmax=(100°C-25°C)/7°C/W=10W    à la vitesse de 20 km/h

La température de jonction de la led avec sa résistance thermique de 3.5°C/W sera de
Tjonction=Tboitier+ Pmax*RTHjc=100°C+10W*3.5=135°C
Mais la température de jonction peut atteindre 150°C/W

La régulation de température n'est pas trop compliquée à programmer.
Par contre, le coefficient intégral est à modifier par rapport à celui du courant.
Car si la température de la led est au départ de 30°C pour atteindre les 100°C alors la Puissance admissible par la led precedente sera tres vite dépassé.
Il faut donc limiter le courant à une certaine valeur pour ne pas detruire la led car la regulation precedente augmentera inutilement la PWM, aisni que le courant



voici le code de la programmation
Code: [Select]

#include <LiquidCrystal.h>
//#include <SoftwareSerial.h>
#include <TimerOne.h>
#include <avr/wdt.h>   //chien de garde
//#include <avr/power.h>   //mise en veille
//#include <avr/sleep.h>
#include "LowPower.h"     //https://github.com/rocketscream/Low-Power



#define led0     10       //
#define led1     A4       //
#define led2     12       //
#define led3     13       // 13      
#define BP3        2       //
#define battery    A0      //relay magnetron



LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables


unsigned    int temps=0;    //temps de la routine d'interruption
            byte  temps1=0;
            byte mode=1;    // etat du bouton poussoir
            float Ic=0.35;   // courant de consigne
            float Ba=0;   //tension batterie
            byte SOC=0;  //etat de charge en pourcentage
            byte barreled=0;    
            byte PWM=0;  
            float I=0;   //courant led principal
            float erreur=0;   //courant led principal
            float kp=10;        //coefficient proportionel integral
            float ki=4;
            float Integral=34;
float   T=0;     //temperature
float   Tc=80;   //consigne de temperature
float  erreurT=0;



// the setup function runs once when you press reset or power the board
void setup() {
//  digitalWrite(A5,HIGH);
//   delay(200);

 
pinMode(led0, OUTPUT);   //
pinMode(led1, OUTPUT);   //
pinMode(led2, OUTPUT);   //
pinMode(led3, OUTPUT);   //led carte arduino
pinMode(3, OUTPUT);      //PWM
pinMode(11, OUTPUT);      //PWM


  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
  lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
 // Serial1.begin(9600);

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 10  32khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet
                                            

  pinMode(2, INPUT);
  attachInterrupt(digitalPinToInterrupt(2), interBP, LOW);   //routine d'interruption exterieur broche 2
//wdt_enable(WDTO_15MS);
}



// Interruptions  tous les 0.001s fait par le timer1***********************************
void callback()  {
temps++;

  //if ( digitalRead(LEDV)== 1 ) {digitalWrite(LEDV,LOW);}  else {digitalWrite(LEDV,HIGH);}
//wdt_reset();
}//fin routine


//interruption exterieur
void interBP() {
//interrupts();

mode++;                  //incrementation des modes
if (mode>=6) mode=1;

  switch (mode) {
  case 1:Ic=0.35;Integral=34;   break;   //donne un ordre de grandeur de la valeur de la PWM=255*(Rshunt*Ic-Useuil)/Ubattery
  case 2:Ic=0.75;Integral=43;   break;
  case 3:Tc=80;Ic=1.5;   break;
  case 4:analogWrite(3,0); analogWrite(11,0);digitalWrite(led0,LOW);digitalWrite(led1,LOW);digitalWrite(led2,LOW);digitalWrite(led3,LOW);  break; //puis mise  en veuille
  case 5: wdt_reset();    break;   //remise à zero    https://www.instructables.com/id/two-ways-to-reset-arduino-in-software/
     }
                              
   }


///////////////////////////////////////////// Boucle correspondant à la fonction main
void loop() {  


if (mode==4)  {lcd .clear ();LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);}
           //   LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
           //mode veuille



if (temps>1)         //affichage tous les 100ms
{
Ba=analogRead(A0);     //mesure tension
Ba=Ba/79;              //
SOC=40*Ba-233;    // cacul de l'etat de charge
lcd.setCursor(0,1);   //colonne, ligne
lcd.print("SOC");
lcd.print(SOC);
barreled=(SOC/18)-1;    

  switch (barreled) {
  case 0:digitalWrite(led0,LOW);digitalWrite(led1,LOW);digitalWrite(led2,LOW);digitalWrite(led3,LOW);     break;               //valeur deu courant dans la led principale
  case 1:digitalWrite(led0,HIGH);digitalWrite(led1,LOW);digitalWrite(led2,LOW);digitalWrite(led3,LOW);   break;
  case 2:digitalWrite(led0,HIGH);digitalWrite(led1,HIGH);digitalWrite(led2,LOW);digitalWrite(led3,LOW);   break;
  case 3:digitalWrite(led0,HIGH);digitalWrite(led1,HIGH);digitalWrite(led2,HIGH);digitalWrite(led3,LOW);   break;
  case 4:digitalWrite(led0,HIGH);digitalWrite(led1,HIGH);digitalWrite(led2,HIGH);digitalWrite(led3,HIGH);   break;          }

I=analogRead(A1);
I=I/102;
lcd.setCursor(7,1);
lcd.print("I=");
lcd.print(I,1);

  
T=analogRead(A2);   //mesure temperature
T=T/2;
lcd.setCursor(13,1);
lcd.print(T,0);
lcd.print(" ");

if ((T>90) && (mode==2)) {erreurT=Tc-T; Ic=Ic+erreurT*0.05;}    //diminution du courant si la temperature atteint 90°C
if (mode==1 || mode==2 )  {lcd.setCursor(0,0);lcd.print("I"); }    //limitation du courant à cause de la  temperature
 
              
if (mode==3) {erreurT=Tc-T; Ic=Ic+erreurT*0.05 ;lcd.setCursor(0,0);lcd.print("T");}  // regulation temperature
if (Ic>=2) {Ic=2; }             // limitation du courant de la consigne
if (Ic<=0.35) {Ic=0.35; }      

lcd.setCursor(1,0);
lcd.print(Ic);
erreur=Ic-I;

//Proportionnel=kp*erreur;
//derive=(erreur-erreurP)*kd;             //derive=(erreur-erreur*Z^Ts)/Ts   avec Ts=Tsampleur
//output=Proportionnel+Integral;   //ce n'est pas la peine de divisée par Ts car si Ts est petit cela donne des valeurs enormes
Integral= Integral+erreur*ki;
if (Integral>=255) Integral=255;
if (Integral<=0) {Integral=0;}
PWM=Integral;
if (Ic==0) {PWM=0;}  

lcd.setCursor(7,0);
lcd.print("PWM=");
lcd.print(PWM);
lcd.print("  ");
analogWrite(3,PWM);    //broche et valeur PWM
//analogWrite(11,127);


temps1++;
if (temps1<2)  {analogWrite(11,255);          }
if (temps1>2)  {analogWrite(11,0);temps1=0;   }
              


temps=0;
}//temps>100

  
} // fin loop  








Perspectives :


On pourrait aussi faire un mode qui gere l'eclairage en fonction de la lumière extérieure en mettant un capteur LDR sur le dessus de l'éclairage.
En effet en plein jour cela permettrait de couper l'éclairage. Attention, parfois on veut meme en plein jour ce faire voir. Donc, il faut garder les anciens modes.

Maintenant que le programme est effectué l'afficheur LCD peut etre retiré.
Etant donné que l'on a plus des sorties non utilisées,  les 8 leds du barled pourraient etre utilisées sachant que leur consommation est dérisoire par rapport à la led de puissance

De plus à la place du LCD, la liaison serie pourrait exporter les dynamiques de la regulation de courant et de temperature pour optimiser la commande.

Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: hbachetti on Feb 02, 2019, 03:06 pm
Quote
il faut changer de capteur de temperature LM35 qui a besoin de 4V minimum par une PT1000
PT1000 c'est surdimensionné.
DS18B20 plutôt (-55°C à +125°C et 3.0V - 5.5V) ?

Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: iutgeiisoissons on Feb 21, 2019, 05:26 pm
Bonne idée pour le DS18B20 mais en boitier TO92 ce n'est pas idéal ni en 8 pin So. Prix plus cher qu'une PT1000 qui est de l'ordre de 1€
(https://i89.servimg.com/u/f89/17/56/35/17/a326.jpg) (https://servimg.com/view/17563517/6049)
La PT1000 est assez facile d'utilisation, par rapport aux circuits intégrés mais consomme tout le temps 0.7mA sous 4.1V.
Alors que DS18B20 consomme 1 mA lorsqu'il est actif et 0.0001mA en standby. Mais il faudrait faire un test.

Etant donné que la tension de référence 5V n'existe plus. L'utilisation de la référence interne 1.1V sera utilisée. Donc, il faut changer aussi le pont diviseur
analogReference(INTERNAL) ;   //1.1V tension de référence internal        
La résistance shunt de mesure de courant passe à 0.1 ohms, ce qui permet d'avoir moins de perte de puissance.

Donc, pour minimiser la consommation, la broche A3 en sortie numérique sera utilisée pour alimenter les 2 ponts diviseurs sachant que la chute de tension dans les transistors interne de l'ATMEL  est négligeable.
La PT 1000 est linéaire et vaut 1346 ohms à 100°C
Mais la tension fournie par la mesure de température, va varier en fonction de la tension de la batterie mais comme cette tension est mesurée, cela se corrige mathématiquement
L'équation pour la PT1000, T=(A2-816*Ba/5)/(0.48*Ba)  
avec Ba correspondant à la tension de la batterie.

Voici les nouvelles valeurs du schéma électrique
Lors de la simulation la sortie A3 sera de 5V et pas à la valeur de la tension Vin malheureusement.
Attention, il faut obligatoirement mettre VCC sur 5V sur l'Arduino, les convertisseurs de l'Arduino nano de la simulation du programme ne fonctionnent pas.

Le coefficient du programme de la mesure de tension change, ainsi que l'état de charge
Ba=A0/221;              //4.2V*pont diviseur=1V   1*1023/(1.1V*4.2)=221
SOC=79*Ba-232;    // calcul de l'état de charge.
Le coefficient de la mesure de courant change aussi est passe à I=A1/93

le shema de simulation est telechargeable sur ce lien
https://drive.google.com/open?id=1uhA8GpavQT-Ov3SpcyT3Rqr05n0EuWH9

(https://i89.servimg.com/u/f89/17/56/35/17/a147.jpg) (https://servimg.com/view/17563517/6064)

Réalisation du typon
Proteus (ISIS et ARES) n'a pas les packages de l'Arduino nano….Donc, il faut le créer et le voici  il sur mon drive et ainsi que mes librarys car j'ai du réalisé de nombreux composants  qui faudra mettre dans la Library  userpkg et userdevice


Le schéma du typon n'est pas identique à celui de simulation donc le voici aussi téléchargeable

Le fichier du typon de l'eclairage
https://drive.google.com/file/d/1NGjCxoRsMxuMwiFWGkKO1xVeSQM2Rhdh/view?usp=sharing
mes differentes  library et le cours ISIS ARES peuvent etre retrouvé ici
https://drive.google.com/drive/folders/0B_fB3GAsM02FfkRxVFRzVG8zeU52QkZ3cFR4RFRRS3NQakRQZnpvaDBBVElkZExQMkxPSWc?usp=sharing



(https://i89.servimg.com/u/f89/17/56/35/17/a236.jpg) (https://servimg.com/view/17563517/6063)

Pour ne pas avoir de fil à souder, toute l'électronique doit s'emboiter.
- La Première carte est l'Arduino évidement
- La Deuxième carte est le  hacheur
- La Troisième carte est pour la led d'éclairage, la band graph, le Bouton poussoir et le capteur de température.
(https://i89.servimg.com/u/f89/17/56/35/17/a328.jpg) (https://servimg.com/view/17563517/6065)

Une inductance 0.1mH/3A en CMS (IDP1451 128x550    INDC3225X135   BOBINE05MH) est assez grosse donc cela ne vaut pas être pas trop le cout de mettre des  transistors et diode CMS à plat….autant mettre les composants debout en boitier T0 220
Pour un prototype, mettre des composants à trous est plus facile si l'on doit changer quelques composants.

Perspectives ;
Dans un futur, un nouveau typon avec que des composants CMS sera effectué, pour savoir si c'est cela prend moins de place ou pas.

Est-ce que la simulation du programme fonctionne avec la version Pro mini avec la tension Vin ?


Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: hbachetti on Feb 21, 2019, 05:53 pm
Quote
Mais la tension fournie par la mesure de température, va varier en fonction de la tension de la batterie mais comme cette tension est mesurée, cela se corrige mathématiquement
La référence interne varie aussi pas mal en fonction de la température.

Si ça peut aider : Alimenter un arduino sur pile ou batterie (https://riton-duino.blogspot.com/2019/02/alimenter-un-arduino-sur-pile-ou.html) :  7.1. Mesure
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: iutgeiisoissons on Feb 21, 2019, 07:12 pm
Super bien écrit ce blog et tres pedagogique
https://riton-duino.blogspot.com/
Mais, je suis un spécialiste des batteries, des chargeurs, régulations….par contre découvreur de l'Arduino
http://velorizontal.bbfr.net/t20802-bms-et-depannage-ou-maintenance-de-pack-de-batterie
D'ailleurs, j'ai bien avancé sur le programme et la réalisation du chargeur lithium mais je ne peux encore le mettre sur le forum Arduino car j'attends le résultat de mes étudiants.
https://forum.arduino.cc/index.php?topic=538070.0
En effet, j'utilise le forum comme départ avec mes étudiants et voir l'avancement des différentes possibilités de réalisation.

Entre 0 et 100°C, il y a environ 5% de variation de la tension de référence et même si la tension de refendre a une variation de 5%. Mais ce n'est pas très grave puisque le barographe est à 25% (avec ces 4 leds) et que la mesure du courant et de température ne sont pas à 10% près.
Nous avons un BMS

Avec la pro mini Malgré qu'il n'y ait pas la sortie A4 pour la led 1, le compilateur compile quand même
Là encore, la simulation des convertisseurs analogique numérique ne fonctionnent pas correctement si +5V, n'est pas à Vcc.
(https://i89.servimg.com/u/f89/17/56/35/17/a148.jpg) (https://servimg.com/view/17563517/6066)

En simulation, la nano ne peut lire la tension reference encore un bug de isis

Etant donné, qu'il n'y a plus que 2 batteries 18650 en //
La charge se fera par ce module
(https://i89.servimg.com/u/f89/17/56/35/17/b115.jpg) (https://servimg.com/view/17563517/6067)

Code: [Select]

#include <LiquidCrystal.h>
//#include <SoftwareSerial.h>
#include <TimerOne.h>
#include <avr/wdt.h>   //chien de garde
//#include <avr/power.h>   //mise en veille
//#include <avr/sleep.h>
#include "LowPower.h"     //https://github.com/rocketscream/Low-Power



#define led0     10       //
#define led1     A4       //
#define led2     12       //
#define led3     13       // 13     
#define BP3        2       //
#define battery    A0     



LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables


unsigned    int temps=0;    //temps de la routine d'interruption
            byte  temps1=0;
            byte mode=1;    // etat du bouton poussoir
            float Ic=0.35;   // courant de consigne
            float Ba=0;   //tension batterie
            byte SOC=0;  //etat de charge en pourcentage
            byte barreled=0;   
            byte PWM=0;   
            float I=0;   //courant led principal
            float erreur=0;   //courant led principal
            float kp=10;        //coefficient proportionel integral
            float ki=4;
            float Integral=150;
float   T=0;     //temperature
float   Tc=80;   //consigne de temperature
float  erreurT=0;



// the setup function runs once when you press reset or power the board
void setup() {
 
pinMode(led0, OUTPUT);   //
pinMode(led1, OUTPUT);   //
pinMode(led2, OUTPUT);   //
pinMode(led3, OUTPUT);   //led carte arduino
pinMode(3, OUTPUT);      //PWM
pinMode(11, OUTPUT);      //PWM
pinMode(1, OUTPUT);     
pinMode(A3, OUTPUT);
digitalWrite(A3,HIGH);


  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
  lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
 // Serial1.begin(9600);

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 10  32khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet
                                           

  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), interBP, LOW);   //routine d'interruption exterieur broche 2
//wdt_enable(WDTO_15MS);

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



// Interruptions  tous les 0.001s fait par le timer1***********************************
void callback()  {
temps++;

  //if ( digitalRead(LEDV)== 1 ) {digitalWrite(LEDV,LOW);}  else {digitalWrite(LEDV,HIGH);}

//wdt_reset();
}//fin routine


//interruption exterieur
void interBP() {
//interrupts();

mode++;                  //incrementation des modes
if (mode>=6) mode=1;

  switch (mode) {
  case 1:Ic=0.35;Integral=150;  digitalWrite(A3,HIGH);   break;   //donne un ordre de grandeur de la valeur de la PWM=255*(Rshunt*Ic-Useuil)/Ubattery
  case 2:Ic=0.75;Integral=170;   digitalWrite(A3,HIGH);   break;
  case 3:Tc=80;Ic=1.5;   digitalWrite(A3,HIGH);  break;
  case 4:analogWrite(3,0); analogWrite(11,0);digitalWrite(led0,LOW);digitalWrite(led1,LOW);digitalWrite(led2,LOW);digitalWrite(led3,LOW);digitalWrite(A3,LOW);  break; //puis mise  en veuille
  case 5: wdt_reset();    break;   //remise à zero    https://www.instructables.com/id/two-ways-to-reset-arduino-in-software/
     }
                               
   }


///////////////////////////////////////////// Boucle correspondant à la fonction main
void loop() { 


if (mode==4)  {lcd .clear ();LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);}
           //   LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
           //mode veuille






if (temps>100)         //100 affichage tous les 100ms
{
Ba=analogRead(A0);     //mesure tension
Ba=Ba/221;              //4.2V*pont diviseur=1V   1*1023/(1.1V*4.2)=221

if (Ba<3.2)  {mode=4;}   //mise en veuil car pas de BMS.

SOC=79*Ba-232;    // cacul de l'etat de charge
lcd.setCursor(0,1);   //colonne, ligne
lcd.print("SOC");
lcd.print(SOC);
barreled=(SOC/18)-1;   

  switch (barreled) {
  case 0:digitalWrite(led0,LOW);digitalWrite(led1,LOW);digitalWrite(led2,LOW);digitalWrite(led3,LOW);     break;               //valeur deu courant dans la led principale
  case 1:digitalWrite(led0,HIGH);digitalWrite(led1,LOW);digitalWrite(led2,LOW);digitalWrite(led3,LOW);   break;
  case 2:digitalWrite(led0,HIGH);digitalWrite(led1,HIGH);digitalWrite(led2,LOW);digitalWrite(led3,LOW);   break;
  case 3:digitalWrite(led0,HIGH);digitalWrite(led1,HIGH);digitalWrite(led2,HIGH);digitalWrite(led3,LOW);   break;
  case 4:digitalWrite(led0,HIGH);digitalWrite(led1,HIGH);digitalWrite(led2,HIGH);digitalWrite(led3,HIGH);   break;          }



I=analogRead(A1);
I=I/93;               //0.1ohms*1A=0.1V   0.1V*1023/1.1=93
lcd.setCursor(6,1);
lcd.print("I=");
lcd.print(I,2);

 
T=analogRead(A2);   //mesure temperature
T=T-814;
T=T/(0.48*Ba);
lcd.setCursor(13,1);
lcd.print(T,0);
lcd.print(" ");

if ((T>90) && (mode==2)) {erreurT=Tc-T; Ic=Ic+erreurT*0.05;}    //diminution du courant si la temperature atteint 90°C
if (mode==1 || mode==2 )  {lcd.setCursor(0,0);lcd.print("I");lcd.print(Ic,2);lcd.print(" "); }    //limitation du courant à cause de la  temperature
 
             
if (mode==3) {erreurT=Tc-T; Ic=Ic+erreurT*0.05 ;lcd.setCursor(0,0);lcd.print("T");lcd.print(Tc,0);lcd.print("  ");}  // regulation temperature
if (Ic>=2) {Ic=2; }             // limitation du courant de la consigne
if (Ic<=0.35) {Ic=0.35; }     

lcd.setCursor(1,0);
lcd.print(Ic);
erreur=Ic-I;

//Proportionnel=kp*erreur;
//derive=(erreur-erreurP)*kd;             //derive=(erreur-erreur*Z^Ts)/Ts   avec Ts=Tsampleur
//output=Proportionnel+Integral;   //ce n'est pas la peine de divisée par Ts car si Ts est petit cela donne des valeurs enormes
Integral= Integral+erreur*ki;
if (Integral>=255) Integral=255;
if (Integral<=0) {Integral=0;}
PWM=Integral;
if (Ic==0) {PWM=0;} 

lcd.setCursor(6,0);
lcd.print("PWM=");
lcd.print(PWM);
lcd.print("  ");
analogWrite(3,PWM);    //broche et valeur PWM
//analogWrite(11,127);


temps1++;
if (temps1<2)  {analogWrite(11,255);          }
if (temps1>2)  {analogWrite(11,0);temps1=0;   }
           
temps=0;
}//temps>100


   
} // fin loop 


Les BMS de protection d'une batterie S1 arrête la décharge à 2,75V, voir 2,5V.  Or, c'est un peu faible pour éviter des décharges profondes
(https://i89.servimg.com/u/f89/17/56/35/17/a329.jpg) (https://servimg.com/view/17563517/6068)
Par conséquent, on préféra s'en passer et si l'Arduino mesure une tension batterie  inférieure à 3.2V alors il devra se mettre en mode veuille.
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: hbachetti on Feb 21, 2019, 10:36 pm
Quote
Entre 0 et 100°C, il y a environ 5% de variation de la tension de référence et même si la tension de refendre a une variation de 5%. Mais ce n'est pas très grave puisque le barographe est à 25% (avec ces 4 leds) et que la mesure du courant et de température ne sont pas à 10% près.
Juste pour de l'affichage : en effet, pas très grave.

TP4056 : bon choix.

Quote
Les BMS de protection d'une batterie S1 arrête la décharge à 2,75V, voir 2,5V.  Or, c'est un peu faible pour éviter des décharges profondes
J'en ai déjà testé qui s'arrêtaient à 3V pile (9.05V pour un 3S (https://4.bp.blogspot.com/-6xpxT2sAcpA/W8Ifj0uQXII/AAAAAAAAAV4/69tjCQaoIX0kHBRiYxrne4pxCZbl4BywQCLcBGAs/s1600/battery-protection.jpg)).

Le test ICI (https://riton-duino.blogspot.com/2018/10/batteries-lithium-ion-recharge-en-serie.html)

Quote
https://forum.arduino.cc/index.php?topic=538070.0
Je vais me pencher dessus, surtout la partie NIMH.

Bonne continuation
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: hbachetti on Feb 21, 2019, 10:59 pm
Quote
J'en ai déjà testé qui s'arrêtaient à 3V pile (9.05V pour un 3S).
La carte que j'ai testé (https://fr.aliexpress.com/item/3S-11-1V-12V-12-6V-18650-Lithium-Battery-Protection-Board-Lipo-Li-ion-Battery-Charge/32801641331.html?spm=a2g0s.9042311.0.0.701b6c37HUMZiK) :

Over discharge protection : 2.5V typiques.

Il y a certainement une erreur de la part du vendeur.
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: iutgeiisoissons on Mar 06, 2019, 09:54 am
En mode veuille avec 5micro ampère, l'autonomie théorique avec 100% de charge est de 33 333Jours avec 2 éléments 18650.
Temps=2A.H*2/(5*10^-6*24h)=33 333Jour
Si l'éclairage se met en mode veuille lorsque 20% restante d'énergie, Le temps de décharge pour atteindre les 100% de la batterie sera de 6666 jours.

Mais une autre solution que le bouton poussoir avec le mode veuille est possible :
C'est un interrupteur sur l'alimentation.
Cet interrupteur devra changer de mode de puissance de la led à chaque coupure de l'alimentation En utilisant EEPROM avec l'incrément des modes sur une adresse

Evidemment, si la personne oublie d'éteindre l'éclairage, il faudra que l'Arduino se mettent en mode veuille à 20% de la capacité énergétique.

Algorithme du setup avec l'interrupteur ;
Lire le mode sur eeprom
Incrémenter le mode
Si eeprom est superieure à 3 alors valeur 0.
Ecrire le mode eeprom

Mais L'utilisation de EEPROM diminue la durée de fonctionnent de l'éclairage.
En effet, le nombre d'écriture avoisine 100 000 fois par adresse et dure 3.3ms.
Donc avec 2 utilisations d'éclairage par jour et une extinction éteint 3 fois l'alimentation à chaque fois pour revenir
Durée de vie =100 000/2J*3=16666J=>45 ans

Evidemment, il serait possible aussi d'utiliser une iteration de la mémoire EEPROM pour écrire dans une adresse différente mais vu les 45 ans, ce n'est pas très utile.
https://www.arduino.cc/en/Tutorial/EEPROMIteration

Il n'y a pas qu'une solution, mais plusieurs….

En fonction du besoin, la programmation Arduino permet d'ajuster la puissance led et de la capacité énergétique.
On pourrait faire aussi un programme avec un seul mode pleine puissance en mode flash et il n'y plus besoin EEPROM.
Exemple :

Avec une seule batterie (https://fr.aliexpress.com/item/Y12-1A-3-7-v-polym-re-lithium-batterie-102050-microphone-batterie/32916785415.html?spm=a2g0w.search0204.8.15.22df571csSBHHg&transAbTest=ae803_3) lithium de 1A.h mais d'utilisation que de 0.8Ah à cause des 20%, l'autonomie en 3Watt mode flash avec rapport cyclique de 0.5, l'autonomie chute à 1heure. mais cette batterie permet de minimiser la masse et l'encombrement
(https://i89.servimg.com/u/f89/17/56/35/17/a237.jpg) (https://servimg.com/view/17563517/6105)
Mais pourquoi pas faire un rapport cyclique de 0.1 sur 1s.
L'autonomie théorique en mode veuille avec cette batterie est toujours correcte
Temps=0.2A.H/(5*10^-6*24h)=1666Jour

Il y a de nombreux à choix à faire sur ce sujet

Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino nano
Post by: hbachetti on Mar 06, 2019, 10:21 am
33 333Jour : n'y compte pas trop, car l'auto-décharge de la batterie n'est pas négligeable.
J'ai flingué une LIPO comme ça : oubliée dans un tiroir pendant 1 an.
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Mar 08, 2019, 08:32 am
Evidemment, c'est une valeur théorique de l'autonomie qui permet de donner un ordre de grandeur.
Elle ne prend pas en compte, l'autodécharge de la batterie par exemple.

Pour débuguer le programme, on aime utiliser ISIS, ce qui permet de tester le programme sans détruire hacheur et led, batterie….
Mais dans ISIS, l'EEPROM ne fonctionne pas si l'on coupe l'alimentation Vcc.
Par contre, cela fonctionne à chaque fois que l'on redémarre la simulation ou que l'on active le reset.
Voici la copie d'écran de la simulation ou le programme demande 0.5A, puis demande 1A, avec une initailisation de la valeur integral de 148 et ki=4
(https://i89.servimg.com/u/f89/17/56/35/17/a240.jpg) (https://servimg.com/view/17563517/6110)
Donc, le courant est directement à 0.5A avec cette valeur de PWM à 148, mais il faut attendre 2.5s pour avoir un PWM de 169 pour atteindre la valeur de 1A comme on peut l'observer sur la figure suivante :
(https://i89.servimg.com/u/f89/17/56/35/17/a152.jpg) (https://servimg.com/view/17563517/6109)

Evidemment, dans le programme final, il vaut mieux augmenter la valeur de cette initialisation dans le cas le plus défavorable de la tension batterie 3.2V.
Donc, il y aura un léger dépassement du courant lorsque l'alimentation sera de 4.2V à cause de l'initialisation du coefficient intégral.

On pourra observer la variation du courant qui est de 10% autour de la valeur moyenne correspondant aux choix de notre inductance mais cela ne gene pas la regulation. donc, pas besoin de filtrer le courant de façon analogique ou numerique
(https://i89.servimg.com/u/f89/17/56/35/17/nano_l10.png) (https://servimg.com/view/17563517/6111)

Voici le nouveau programme utilisant EEPROM en PJ


Pour visualiser les dynamiques de la régulation en réel, il faut mesurer en fonction du temps, la tension image du courant de la résistance shunt avec la valeur moyenne de la PWM.
Pour mesure la valeur de la PWM à l'oscilloscope, il faudrait utiliser un filtre passe bas de fréquence de coupure bien inférieur à la période de hachage et supérieur à 10Hz correspondant à l'inverse de la période d'échantillonnage.
Un filtre sallen key du deuxième ordre de fréquence de coupure de 100hz est un bon compromis ou un RC du premier ordre.


Une autre solution et d'utiliser la liaison série et le terminal et faire un copier-coller du terminal pour faire un fichier CSV dans Excel….D'ailleurs c'est pour cela que l'on a jamais utilisé le Tx sur ce post
pour cela, il faut inclure la bibliothèque  #include <SoftwareSerial.h>
Initialisation à Serial.begin(9600);
Ces enregistrements prouvent le bon fonctionnement des régulations en simulation et en réel.
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Mar 18, 2019, 09:24 am
Notre système n'a pas besoin d'une grande précision de la mesure de température de la led (plus ou moins quelques °C suffit)
Une PTC (positive température coefficient) (kty81) est 2 fois moins cher qu'une PT 1000 (environ 0.4 euros)
(https://i89.servimg.com/u/f89/17/56/35/17/a335.jpg) (https://servimg.com/view/17563517/6166)
Mais, est qu'il y a plus de sensibilité dans une PTC que dans une PT 1000 ?

Remarque, Dans Isis, c'est la kty 81/110   1000ohms à 25°C qui est simulable
http://www.farnell.com/datasheets/1503771.pdf?_ga=2.252704713.1576310020.1552658034-1358927439.1552558264

Le modèle mathématique d'une PTC est bien présenté sur ce lien
http://mathscinotes.com/2011/07/thermistor-mathematics/
Car ce n'est pas terrible dans wiki
https://en.wikipedia.org/wiki/Thermistor
Voici le modelé mathématique exponentiel et la linéarisation de la tension image de la température entre 0°C et 140°C
Dans les datasheet, si la résistance R25 est donné, le coefficient B (kelving) est parfois pas donné, mais c'est facile de le retrouver
(https://i89.servimg.com/u/f89/17/56/35/17/a247.jpg) (https://servimg.com/view/17563517/6177)
(https://i89.servimg.com/u/f89/17/56/35/17/a338.jpg) (https://servimg.com/view/17563517/6176)
Le boitier des kty 81 est souvent, un TO92 et pas TO220; donc il y a une erreur de la mesure en fonction du contact et un retard de la mesure à cause de la constante de temps thermique. Le boitier TO220 permet de fixer correctement le capteur mais prend de la place
D'ailleurs, la kty 81 dans ISIS est paramétré avec une constante de temps de 10s, une résistance thermique de 2000°C/W et une résistance de contact de 0.5°C/W.
Mais un boitier TO 92, a une constante de temps de 30s avec une résistance thermique de 140°C/W et une résistance de contact de 30°C/W.
Le temps de réponse du capteur est bien inférieur à celui du dissipateur de la LED grâce au dissipateur.
(https://i89.servimg.com/u/f89/17/56/35/17/a337.jpg) (https://servimg.com/view/17563517/6174)
(https://i89.servimg.com/u/f89/17/56/35/17/a246.jpg) (https://servimg.com/view/17563517/6175)
Exemple : si la température mesurée est de 53°C avec une température ambiante de 20°C, alors la température du radiateur sera de 60°C. Il y a une différence de 7°C
Si la température mesurée est de 80°C, la température réelle  est de 91°C. La différence est de 11°C
On peut observer cette différence sur la simulation suivante et en réel avec une caméra infrarouge
(https://i89.servimg.com/u/f89/17/56/35/17/a339.jpg) (https://servimg.com/view/17563517/6178)
Donc, il faut corriger cette différence, avec l'équation précédente, mais la mesure de la température ambiante n'étant pas mesuré, elle sera estimée à 25°C ce qui donnera une erreur par défaut sur la température ambiante est plus grande.
On peut observer sur la simulation que la valeur de la température du capteur et identique à celle donné par l'Arduino avec la correction précédente
(https://i89.servimg.com/u/f89/17/56/35/17/a340.jpg) (https://servimg.com/view/17563517/6179)


Si les PTC sont très courantes pour mesurer la température, les NTC sont très utilisées aussi.


Perspectives  futur;

Avec le programme, le bargraphe n'indique pas s'il y a un état de charge.
Or, ce serait bien qu'il clignote lors de la charge pour indiquer à l'utilisateur que le micro usb est bien connecté.

Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: Adrien_UIT on Mar 19, 2019, 03:14 pm
La régulation de courant de l'Arduino Nano est avec un hachage à 32 kHz.
Contrainte : La taille de l'inductance du hacheur est relativement importante. Pour 320 kHz elle serait divisée par 10.
Perspective : Le hacheur de la carte électronique peut-être remplacer par un composant électronique FL7760. Ce composant est destiné aux applications d'éclairage à Led et comporte des hacheurs.

http://www.farnell.com/datasheets/2363644.pdf

Suivant la documentation du constructeur, nous avons réaliser une carte électronique de régulation de courant. Sur la doc on peut trouver les performances de la fréquence de hachage (1MHz) et la consommation du circuit intégrer (300 microA). L'hystérésis est de plus ou moins 30mV, le reste n'est pas trop indiquée.
Donc pour un courant Led de 0,4 A

(https://i52.servimg.com/u/f52/20/00/09/23/rendem10.jpg) (https://servimg.com/view/20000923/104)

On néglige dans un premier temps la puissance du transistor et de la diode., qui sont surdimensionnés par rapport au courant Led pour ne pas mettre de dissipateur.

Voici le schéma ISIS avec le choix des composants
(https://i52.servimg.com/u/f52/20/00/09/23/carte_10.jpg) (https://servimg.com/view/20000923/105)

(https://i52.servimg.com/u/f52/20/00/09/23/carte_11.jpg) (https://servimg.com/view/20000923/106)

Voici nos mesures expérimentales visant à caractériser les performances du régulateur 7760 :
D'une part pour une tension d'alimentation de 10 V puis 16 V. Puis en variant la résistance de mesure de 1 Ω à 0,5 Ω. Car elle n'est pas précisée dans la documentions constructeur...
- Détermination du rapport cyclique
- Détermination de la fréquence de fonctionnement
- Vérification de l'ondulation de courant
- Mesure du courant d'entrée et détermination de la puissance absorbé
- Détermination des caractéristiques de la Led (tension, courant et puissance utile)
- Calcul du rendement
- Éclairement
Tableau récapitulatif des mesures :
(https://i52.servimg.com/u/f52/20/00/09/23/tablea11.jpg) (https://servimg.com/view/20000923/107)
Pour l'éclairement : 860 Lux à 10 cm pour une puissance de 0,42 W.

La régulation de courant dans la Led fonctionne bien
Les pertes deviennent négligeables pour un courant supérieur à 0.4A avec une résistance Rsense de 0,5ohms, donc un rendement de 70% à la place de 90% théorique.
On a effectué une mesure à vide de la consommation du 7760 et on trouve 400 μA au lieu de 300microA
Mais ça ne change pas tant que ça la valeur théorique du rendement. On pense que cette différence de 100 μA est dû à la commande du transistor…c'est une hypothèse.

Avec une inductance de 100 μH, on a une fréquence entre 300 kHz et 200 kHz correspondant à l'équation théorique suivante avec 60mV
(https://i52.servimg.com/u/f52/20/00/09/23/formul10.jpg) (https://servimg.com/view/20000923/108)
Donc, en théorie, si on divise notre inductance par deux on multiplie d'autant notre fréquence.
On a effectué une vérification pratique avec une valeur d'inductance de 50 μH. On obtient une valeur de 400 kHz.
Mais une valeur de 33 μH, On obtient une toujours une fréquence de 400 kHz qui est certainement dû aux ondulations parasite du typon que l'on peut observer sur les figures suivantes.

Ondulation pour 200 kHz
(https://i52.servimg.com/u/f52/20/00/09/23/delta_10.jpg) (https://servimg.com/view/20000923/109)

Ondulation pour 400 kHz
(https://i52.servimg.com/u/f52/20/00/09/23/delta_11.jpg) (https://servimg.com/view/20000923/110)

Mais comment faire varier la puissance de la led avec l'arduino

A partir de la doc constructeur et sur notre schéma, il y a une broche DIMMING du FL7760.
Cette broche sert à faire varier le courant de la LED. Il faut pour cela appliqué un signal PWM et faire varier le rapport cyclique normalement supérieure à 2KHz.
On a appliqué un signal PWM de 32 kHz et d'amplitude 5 V, en faisant varié le rapport cyclique on observe une variation de la tension Vsense image du courant de notre LED.
On a effectué une série de mesures sur la broche DIM ainsi que sur la résistance Rsense :
(https://i52.servimg.com/u/f52/20/00/09/23/mesure12.jpg) (https://servimg.com/view/20000923/111)
Donc le courant led correspond à l'équation suivante :
(https://i52.servimg.com/u/f52/20/00/09/23/formul11.jpg) (https://servimg.com/view/20000923/112)

Conclusions :
Avec le choix de nos composant, le courant led peut atteindre 3A avec une fréquence de 400khz en minimisant l'inductance à 30μH avec un rendement qui va être aux alentours de 90%. Mais qu'il faudra vérifier.

Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: aurelie_iutgeiisoissons on Mar 19, 2019, 03:25 pm
Test de la durée d'exécution du programme utilisant EEPROM


On souhaite connaître la durée d'exécution de notre programme, cependant arduino ne réalise pas de fichier .cof que l'on peut simuler sur ISIS pour visualiser la durée du programme. Donc on décide tout simplement, d'allumer une LED au lancement de la boucle des 100ms puis de l'éteindre à la fin de son exécution ; ensuite on visualise ce changement d'état à l'oscilloscope et on effectue notre mesure en simulation et en réalité.

(https://i52.servimg.com/u/f52/20/00/09/23/temps_10.png) (https://servimg.com/view/20000923/113)

Comme on peut le voir, le programme s'exécute en 15ms avec l'afficheur LCD et un temps d'échantillonnage de 100ms (boucle d'affichage et de régulation si temps= 100ms (if temps>100).

Mais pour faire cet éclairage, il n'est pas utile d'utiliser un afficheur LCD (qui est utilisé pour faire du debuggage), donc le programme s'exécute en 3,3ms sans l'afficheur LCD avec un temps d'échantillonnage de 100ms.

(https://i52.servimg.com/u/f52/20/00/09/23/temps_11.png) (https://servimg.com/view/20000923/114)

On en conclut qu'on peut diminuer la période d'échantillonnage à 5ms tout en sachant que l'œil à une persistance rétinienne de 20 Hertz, donc un rafraichissement des valeurs de l'afficheur LCD toutes les 0,1s.
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Mar 25, 2019, 09:05 am
pour faire un feu stop arriere automatique un accelerometre va être utilisé

Les accéléromètres numériques sont nombreux avec des micro-usiné capacitif intelligent à trois axes et à faible consommation avec des résolutions de 10bits à 14 bits. Des fonctions intégrées sont multiples avec des options flexibles programmables par l'utilisateur (filtrées passe-bas, et passe haut, interruption).
Pour ce projet, nous n'avons pas besoin d'une grande résolution pour détecter la décélération du vélo pour activer l'éclairage arrière.
S'il y a une décélération en roue libre, on passe de 15km/h (4.1m/s) à l'arrêt  en 19s minimum sur du plat. Donc la décélération est de -0.22m/s^2
Lors de freinage intensif, on passe de 16.6m/s à l'arrêt en 2.5s onc décélération de -6.6m/s^2

Donc pour une déclaration de -1m/s^2 mettra l'éclairage arrière en action full pendant 10s
Mais une accélération de +1m/s^2 arrêtera l'éclairage et remettra à 0. Car cela voudra dire que l'on a redémarré

Remarque 1 g est égale à    9,81 m/s²
D'ailleurs, le programme suivant a choisi la valeur -30=>-0.117g=-1.14m/s^2 pour actionner sa lumière arrière
https://www.instructables.com/id/passive-brake-light/
Quels sont les capteurs d'accélération possibles ? Sachant que l'on veut minimiser le cout de fonctionnement.
L'accéléromètre analogique tel que ADXL335 est relativement cher (environ 3€) mais c'est possible de faire un filtre analogique.
L'accéléromètre numérique tel que ADXL345 est vendu pour environ 1€
(https://i89.servimg.com/u/f89/17/56/35/17/a154.jpg) (https://servimg.com/view/17563517/6223)
Le MCU 6050 qui a un gyroscope interne est plus cher que le composant précédent
(https://i89.servimg.com/u/f89/17/56/35/17/a248.jpg) (https://servimg.com/view/17563517/6224)

Voici, les Performances ADXL345
https://www.sparkfun.com/datasheets/Sensors/Accelerometer/ADXL345.pdf

Alimentation: 2,0 Vcc à 3,6 Vcc
Consommation:  - en mesure: 40 µA à 2,5 Vcc
                       - au repos: 0,1 µA à 2,5 Vcc
Interface: I2C ou SPI 16 bits
Plage de mesure: ±16 g
Sensibilité: 3,9 mg/LSB 2g
Résolution: 4 mg/LSB (13 bits)    1bits(signe) 16g/2^12=16/4096=3.9mg
Filtre interne de ?
FiFo de 32 valeurs
Le temps de mesurer l'accélération sur un axe est de ?

Pour notre programme precedent ;
L'échantillonnage de la commande de la led a été choisi à  0.1seconde (fréquence 10hz).
Pour ne pas avoir de décélération intempestifs, un filtre passe bas de la mesure d'accélération à la fréquence de coupure légèrement inférieur à 10hz serait souhaitable.
Donc, un filtre avec une fréquence de coupure de 0.05s  ne nuira pas aux dynamiques de détection de l'accélération qui est de quelques secondes.
Remarque avec notre programme qui a une routine d'interruption de 1ms, la période d'échantillonnage de l'accélération  se fera à cette valeur.
Il est facile de faire un filtre passe bas numérique  qui atténue les fréquences les plus élevées du signal, offrant ainsi une variation plus douce de la sortie. Ce filtre passe-bas est facilement implémentable en utilisant l'équation suivante avec correspondant à la constante de temps désirée :
(https://i89.servimg.com/u/f89/17/56/35/17/a156.jpg) (https://servimg.com/view/17563517/6228)
(https://i89.servimg.com/u/f89/17/56/35/17/a157.jpg) (https://servimg.com/view/17563517/6229)
Mais comment vérifier les résultats les dynamiques du filtre numérique ?

On peut vérifier le filtrage en mettant un signal carré de période 0.1s et la sortie du filtre passe bas devra donner une exponentielle croissante et décroissante comme en analogique.
Exemple avec une constante de temps de 10ms, donc e^-aTe= e^-(1ms/10ms)= 0.91
Matlab permet de faire cette vérification très facilement
(https://i89.servimg.com/u/f89/17/56/35/17/a155.jpg) (https://servimg.com/view/17563517/6225)
On peut observer que la constante de temps est  bien de 10ms et que le gain statique du filtre est de 1 car l'amplitude en sortie est identique à celle de l'entrée.
(https://i89.servimg.com/u/f89/17/56/35/17/untitl10.jpg) (https://servimg.com/view/17563517/6226)

Maintenant, si l'on désire, une constate de temps de 50ms e^-aTe= e^-(1ms/50ms)= 0.98
On peut observer sur la figure suivante  que la sortie du filtre à bien correspond à la valeur moyenne  du signal carré d'entré qui a un rapport cyclique de 50% donc de 0.5V mais avec une oscillation d'amplitude de 20%.
(https://i89.servimg.com/u/f89/17/56/35/17/untitl11.jpg) (https://servimg.com/view/17563517/6227)

Pour tester le filtre, il serait possible de rajouter sur le signal carré precedent du bruit à haute frequence pour bien vérifier que ce dernier serait atténué.
Evidemment, il est possible de faire des filtres plus complexes pour avoir encore plus d'atténuation


Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Mar 29, 2019, 07:47 pm
Il aurait été possible que l'Arduino lise un signal carré extérieur et de faire une sortie analogique des valeurs sur une PWM pour démontrer l'utilisation d'un filtre numérique sur un oscilloscope avec une routine d'interruption de 1ms pour faire les calculs du filtrage qui a été présenté précédemment.
Mais, nous avons utilisé juste le terminal pour observer les calculs du filtre et vérifier que le float avec ces 7 chiffres significatif fonctionne bien comme on peut l'observer sur le code suivant qui ont été placé dans Excel pour observer les dynamiques du filtre.

Code: [Select]

#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
#include <TimerOne.h>
#include <avr/wdt.h>   //chien de garde
//#include "LowPower.h"     //https://github.com/rocketscream/Low-Power


LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables


unsigned    int     temps=0;
            float  entree=0;
            float  sortie=0;



// Filtre numerique premier ordre
void setup() {
    

  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
  lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
  Serial.begin(9600);

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 10  32khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet
                                            

//wdt_enable(WDTO_15MS);
}



// Interruptions  tous les 0.001s fait par le timer1***********************************
void callback()  {
temps++;
sortie=entree*0.008+sortie*0.992;   //filtre passe pas
  Serial.print(temps);
  Serial.print(";");
  Serial.print("\t");
    
  Serial.print(entree);
  Serial.print(";");
  Serial.print("\t");
  
  Serial.print(sortie,2);
  Serial.print("\t");
  Serial.println(";");  //mise à la ligne

//wdt_reset();
}//fin routine



///////////////////////////////////////////// Boucle correspondant à la fonction main
void loop() {  

if (temps>=50)         //1=singnal carré de 100ms
{
temps=0;  //reset : attention cette boucle doit etre infereir à son temps d'execution
if (entree==16384) {entree=0;}  else {entree=16384;}  
  
}//temps>100

  
} // fin loop  




Avec le terme 0.91 du filtre échantillon à 1ms, On peut observer que la constante de temps est environ celle théorique de 10ms, pour une amplitude de 1023 de l'entrée (10bits).
(https://i89.servimg.com/u/f89/17/56/35/17/a159.jpg) (https://servimg.com/view/17563517/6235)

Avec le terme 0.98 du filtre échantillon à 1ms, On peut observer que la constante de temps est légèrement inférieure à la valeur théorique de 50ms, pour une amplitude de 16384 (14bits) de l'entrée.
Lorsque la constante de temps devient très grande devant la période du signal, la sortie du filtre donnera une oscillation avec une amplitude correspondant à l'équation suivant autour de la valeur moyenne du signal d'entrée
(https://i89.servimg.com/u/f89/17/56/35/17/b116.jpg) (https://servimg.com/view/17563517/6239)
(https://i89.servimg.com/u/f89/17/56/35/17/a251.jpg) (https://servimg.com/view/17563517/6236)
Avec le terme 0.992 du filtre échantillon à 1ms, la constante de temps theorique
(https://i89.servimg.com/u/f89/17/56/35/17/b215.jpg) (https://servimg.com/view/17563517/6240)
on peut observer que l'amplitude
(https://i89.servimg.com/u/f89/17/56/35/17/b312.jpg) (https://servimg.com/view/17563517/6241)
(https://i89.servimg.com/u/f89/17/56/35/17/a342.jpg) (https://servimg.com/view/17563517/6237)
Donc, il y a des petites différences entre la théorique et la pratique mais globalement, cela fonctionne correctement.

Remarque : ne jamais depasser la valeur de 1, sinon c'est instable, d'ou l'obligation de declarer en float
faut il des bibliotheques filtre  pour cela     ? ? ? ? ? ? ? ?
https://playground.arduino.cc/Code/Filters/
https://github.com/sebnil/FIR-filter-Arduino-Library
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Apr 06, 2019, 10:05 am
Pour améliorer le filtrage précédant, il est possible de prendre un filtre d'ordre supérieur.

Mais, les livres pour bien comprendre les filtres numériques ne sont pas très vulgarisé et ils n'ont pas beaucoup d'exemple comme on a pourrait le voir sur le post précèdent :
http://people.rennes.inria.fr/Olivier.Sentieys/teach/filtragepourlesnuls.pdf
http://public.iutenligne.net/electronique/le-bars/num/fnum_ana.pdf
http://public.iutenligne.net/electronique/le-bars/num/fnum_syn.pdf
http://www.f-legrand.fr/scidoc/docimg/numerique/filtre/filtrenum/filtrenum.html
il y a sur ce lien, sur le filtage avec Arduino
http://www.f-legrand.fr/scidoc/docimg/sciphys/arduino/filtrage2/filtrage2.html

Mais la vulgarisation n'est pas simple, car il y de nombreuses méthodes pour déterminer les coefficients d'un filtre numérique à partir d'un gabarit désiré ou à partir d'un filtre analogique.
Evidemment, il y a des softs qui déterminent les coefficients assez facilement tel que :
Matlab filterBuilder pour
Mathcad Plus avec des fonctions spécifiques
des soft en C     http://iowahills.com/8DownloadPage.html
Je n'ai pas réussi à faire fonctionner ce lien
http://www.schwietering.com/jayduino/#Filter
(https://i89.servimg.com/u/f89/17/56/35/17/a254.jpg) (https://servimg.com/view/17563517/6261)
Pas mieux avec celui la
http://t-filter.engineerjs.com/


Je n'ai pas de trouver de tuto sur le forum en anglais, ni en francais ????

Autant, le faire par soi meme....avec mathcad c'est assez facile
Mais pourquoi pas faire les calculs du filtre avec Excel, IDE arduino....
les calculs avec les complexes vont etre plus penible...mais why not....

Le calcul mathématique  d'un butterworth  numérique quel que soit son ordre va être présenté.
Dans le lien suivant, un article présente la méthode bilinéaire mais avec un filtre de coupure de 1 rad/s ???????? Ce qui n'aide pas à la compréhension.
https://www.dsprelated.com/showarticle/1119.php

Quelques soient l'ordre du filtre butterWorth, il n'y a pas de gain positif, le lien dans Wikipédia présente bien ce filtre analogique et il est très facile de déterminer la courbe d'atténuation avec Mathcad.
Nous allons prendre une fréquence de coupure de 10hz et une fréquence d'échantillonnage de 100Hz
https://fr.wikipedia.org/wiki/Filtre_de_Butterworth
(https://i89.servimg.com/u/f89/17/56/35/17/a161.jpg) (https://servimg.com/view/17563517/6256)
Puis de déterminer les pôles du filtre pour les transformer en  zéro du filtres numérique
(https://i89.servimg.com/u/f89/17/56/35/17/a162.jpg) (https://servimg.com/view/17563517/6258)
(https://i89.servimg.com/u/f89/17/56/35/17/a253.jpg) (https://servimg.com/view/17563517/6259)
Enfin de vérifier, l'atténuation du filtre avec les coefficients déterminés, la courbe de fréquence est tracé. On retrouve bien une atténuation de 0.707 ou de -3db à la fréquence de coupure.
(https://i89.servimg.com/u/f89/17/56/35/17/a344.jpg) (https://servimg.com/view/17563517/6257)

Plus, l'écart entre la fréquence d'échantillonnage et la fréquence de coupure est grande, plus l'ordre N du filtre pourra être grand. mais plus le gain devra etre petit et la résolution des zeros devront etre precis.
pour bien tester le filtre numerique,  il faut générer un signal sinusoïdal en entrée et voir en sortie l'atténuation pour chaque fréquence testée

sinon, en utilisant, la décomposition de série de fourriers d'un signal carré, L'amplitude de l'ondulation sera égale à l'équation suivante exemple avec une frèquence de coupure de 1hz.

Si on utilise, un ordre 1, alors l'ondulation theorique sera de 14%
(https://i89.servimg.com/u/f89/17/56/35/17/a164.jpg) (https://servimg.com/view/17563517/6262)
Si on utilise un ordre 3, ondulation sera de 0.1%
(https://i89.servimg.com/u/f89/17/56/35/17/a255.jpg) (https://servimg.com/view/17563517/6263)


Maintenant, il reste à implanter dans l'Arduino.
Evidement les coefficients a(z) sont en float car il faut une certaine précision.
Quel est le temps de calcul de l'Arduino en fonction de l'ordre ?
Mais ce sera pour plus tard.
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Apr 07, 2019, 07:16 am
Précédemment, pour un filtre butteworth d'ordre 3, avec une fréquence d'échantillonnage de 100z et de fréquence de coupure de 10hz,
Si l'on choisit les coefficients au centième près par défaut, le gain passe 1/55 à 1/53 et la courbe d'atténuation fréquentielle sera légèrement modifiée avec une fréquence de coupure légèrement décalé
(https://i89.servimg.com/u/f89/17/56/35/17/a165.jpg) (https://servimg.com/view/17563517/6265)
(https://i89.servimg.com/u/f89/17/56/35/17/a256.jpg) (https://servimg.com/view/17563517/6264)

Le temps de calcul du filtre avec l'ATMEL 328 est de 120us pour un troisième ordre
J'aurai pensé que le temps de calcul aurait été bien plus long. le compilateur doit faire des simplifications

Voici les résultats simuler avec Matlab dans un premier temps avec une fréquence d'échantillon de 100Hz, un signal carré de 10hz, et une fréquence de coupure de 10hz donc avec 10 échantillons par période du signal, ce n'est pas terrible
(https://i89.servimg.com/u/f89/17/56/35/17/a166.jpg) (https://servimg.com/view/17563517/6266)
(https://i89.servimg.com/u/f89/17/56/35/17/filtre10.jpg) (https://servimg.com/view/17563517/6267)
Si l'on essaye de faire avec une fréquence d'échantillon de 1000hz, il y a une divergence du signal de sortie même avec 3 chiffres ou 4 chiffres après la virgule des coefficients zéros du filtre.
C'est là que l'on voit qu'entre la théorie et la pratique, il y a un monde
Plus l'ordre est élevé et plus s'il y a un écart entre fe et fc et plus il faudra une précision sur les coefficients du filtre.
Remarque : Lorsqu'il y a un trop grand écart entre le gain statique avec les coefficients pris par défaut ou avec des coefficients avec 7 chiffres significatifs alors le filtrage devient divergent.

Donc, nous allons le faire avec un butterworth numerique du deuxième ordre
Voici les valeurs pour une fréquence d'échantillonnage de 1000Hz et une fréquence de coupure de 10hz.
(https://i89.servimg.com/u/f89/17/56/35/17/a171.jpg) (https://servimg.com/view/17563517/6277)
(https://i89.servimg.com/u/f89/17/56/35/17/a259.jpg) (https://servimg.com/view/17563517/6276)
La simulation dans Matlab, avec ces coefficients de ce deuxième ordre et un gain de 1/1000. Donne la courbe suivante. Ce signal de sortie a 100 valeurs par période donc il est moins échantillonné que le précèdent.
(https://i89.servimg.com/u/f89/17/56/35/17/filtre11.jpg) (https://servimg.com/view/17563517/6270)
Toujours avec les mêmes coefficients que précèdent mais pour une fréquence de coupure de 1Hz avec une fréquence d'échantillonnage de 100Hz et toujours notre signal carré à 10Hz, on peut observer sur la figure suivante que l'ondulation de la sortie est bien de 13decimal comme en théorie et on garde bien la valeur moyenne.
(https://i89.servimg.com/u/f89/17/56/35/17/filtre12.jpg) (https://servimg.com/view/17563517/6271)
(https://i89.servimg.com/u/f89/17/56/35/17/a168.jpg) (https://servimg.com/view/17563517/6272)


Voici les résultats avec l'Arduino, Le temps de calcul du filtre 2 ordre est de 80us
Voici le programme,
Code: [Select]

#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
#include <TimerOne.h>
#include <avr/wdt.h>   //chien de garde



#define LED13    13      
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables


unsigned    int    temps=0;

            float  entree=0;
            float  entree1=0;
            float  entree2=0;
        
            float  sortie=0;
            float  sortie1=0;
            float  sortie2=0;
            
            float  out=0;
 const float b1 =2;
 const float b2 =1;

            
            const float a1 =-1.911;
            const float a2 =0.915;
            
            const float gain =1000;  
                    

void setup() {
  pinMode(LED13, OUTPUT);

  Timer1.initialize(10000);           // 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
  lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
  Serial.begin(9600);

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 10  32khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet
}



// Interruptions  tous les 0.01s fait par le timer1***********************************
void callback()  {

temps++;  
if (temps>4)         //1=singnal carré de 0.1s  5*routine d'interruption*2
{
temps=0;  //reset : attention cette boucle doit etre infereir à son temps d'execution
if (entree==1023) {entree=0;}  else {entree=1023;}  
 
}//temps>1


      /* ----filtre passe pas Butterwoth 3émé ordre  pour fc=10hz,  fechantillon=1000Hz------   */
digitalWrite(LED13,HIGH);  //permet de mesurer à l'oscillo, le temps du calcul du filtre et le temps de la routine d'interruption
entree2=entree1;      //entree(n-2)
entree1=entree;       //entree(n-1)

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

//sortie=entree+entree1*b1+entree2*b2+entree3*b3-sortie1*a1-sortie2*a2-sortie3*a3 ;   //filtre passe pas recursif ordre 3
sortie=(entree+entree1*b1+entree2*b2-sortie1*a1-sortie2*a2) ;   //filtre passe pas recursif ordre 2
out=sortie/gain;      

digitalWrite(LED13,LOW);
//if ( digitalRead(LED13)== 1 ) {digitalWrite(LED13,LOW);}  else {digitalWrite(LED13,HIGH);}

  Serial.print(temps);
  Serial.print(";");
  Serial.print("\t");
    
  Serial.print(entree);
  Serial.print(";");
  Serial.print("\t");
  
  Serial.print(out);
  Serial.print("\t");
  Serial.println(";");  //mise à la ligne

}//fin routine



///////////////////////////////////////////// Boucle correspondant à la fonction main
void loop() {  
  lcd.setCursor(0,0);
  lcd.print(temps);


  
} // fin loop  



La sortie de l'Arduino correspond bien à la théorie
(https://i89.servimg.com/u/f89/17/56/35/17/a169.jpg) (https://servimg.com/view/17563517/6273)

En synthèse : avec ce filtre RII du deuxième ordre filtre qui est  bien mieux que le premier ordre alors extraire l'information de notre capteur accélérateur en atténuant les vibrations de la route est plus efficace.

Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Apr 08, 2019, 09:38 am
Encore pour tester le filtre, on aurait pu utiliser le traceur série pour tester le filtre du deuxième ordre numérique, mais on peut aussi utiliser une sortie PWM.

En effet, si l'on désire lire le signal carré ou un signal alternatif est connaitre les résultats du filtre numérique, il est possible d'utiliser une sortie PWM filtré analogiquement par un RC.
Avec une fréquence PWM de 32kHz, et un RC de (10kohms et une capacité de 33nF) donc une fréquence de coupure de 482Hz atténuera l'ondulation de la PWM de
On peut observer l'ondulation pour un rapport cyclique de 50% sur la figure suivante :
(https://i89.servimg.com/u/f89/17/56/35/17/a173.jpg) (https://servimg.com/view/17563517/6284)
Cette ondulation est de 0.075V autour de la valeur moyenne.
(https://i89.servimg.com/u/f89/17/56/35/17/a260.jpg) (https://servimg.com/view/17563517/6283)

Avec un signal sinusoïdal ou carré de 10Hz et la fréquence de coupure de 1Hz, on retrouve bien que la valeur moyenne du signal carré qui est donc bien filtré en réel et dans ISIS.
(https://i89.servimg.com/u/f89/17/56/35/17/a174.jpg) (https://servimg.com/view/17563517/6285)
Mais si l'on met un signal sinusoïdale de fréquence de 1hz, l'atténuation est de 0.35 à la place de 0.7 par contre le déphasage est bien de -90°.
(https://i89.servimg.com/u/f89/17/56/35/17/a175.jpg) (https://servimg.com/view/17563517/6286)
Evidemment pour une fréquence sinusoïdale de 0.1Hz, il n'y a plus d'atténuation et le déphasage est presque à 0°.
(https://i89.servimg.com/u/f89/17/56/35/17/a176.jpg) (https://servimg.com/view/17563517/6287)

Le code avec la pwm et la conversion analogique est le suivant :

Code: [Select]

#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
#include <TimerOne.h>
#include <avr/wdt.h>   //chien de garde


#define PWM3   3      //   timer2   
#define LED13    13       
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables


unsigned    int    temps=0;

            float  entree=0;
            float  entree1=0;
            float  entree2=0;
         
            float  sortie=0;
            float  sortie1=0;
            float  sortie2=0;
           
            float  out=0;
 const float b1 =2;
 const float b2 =1;

             
            const float a1 =-1.911;
            const float a2 =0.915;
           
            const float gain =1000;   
                   

void setup() {
  pinMode(LED13, OUTPUT);
  pinMode(PWM3,OUTPUT);

  Timer1.initialize(10000);           // 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
  lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
  Serial.begin(9600);

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 10  32khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet

 
}



// Interruptions  tous les 0.01s fait par le timer1***********************************
void callback()  {

/*
temps++; 
if (temps>4)         //1=singnal carré de 0.1s  5*routine d'interruption*2
{
temps=0;  //reset : attention cette boucle doit etre infereir à son temps d'execution
if (entree==1023) {entree=0;}  else {entree=1023;} 
 
}//temps>1
*/

      /* ----filtre passe pas Butterwoth 3émé ordre  pour fc=10hz,  fechantillon=1000Hz------   */
entree=analogRead(A0);         
//digitalWrite(LED13,HIGH);  //permet de mesurer à l'oscillo, le temps du calcul du filtre et le temps de la routine d'interruption
entree2=entree1;      //entree(n-2)
entree1=entree;       //entree(n-1)

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

//sortie=entree+entree1*b1+entree2*b2+entree3*b3-sortie1*a1-sortie2*a2-sortie3*a3 ;   //filtre passe pas recursif ordre 3
sortie=(entree+entree1*b1+entree2*b2-sortie1*a1-sortie2*a2) ;   //filtre passe pas recursif ordre 2
out=sortie/gain;       //plus facile de diviser  que de multiplier


out = map(out, 0, 1023, 0, 255);   //mise à l'echelle

analogWrite(PWM3,out);


//digitalWrite(LED13,LOW);
if (entree>=850) {digitalWrite(LED13,HIGH);}  else {digitalWrite(LED13,LOW);}  //test de la lecture du signal

/*  Serial.print(temps);
  Serial.print(";");    //creation du fichier CSV
  Serial.print("\t");
*/   
  Serial.print(entree);
  Serial.print(";");
  Serial.print("\t");
 
  Serial.print(out);
  Serial.print("\t");
  Serial.println(";");  //mise à la ligne dans le terminal

}//fin routine



///////////////////////////////////////////// Boucle correspondant à la fonction main
void loop() { 
  lcd.setCursor(0,0);
  lcd.print(entree,0);
   lcd.print("   ");

   
} // fin loop 
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: adel02 on Apr 08, 2019, 07:38 pm
Réalisation complète et finie du typon sur ares :
(https://i80.servimg.com/u/f80/20/05/61/31/imago11.png)


Les 2 cartes arduino doivent venir s'empiler l'une sur l'autre


La carte à été réalisée à partir du schémas isis de base, légèrement modifé :
(https://i80.servimg.com/u/f80/20/05/61/31/imag10.png)


En effet j'ai modifié les entrées et sorties au niveau des ports arduino dans le schéma isis, pour relier tous les composants entre eux sur une même carte arduino sur ares. (Aucun composant devait être relié d'une carte à l'autre car les cartes s'empilent)
Voici les ports affectés aux cartes arduino :
(https://i80.servimg.com/u/f80/20/05/61/31/dz10.png)


Remarquez que seul un fil est présent entre les 2 cartes, il s'agît de la broche 4 de la première carte qui doit être reliée au composant U1, il suffit de relier U1 à la broche 4 de la deuxième carte puisque les cartes s'empilent.
(https://i80.servimg.com/u/f80/20/05/61/31/imago12.png)


Le reste des différents fils non reliés doivent simplement être reliées par un pont.


J'ai également rajouté une résistance R10 en parallèle à R20 pour éviter une surchauffe de R20.
(https://i80.servimg.com/u/f80/20/05/61/31/res10.png)


Enfin, remarquez que je n'ai mis que la led D10 par manque de place sur la carte arduino sur ares.
(https://i80.servimg.com/u/f80/20/05/61/31/imagi10.png)





Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: philippe6philoux on Apr 12, 2019, 11:45 am
super
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: abdou_sankheIUT on Apr 13, 2019, 06:21 pm
MAINTENACE ARDUINO NANO

(https://i12.servimg.com/u/f12/20/05/80/21/110.png)


(https://i12.servimg.com/u/f12/20/05/80/21/210.png)


lorsqu'on alimente l'Arduino nano sous 5V ça marche  mais lorsqu'on l'alimente en USB cela  ne fonctionne pas.
Quel est le composant  dans le schéma  qui ne fonctionne plus ?


(https://i12.servimg.com/u/f12/20/05/80/21/310.png)


donc, ce n'est pas le régulateur  5V qui est est incriminé car cela fonctionne en 5V
Mais l'erreur se trouve au niveau de la diode shotky D1 alimentée par l'USB.

(https://i12.servimg.com/u/f12/20/05/80/21/410.png)

Cette diode D1 se trouve sur le PCB (Printed Circuit Board)


(https://i12.servimg.com/u/f12/20/05/80/21/510.jpg)

mais, on ne voit pas correctement ou est l'anode et la cathode sur le composant
donc, on a identifié l'anode avec la mesure de la tension d'entrée VUSB  à 5v.
La diode MBR0520 supporte 0,5 A, donc nous l'avons remplacé par un boitier  sod 123 supportant 0,3A


(https://i12.servimg.com/u/f12/20/05/80/21/610.png)


https://i12.servimg.com/u/f12/20/05/80/21/710.png


(https://i12.servimg.com/u/f12/20/05/80/21/810.png)

(https://i12.servimg.com/u/f12/20/05/80/21/910.png)

(https://i12.servimg.com/u/f12/20/05/80/21/1010.png)


nous avons fait un petit programme pour vérifier le bon fonctionnent des sorties.
Celle -ci passe de 0 à 5V toutes les 5secondes pour pouvoir vérifier avec un multimètre les différentes tensions
programme

/*
 * SANKHE Abdou
  Clignotement de LED
  Allume toues les LED pendant 5 seconde, puis les éteint pendant 5 seconde
  puis le programme se répète indéfiniment

  Cet exemple est dans le domaine public
  Traduction française par X. HINAULT - www.mon-club-elec.fr
 */
#define Led13 13
#define Led12 12
#define Led11 11
#define Led10 10
#define Led9 9
#define Led8 8
#define Led7 7
#define Led6 6
#define Led5 5
#define Led4 4
#define Led3 3
#define Led2 2
#define LedA0 A0
#define LedA1 A1
#define LedA2 A2
#define LedA3 A3
#define LedA4 A4
#define LedA5 A5
#define LedA6 A6
#define LedA7 A7
 // Définition des broches

void setup() {               
  // initialise la broche 13 en sortie numérique
  // la broche 13 a une LED déjà connectée sur la plupart des cartes Arduino :
  pinMode(13, OUTPUT); 
  pinMode(12,OUTPUT);
  pinMode(11,OUTPUT);
  pinMode(10,OUTPUT );
  pinMode(9,OUTPUT );
  pinMode(8,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(5,OUTPUT);
  pinMode(4,OUTPUT);
  pinMode(3,OUTPUT);
  pinMode(2,OUTPUT);
  pinMode(A0,OUTPUT); 
  pinMode(A1,OUTPUT);
  pinMode(A2,OUTPUT);
  pinMode(A3,OUTPUT);
  pinMode(A4,OUTPUT);
  pinMode(A5,OUTPUT);
  pinMode(A6,OUTPUT);
  pinMode(A7,OUTPUT);
 
}

void loop() {
  digitalWrite(Led13, HIGH);
  digitalWrite(Led12, HIGH);
  digitalWrite(Led11, HIGH);
  digitalWrite(Led10, HIGH);
  digitalWrite(Led9, HIGH);
  digitalWrite(Led8, HIGH);
  digitalWrite(Led7, HIGH);
  digitalWrite(Led6, HIGH);
  digitalWrite(Led5, HIGH);
  digitalWrite(Led4, HIGH);
  digitalWrite(Led3, HIGH);
  digitalWrite(Led2, HIGH);                    // allume la LED

  digitalWrite(LedA0, HIGH);
  digitalWrite(LedA1, HIGH);
  digitalWrite(LedA2, HIGH);
  digitalWrite(LedA3, HIGH);
  digitalWrite(LedA4, HIGH);
  digitalWrite(LedA5, HIGH);
  digitalWrite(LedA6, HIGH);
  digitalWrite(LedA7, HIGH);
 
   
  delay(5000);              // ne fait rien pendant 1 seconde
  digitalWrite(13, LOW);
  digitalWrite(12,LOW);
  digitalWrite(11,LOW);
  digitalWrite(10,LOW );
  digitalWrite(9,LOW );
  digitalWrite(8,LOW );
  digitalWrite(7,LOW );
  digitalWrite(6,LOW);
  digitalWrite(5,LOW );
  digitalWrite(4,LOW );
  digitalWrite(3,LOW );
  digitalWrite(2,LOW );

  digitalWrite(A0,LOW );
  digitalWrite(A1,LOW );
  digitalWrite(A2,LOW );
  digitalWrite(A3,LOW);
  digitalWrite(A4,LOW );
  digitalWrite(A5,LOW );
  digitalWrite(A6,LOW );
  digitalWrite(A7,LOW );
 
                          // éteint la LED
  delay(5000);              // ne fait rien pendant 1 seconde
}
 

schéma de simulation

(https://i12.servimg.com/u/f12/20/05/80/21/1110.png)


on peut observer que la sortie analogique A6 et A7 ne peuvent pas être commandé en numérique.


malgré que l'on soit à vide , la tension de sortie est seulement de 4.3V à cause de la chute de tension interne du transistor.


les tensions sont les suivantes :

(https://i12.servimg.com/u/f12/20/05/80/21/tablea10.png)
(https://i12.servimg.com/u/f12/20/05/80/21/tab10.png)



Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: Thomas_IUT on Apr 18, 2019, 02:16 pm
Fonctionnement du MPU6050
(https://zupimages.net/up/19/16/o2g5.jpg) (http://zupimages.net/viewer.php?id=19/16/o2g5.jpg)
Le capteur MPU6050 est la combinaison d'un accéléromètre et d'un gyroscope. Il est aussi doté d'un capteur de température que nous ne servirons pas ici. L'objectif était d'éteindre la l'éclairage lorsque le vélo ne bougeait plus pendant au moins 2 minutes (je me suis aussi amusé à faire le cas inverse ou lorsque le vélo bouge on allume). Cela nous permet d'avoir une meilleure autonomie et une meilleure gestion des batteries. Pourquoi avoir choisis le MPU6050 ? Nous utilisons le matériel que nous avons dans notre université, nous essayons de « recycler » un maximum pour éviter de faire des dépenses alors que nous pouvons utiliser d'autres composants.
Voici le programme que j'ai fait :
---------------------------------------------------------------------------------------------------------------------
(https://zupimages.net/up/19/16/i7tx.png) (http://zupimages.net/viewer.php?id=19/16/i7tx.png)
---------------------------------------------------------------------------------------------------------------------
Nous utilisons seulement l'accéléromètre du MPU6050, j'ai commencé par trouver par quel coefficient il fallait diviser la mesure pour obtenir quelque chose de cohérent, sur internet et les différents tutos explicatifs que l'on peut trouver personne ne parle de ce coefficient, j'ai donc cherché dans la datasheet et en regardants les différents paramètres que j'avais sur mon MPU6050, il s'avère qu'il fallait que je choisisse 16384. Ensuite j'ai effectué une correction à chaque démarrage ou redémarrage du module pour que son accélération d'origine soit 0,0,0 lors de son démarrage car nous devions tenir compte de l'inclinaison du vélo et la force gravitationnelle de 1G vers le centre de la terre. Par la suite j'ai calculé le module de l'accélération et j'ai fais en sorte que lorsque que l'on marche normalement à une vitesse d'environs 6km/h le module est d'environs 12/13, alors dans le programme lorsque le module est supérieur a 10 il active une boucle qui fait clignoter une led (cette même boucle sera remplacée par l'extinction de là l'éclairage du vélo). Pour trouver le module de l'accélération lorsque l'on marche nous avons dû effectuer des test e utilisant un Arduino nano, un écran LCD, le MPU6050 et 2 batteries lithium 18650.
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: abdou_iutgeiisoissons on Apr 18, 2019, 06:08 pm
J'ai vérifié la mesure du courant du processeur de l'arduino PRO MINI ainsi que celui de l'arduino NANO, les deux possèdent un processeur ATMEGA 328.

Pour réaliser cette mesure sur nous allons mettre une résistance 100 Ohms brancher en série sur l'alimentation et de l'autre côté sur l'entrée Vcc (pour l'arduino PRO MINI) ou sur l'entrée Vin (pour l'arduino NANO)
Ensuite nous allons mesurer la tension aux bornes de la résistance, puis nous allons appliquer la loi d'Ohms: I = U/R
(https://i52.servimg.com/u/f52/20/00/09/23/image412.jpg) (https://servimg.com/view/20000923/128)

Pour la PRO MINI nous allons réaliser les mesures en utilisant les deux entrées l'entrée VCC et l'entrée RAW.

Voici les entrées RAW et VCC représenter sur le schéma de la carte arduino PRO MINI
(https://i52.servimg.com/u/f52/20/00/09/23/captur27.png) (https://servimg.com/view/20000923/127)

Voici les entrées RAW et VCC représenter sur le diagramme de la carte arduino PRO MINI
(https://i52.servimg.com/u/f52/20/00/09/23/captur30.png) (https://servimg.com/view/20000923/133)

Pour l'arduino PRO MINI en 16MHz alimenter sur VCC avec la led d'alimentation qui demande :

- avec une alimentation de 3.3V, la consommation est de 1.9 mA, sachant que la led alimentation consomme 0.15mA
- avec une alimentation de 5V, la consommation est de 9.7 mA, sachant que la led alimentation consomme 0.32mA


Pour l'arduino PRO MINI avec l'alimentation utilisant le régulateur de tension brancher sur l'entrée RAW, ce port peut être alimenté de 7V à 12V.

avec une alimentation de 7.5V, la consommation est de 13 mA, sachant que la led alimentation consomme 0.57mA
avec une alimentation de 10V, la consommation est de 21 mA, sachant que la led alimentation consomme 0.82mA


Pour l'arduino NANO alimenter sur VIN on a avec une alimentation de 5V une consommation de 23 mA.

J'ai réalisé le schéma ISIS ci-dessous représentant un hacheur.
(https://i52.servimg.com/u/f52/20/00/09/23/captur29.png) (https://servimg.com/view/20000923/132)
Ce montage est composé de resistances allant de 1 ohm à 100 kohms, d'un transistor TIP 122, d'une diode Schottky (PBYR745), d'une inductance de 0.5 mH, d'une led de puissance et d'un mosfet IRF 9530.
(https://i52.servimg.com/u/f52/20/00/09/23/image111.jpg) (https://servimg.com/view/20000923/129)

Voici le montage final avec la platine d'essai :
(https://i52.servimg.com/u/f52/20/00/09/23/image211.jpg) (https://servimg.com/view/20000923/135)

La PWM est généré par un signal carré de fréquence 32 KHZ
Le hacheur est alimenté à 8.4 V
j'ai préferer utiliser un mosfet IRF9530 au lieu d'un transistors TIP 122 car une mosfet à une haute impédance et ne demande qu'un petit courant pour s'allumer.

L'utilisation de la diode schottky fait office de protection des autres composants. Elle a un temps de commutation trés court ce qui lui permet d'être trés réactive.








Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: HERRERA_Nataly on Apr 30, 2019, 11:00 am
Suite à la commande de la LED avec le CI FL7760 de mar 19 2019 précèdent



On souhaite réaliser un programme pour augmenter le rapport cyclique de la PWM, de 0% à 100% avec un pas de 10%, par l'appui d'un bouton poussoir. Ce circuit demande une pwm de dimming minimale de 2kHz.

Mais comment gérer l'incrément de cette PWM avec le bouton poussoir ?

Pour vérifier notre programme, nous l'avons simulé avec ISIS, avec une carte Arduino Nano, donc nous avons utilisé le pin 3 pour la PWM et le pin 2 pour notre bouton poussoir.

Dans le setup de notre programme, on déclare le pin connecté au bouton poussoir comme une entrée et la PWM comme une sortie (voir figure ci-dessous).


(https://i31.servimg.com/u/f31/20/06/46/26/setup10.png) (https://servimg.com/view/20064626/3)

Fonction Loop :

Nous avons déclaré et initialisé un boolean « relâcher_bouton » qui nous permettra d'augmenter l'intensité lorsque on relâche le bouton poussoir.
La variable intensité ne peut que varier de 0 à 255 car à « analogWrite() » avec Atmel 328 est sur 8bit. Donc pour cela nous avons créé une condition : si l'intensité est supérieure à 255 on revient à 0 qui permettra d'éteindre la LEDde puissance.
Au niveau de l'affichage, on affiche la valeur de la variable pourcentage, cette variable reçoit la valeur de l'intensité en pourcentage, en sorte que analogWrite (PWM,255) demande un cycle de travail de 100 % et analogWrite(PWM,127) correspond à un cycle de travail à 50%.

Voici le programme de la fonction loop :
Code: [Select]

void loop() {  
  lcd.setCursor(0,0); // position du cousor en haut à gauche
  analogWrite(3, intensite);    //on envoie sur le pignal PWM la valeur de l'intensité
  lcd.print("Duty cycle ");lcd.print(pourcentage);lcd.print("%  "); // affichage du rapport cyclique
  boolean relacher_bouton= false;
    
  if(digitalRead(bouton)==HIGH){ // si on appuie sur le bouton alors
    while(!relacher_bouton){      // on rentre dans cette boucle jusqu'à ce qu'on relâche le bouton
      if(digitalRead(bouton)==LOW){ // si on relâche le bouton alors
        relacher_bouton=true; // relâcher_bouton est vrai et
        intensite=intensite+25.5; // dès qu'on rêlache le bouton, on augmenté l'intensité
        if (intensite > 255){ // si le rapport cyclique arrive à 255, soit 100% alors
          intensite=0; //Reviens à 0
        }      
        pourcentage = ((100*intensite)/255); //formule pour afficher le rapport cyclique en pourcentage
      }
    }
  }
}


Voyons la simulation sur ISIS, on remarque bien que pour un rapport cyclique de 30 %, nous avons 1,8 carreaux à 5V sur 6 ce qui correspond à 0,3=1.8/6 donc 30%.

(http://<a target=)(https://i31.servimg.com/u/f31/20/06/46/26/3010.png)">

De même, pour un rapport cyclique de 90%, on remarque que 5,4 carreaux sont à 5V sur 6 ce qui corresponde à 0,9=5.4/6 donc 90%

(http://<a target=)(https://i31.servimg.com/u/f31/20/06/46/26/9010.png)">

Ci-dessous le programme complet réalisé sur Arduino

Code: [Select]

#include <LiquidCrystal.h>

int bouton = 2;  //init bouton
float intensite=0;
int pourcentage=0;
LiquidCrystal lcd(9,8,4,5,6,7);

void setup() {
  pinMode(3, OUTPUT); // PWM en sortie
  pinMode(bouton, INPUT); // Bouton en entrée
  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 10  32khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet                                      
}

void loop() {  
  lcd.setCursor(0,0); // position du cousor en haut à gauche
  analogWrite(3, intensite);    //on envoie sur le pignal PWM la valeur de l'intensité
  lcd.print("Duty cycle ");lcd.print(pourcentage);lcd.print("%  "); // affichage du rapport cyclique
  boolean relacher_bouton= false;
    
  if(digitalRead(bouton)==HIGH){ // si on appuie sur le bouton alors
    while(!relacher_bouton){      // on rentre dans cette boucle jusqu'à ce qu'on relâche le bouton
      if(digitalRead(bouton)==LOW){ // si on relâche le bouton alors
        relacher_bouton=true; // relâcher_bouton est vrai et
        intensite=intensite+25.5; // dès qu'on rêlache le bouton, on augmenté l'intensité
        if (intensite > 255){ // si le rapport cyclique arrive à 255, soit 100% alors
          intensite=0; //Reviens à 0
        }      
        pourcentage = ((100*intensite)/255); //formule pour afficher le rapport cyclique en pourcentage
      }
    }
  }
}


Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: Fquihifaissal on Apr 09, 2020, 10:44 pm
Communication avec Arduino:

Le MPU6050 utilise le protocole de communication I²C dont la connexion est réalisée par l'intermédiaire de deux lignes :
• SDA (Serial Data Line) : ligne de données bidirectionnelle
• SCL (Serial Clock Line) : ligne d'horloge de synchronisation bidirectionnelle
Dans le monde Arduino, il existe une librairie dédiée à ce protocole : Wire.
En lisant la doc de la librairie Wire Arduino, on voit que sur un Arduino NANO ce sont les entrées analogiques A4 et A5 qui correspondent respectivement à SDA et SCL. On câble donc tout cela ensemble.
Le MPU a besoin d'être alimenté en 3.3V, on relie donc la broche Vcc à la broche 3.3V de l'Arduino et le GND au GND de l'Arduino.
Ce qui nous donne au final ce câblage :

(https://i.servimg.com/u/f38/19/53/73/97/cabl11.png) (https://servimg.com/view/19537397/4)


Configuration :

Sensibilité de l'accéléromètre :

Le registre ACCEL_CONFIG permet de configurer la plage de fonctionnement de l'accéléromètre.

(https://i.servimg.com/u/f38/19/53/73/97/afs10.jpg) (https://servimg.com/view/19537397/5)


Une plage de ±2g est suffisante pour l'étude, ce qui nous amène à utiliser le facteur AFS_SEL = 0

https://servimg.com/view/19537397/6
Structure du registre ACCEL_CONFIG

La paramètre AFS_SEL est codé sur les bits 3 & 4. La valeur 0 en binaire s'écrit alors 0 aussi.
Les bits 0, 1 et 2 sont réservés, on les laisse donc à 0.
Les bits 5, 6, 7 servent à effectuer un auto-test des axes X Y Z respectivement. Cela ne nous intéresse pas, on les laisse donc à 0.

Plus loin dans la datasheet, on arrive sur la page du registre Power Management. Ce registre nous permet de choisir la source d'horloge que le MPU va utiliser au travers du paramètre CLKSEL.

https://servimg.com/view/19537397/7


Nous allons utiliser ici son horloge interne de 8MHz, soit CLKSEL = 0.

(https://i.servimg.com/u/f38/19/53/73/97/horl10.jpg) (https://servimg.com/view/19537397/8)

Structure du registre PWR_MGMT_1

Là encore, on voit que ce registre est codé sur 8 bits.
CLKSEL est codé sur les bits 0, 1 & 2. La valeur 0 en binaire s'ecrit alors 000
Le bit 3 TEMP_DIS (temparture disabled) sert à désactiver la lecture de la température lorsqu'il est à 1. On va garder cette information, on laisse donc ce bit à 0.
On laisse le reste à 0, ce qui nous donne au final 00000000 en binaire, soit 0x00 (hex).
Enfin, l'adresse du registre est 0x6B en hexadécimal.
Ce qui nous donne le code Arduino suivant :

Code: [Select]

Wire.beginTransmission(MPU);        // Start communication with MPU6050 // MPU=0x68
Wire.write(0x6B);                  // Talk to the register 6B
Wire.write(0x00);                  // Make reset - place a 0 into the 6B register


Filtre passe bas :

Le registre, de nom CONFIG, va nous servir à configurer la fréquence de coupure du filtre passe-bas de l'accéléromètre au travers du paramètre DLPF_CFG.

(https://i.servimg.com/u/f38/19/53/73/97/fl10.jpg) (https://servimg.com/view/19537397/9)

Digital Low Pass Filter

On va partir sur une fréquendce d'environ ~43Hz, ce qui nous amène à DLPF_CFG = 3.
On laisse les autres bits à 0, ce qui nous amène à  en binaire, soit 0x03 en hexadécimal.
Enfin, l'adresse du registre est 0x1A en hexadécimal.
Ce qui nous amène au code Arduino suivant :

Code: [Select]

Wire.write(0x1A);             // Request the CONFIG register
Wire.write(0x03);             // Apply the desired configuration to the register : DLPF about 43Hz


Fréquence d'horloge :

Plus loin dans la datasheet, on arrive sur la page du registre Power Management. Ce registre nous permet de choisir la source d'horloge que le MPU va utiliser au travers du paramètre CLKSEL.
https://servimg.com/view/19537397/10
Nous allons utiliser ici son horloge interne de 8MHz, soit CLKSEL=0

(https://i.servimg.com/u/f38/19/53/73/97/pwr10.jpg) (https://servimg.com/view/19537397/11)



Structure du registre PWR_MGMT_1
Là encore, on voit que ce registre est codé sur 8 bits.
CLKSEL est codé sur les bits 0, 1 & 2. La valeur 0 en binaire s'ecrit alors 000.
Le bit 3 TEMP_DIS (temparture disabled) sert à désactiver la lecture de la température lorsqu'il est à 1. On va garder cette information, on laisse donc ce bit à 0.
On laisse le reste à 0, ce qui nous donne au final 00000000 en binaire, soit 0x00 (hex).
Enfin, l'adresse du registre est 0x6B en hexadécimal.
Ce qui nous donne le code Arduino suivant :

Code: [Select]

Wire.beginTransmission(MPU_ADDRESS); // Start communication with MPU
Wire.write(0x6B);                    // Request the PWR_MGMT_1 register
Wire.write(0x00);                    // Apply the desired configuration to the register
Wire.endTransmission();              // End the transmission



LECTURE DES DONNEES BRUTES DU MPU6050 :

Maintenant que le MPU6050 est câblé et configuré, il ne reste plus qu'à lire les données brutes du capteur.

On constate dans la table des registres que les registres 59 à 64 stockent les valeurs de sorties de l'accéléromètre .

(https://i.servimg.com/u/f38/19/53/73/97/lec10.jpg) (https://servimg.com/view/19537397/12)


On va donc simplement parcourir le contenu de ces 6 registres, en commençant à l'adresse 0x3B :

Code: [Select]

Wire.beginTransmission(MPU_ADDRESS);// Start communicating with the MPU-6050
Wire.write(0x3B);                   // Send the requested starting register
Wire.endTransmission(false);             // End the transmission
Wire.requestFrom(MPU_ADDRESS,6);   // Request 14 bytes from the MPU-6050



Mesure de l'accélération :

Un accéléromètre mesure l'accélération subite et l'exprime en g.
1g représente l'accélération de pesanteur sur Terre, soit environ 9,8m.s−29 et des bananes.
L'accéléromètre au repos mesure donc une accélération de 1g.



Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: Fquihifaissal on Apr 09, 2020, 10:51 pm
Script intégral en C sur l'IDE Arduino :

Code: [Select]

#include // include la bibliothèque Wire.h

#define MPU_ADDRESS 0x68  // I2C address of the MPU-6050

#define X  0        // X axis
#define Y  1        // Y axis
#define Z  2        // Z axis
float acc_total_vector;

int acc_raw[3] = {0,0,0};

/**
* Configure la plage de fonctionnement de l'accéléromètre :
*  - accéléromètre: +/-2g

*
* @return void
*/
void setup() {
analogReference(EXTERNAL);
Serial.begin(19200);
Wire.begin();  
// Configure power management
Wire.beginTransmission(MPU_ADDRESS); // Start communication with MPU
Wire.write(0x6B);                    // Request the PWR_MGMT_1 register
Wire.write(0x00);                    // Apply the desired configuration to the register
Wire.endTransmission();              // End the transmission

// Configure the acceleromter's sensitivity
Wire.beginTransmission(MPU_ADDRESS); // Start communication with MPU
Wire.write(0x1C);                    // Request the ACCEL_CONFIG register
Wire.write(0x00);                    // Apply the desired configuration to the register : ±8g
Wire.endTransmission();              // End the transmission

// Configure low pass filter
Wire.beginTransmission(MPU_ADDRESS); // Start communication with MPU
Wire.write(0x1A);                    // Request the CONFIG register
Wire.write(0x00);                    // Set Digital Low Pass Filter about ~43Hz
Wire.endTransmission();              // End the transmission

Wire.endTransmission(true);        //end the transmission
}

void loop() {
Wire.beginTransmission(MPU_ADDRESS);// Start communicating with the MPU-6050
Wire.write(0x3B);                   // Send the requested starting register
Wire.endTransmission(false);             // End the transmission
Wire.requestFrom(MPU_ADDRESS,6);   // Request 14 bytes from the MPU-6050

// Wait until all the bytes are received
while(Wire.available() < 6);

acc_raw[X]  = (Wire.read() << 8 | Wire.read())/ 16384.0; // Add the low and high byte to the acc_raw[X] variable
acc_raw[Y]  = (Wire.read() << 8 | Wire.read())/ 16384.0; // Add the low and high byte to the acc_raw[Y] variable
acc_raw[Z]  = (Wire.read() << 8 | Wire.read())/ 16384.0; // Add the low and high byte to the acc_raw[Z] variable

acc_total_vector = sqrt(pow(acc_raw[X], 2) + pow(acc_raw[Y], 2) + pow(acc_raw[Z], 2));

Serial.print(acc_raw[X]);
Serial.print("/");
Serial.print(acc_raw[Y]);
Serial.print("/");
Serial.print(acc_raw[Z]);
Serial.print("/");
Serial.println(acc_total_vector);
delay(10);

}



Résultats moniteur Arduino:

1g suivant +X :

(https://i.servimg.com/u/f38/19/53/73/97/x10.png) (https://servimg.com/view/19537397/14)


1g suivant -Y :

(https://i.servimg.com/u/f38/19/53/73/97/y10.png) (https://servimg.com/view/19537397/15)



1g suivant +Z:

(https://i.servimg.com/u/f38/19/53/73/97/z10.png) (https://servimg.com/view/19537397/16)

Conclusion:

Quant aux différents filtres, j'ai utilisé le filtre passe-bas numérique intégré dans le MPU6050 avec une bande passante d'environ 45Hz, quand j'essaie de bouger le capteur pour voir les réponses suivant plusieurs axes, les réponses sont quasi-stables dans le moniteur série d'IDE Arduino, le fait d'implanter des équations récurrentes de différents types de filtre (pass_bas pass_haut passe bande ...), c'est facile, mais je n'y vois pas l'intérêt, car tous les résultats qu'on trouve sur le moniteur série Arduino, sont soit 1g suivant X soit 1g suivant Y soit 1g suivant Z.


Allumer un feu stop après un freinage ou un arrêt normal du vélo, est tout à fait possible avec un accéléromètre détectant la décélération, toutefois cela nécessite une étude comparatives de plusieurs accéléromètres analogiques et numériques, sans oublier les autres solutions technologiques pour répondre à cette problématique, comme par exemple un compteur de vitesse (Tr/min)
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Apr 11, 2020, 09:55 pm
Pourquoi ne pas avoir utilisé une bibliothèque dédiée pour le MPU 6050 ??????
Mais en général, avec ces bibliothèques, la configuration est difficile….
donc c'est vraiment bien, ce que vous avez fait.

Est-ce que vous avez fait des essais du capteur MPU6050 dans une voiture et vérifier les dynamiques de l'accélération avec une application smartphone ???????

si tu mets
Code: [Select]

[url=https://servimg.com/view/19537397/16][img]https://i.servimg.com/u/f38/19/53/73/97/z10.png[/img][/url]


on verra l'image
(https://i.servimg.com/u/f38/19/53/73/97/z10.png) (https://servimg.com/view/19537397/16)
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Apr 13, 2020, 07:05 pm
Bref, les compteurs de vélos (odomètre capteur magnet KY03) qui mesurent la vitesse grâce à un compte tour de la roue pourrait aussi mesurer la décélération et activé un STOPT arrière.
Mais quelle pourrait être la précision de cette méthode ? Faut-il mettre plusieurs aimants sur la roue ? Faut-il filtrer la valeur de la  décélération ?

De plus, il existe des éclairages arrière  vélos qui donnent la direction (clignotant droit et gauche) sans fil, mais sur un vélo, il n'y qu'à tendre la main à droite ou à gauche donc c'est inutile.
Mais pour un velomobile (vélo caréné), cela est intéressant
http://velorizontal.1fr1.net/t17956-velomobile-electric-leiba-x-stream-iut-aisne (http://velorizontal.1fr1.net/t17956-velomobile-electric-leiba-x-stream-iut-aisne)
(https://i.servimg.com/u/f21/17/56/35/17/p1050046.jpg) (https://servimg.com/view/17563517/1364)
Voici un bel article avec 2 arduinos et une communication bluetooth
https://create.arduino.cc/projecthub/simonwongwong/bluetooth-enabled-bicycle-turn-signal-2f4f5d
Mais les matrices de leds ne permettent pas d'être vu de jour (pas assez de lumen)

L'article suivant utilise une télécommande 4 boutons
https://github.com/sdebby/Arduino_bike_blink
Donc une télécommande et un récepteur, voici en voici l'électronique
http://www.wzmicro.com/rf.htm
Cela ne coute rien, mais il faudra mettre le compteur de vélo sur l'Arduino arrière pour avoir un feu stop
(https://i89.servimg.com/u/f89/17/56/35/17/a622.jpg) (https://servimg.com/view/17563517/7992)

Donc, un compteur vélo avec Bluetooth va être réalisé et commander l'éclairage arrière comme on peut l'observer sur la figure suivante.
Le compteur avec son afficher a permis  de vérifier  le bon fonctionnement de la programmation et s'il fallait filtrer la mesure de la décélération
Il faudra prendre des Arduino Pro et pas nano pour leurs faibles consommations sur la batterie.
Mais pour vérifier la programmation le nano a été utilisé.
(https://i89.servimg.com/u/f89/17/56/35/17/a384.jpg) (https://servimg.com/view/17563517/8003)
L'indication droite et gauche est évidemment clignotante ainsi que le stop et lors de la décélération.
Mais on aurait pu mettre une 4éme led, pour un feu stop mais cela n'a pas été fait.
Le bouton poussoir stop est inutile, puisque la décélération est mesurée et active automatiquement l'éclairage arrière.

Le compteur vélo a 4 aimants sur la roue pour augmenter la précision des mesures de la vitesse dans les basses vitesses.
Avec l'utilisation de la mesure en milliseonde à chaque quart de roue
L'erreur de la vitesse est déterminée par l'équation suivante avec 4 aimants
DeltaVitesse=(2010*3.6/4)/(Timer+1)( Timer)         pour Timer=25ms=>2.78km/h  pour vitesse 72km/h    
La précision correspond à l'équation suivante
Précision=1/(Timer+1)       donc à 72km/h précisons de 3.8%  et à 18km/h 1%

Etant donné que l'accélération est déterminée aussi pour chaque quart de roue tournée, l'erreur de l'accélération correspondra aux équations suivantes
DeltaAccelera=(277)/(Timer+1)( Timer)        pour Timer=25ms=>0.42m/s^2   pour vitesse 72km/h  
DeltaAccelera=(277)/(Timer+1)( Timer)        pour Timer=100ms=>0.027m/s^2   pour vitesse 18km/h  

Pour ne pas avoir de décélération intempestive, le calcul de la décélération se fera seulement si l'erreur de mesure de la vitesse est plus faible que sa variation.
Etant donné que la propriété de la routine d'interruption extérieure n'est pas si facile à imposer par rapport à routine d'interruption timer sur Atmel, il n'y aura pas d'interruption timer.

Voici le code
Code: [Select]

#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
//#include <TimerOne.h>


#define led13     13       //    
#define BPLeft    12       //
#define Night     11       //
#define BPRight   10       //
#define BPStop     9       //
 

LiquidCrystal lcd(8, 3, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables

 float Time=0;
 float  TO=0;
 float  temps=0;
 float  Time1=0;              
            float kph=0;
            float kph1=0;
            float distance=0;

            float deceler=0;
            float erreur=0;
            bool stop=0;
            bool flagnight=0;
            bool attendre=0;
            
            byte   buffer1=0;
            String readString;

// the setup function runs once when you press reset or power the board
void setup() {
 
pinMode(led13, OUTPUT);   //led carte arduino
pinMode (BPLeft, INPUT_PULLUP);
pinMode (Night, INPUT_PULLUP);
pinMode (BPRight, INPUT_PULLUP);
pinMode (BPStop, INPUT_PULLUP);

 lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
 Serial.begin(9600);     //57600
 //SoftwareSerial mySerial(0, 1);   // RX, TX mais il n'y a pas trop le choix sur la nano


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

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 3  32khz    

attachInterrupt(0, interrup2, RISING);   // il vaut mieux utiliser  KY003 tout ou rien   RISING, FALLING, CHANGE
TO = millis();                                  
}//fin setup

void interrup2() // la fonction appelée par l'interruption externe n°0
{//digitalWrite(led13,HIGH);
Time=(millis()-TO);  //mesure du temps     //micros()    millis()
TO=millis();

distance=(distance+(2.01/4));     //perimetre/4 aimants
kph1=kph;                            
if (Time>=500) {kph=0;deceler=0; }
          else {kph=((2.010*1000*3.6)/(Time*4));   //kph=perimetre/time  avec 4 aimants   //
                erreur=(kph/(Time-2));                                                                            
                if ( (kph<(kph1-erreur)))  {deceler=(((kph-kph1)*277)/Time);} else {deceler=0;}  
                }              // en m/s^2  277=1000milliseconde/3.6      
if (deceler<-40) {deceler=-40; }
if (deceler>40) {deceler=40; }
//  digitalWrite(led13,LOW);   de la routine interr exterieur durée 0.7ms
}



// Interruptions  tous les 100ms fait par le timer1***********************************

//void Routinetimer1()  {
//  temps++;  
//}//fin routineinterruption


///////////////////////////////////////////// Boucle correspondant à la fonction main
void loop() {  
Time1=(millis()-TO);
if (Time1>=500) {kph=0;deceler=0;}   //remise à 0, lorsqu'il n'y a plus d'interruption
attendre=0;

  lcd.setCursor(0,0);  // (X,Y)                              
  lcd.print(kph,1);
  lcd.print("kph    ");
  lcd.setCursor(9,0);  // (X,Y)                                
  lcd.print(distance/1000,2);
  lcd.print("km  ");
 
    lcd.setCursor(0,1);  // (X,Y)                            
    lcd.print(deceler,1);
    lcd.print("m/s");
    lcd.print((char)94);
    lcd.print("2 ");

    if  (deceler<(-2)) {stop=1;lcd.setCursor(10,1);lcd.print("STOP");Serial.print(2); }  
    if  (deceler>0)    {stop=0,lcd.setCursor(10,1);lcd.print("    "); }
    if  (digitalRead(BPStop)==0) {stop=1;lcd.setCursor(10,1);lcd.print("STOP");Serial.print(2); }  
    if (digitalRead(BPLeft)==0)     {Serial.print(1); }
    if (digitalRead(BPRight)==0 )   {Serial.print(3); }
    if (digitalRead(BPRight)==0 && digitalRead(BPStop)==0   )    {distance=0;}   //remise à zero du compteur
    if  (digitalRead(BPStop)==0) {stop=1;lcd.setCursor(10,1);lcd.print("STOP");Serial.print(2); }
 if ((digitalRead(Night)==0) && (flagnight==0) && attendre==0 )      {flagnight=1;Serial.print(0);attendre=1; }   //eteindre la lumiere
 if ((digitalRead(Night)==0) && (flagnight==1) && attendre==0)      {flagnight=0;Serial.print(4);attendre=1;}   //allume lumiere
 if (flagnight==1)  {lcd.setCursor(15,0);lcd.print("N"); }      //lumiere
 if (flagnight==0)  {lcd.setCursor(15,0);lcd.print(" "); }
 
/*Serial.print(Time,0);
Serial.print(";");
Serial.print(kph,1);
Serial.print(";");
Serial.print(deceler,1);
Serial.println(";");  */
delay(100);            
  
} // fin loop


Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Apr 13, 2020, 07:17 pm
la suite du post precedent

Voici le résultat de la mesure de la vitesse et la deceleration avec excel, du programme precedent
(https://i89.servimg.com/u/f89/17/56/35/17/img_2134.jpg) (https://servimg.com/view/17563517/8004)

Pas envie de mettre 2 fils d'alimentation et 1 fil de communication entre le compteur et l'éclairage arrière entre le compteur et la partie éclairage arrière. Donc une commination série Bluetooth HC06 a été choisie.
Il sera possible d'indiquer sur le compteur rétroéclairer, l'état de la batterie arrière.

Le code de la récepteur et qui gère le clignotement
Code: [Select]

#include <SoftwareSerial.h>
#include <TimerOne.h>
//#include <math.h>

 
#define led12     12       //
#define led11     11       //
#define led10     10       //

            byte  temps12=0;
            byte  temps11=0;
            byte  temps10=0;
            byte c=0;
            bool flag12=0;
            bool flag11=0;
            bool flag10=0;
            bool flagnight=0;
            


void setup() {
pinMode(led12, OUTPUT);   //lumiere gauche, direction
pinMode(led11, OUTPUT);   //lumiere centrale, stop et eclairage
pinMode(led10, OUTPUT);   //lumiere gauche, direction


Serial.begin(9600);    
 //SoftwareSerial Serial(0, 1);   // RX, TX mais il n'y a pas trop le choix sur la nano

 Timer1.initialize(400000);           // initialize timer1, and set a 0,1 second period =>  100 000  pour 0.01s  10 000
 Timer1.attachInterrupt(Routinetimer1);   // attaches le sous programme  Routinetimer1 as a timer overflow interrupt
                            
}//fin setup




// Interruptions  tous les 400ms fait par le timer1***********************************
void Routinetimer1()  {
  temps12++;
  temps11++;
  temps10++;
if (temps12<15 && flag12==1)  {if ( digitalRead(12)== 1 ) {digitalWrite(12,LOW);}  else {digitalWrite(12,HIGH);}}  //clignotement pendant 15=6s/0.4s  gauche
if (temps12>15 && flag12==1)  {flag12=0;digitalWrite(led12,LOW);}

if (temps10<15 && flag10==1)  {if ( digitalRead(10)== 1 ) {digitalWrite(10,LOW);}  else {digitalWrite(10,HIGH);}}  //clignotement pendant 15=6s/0.4s droite
if (temps10>15 && flag10==1)  {flag10=0;digitalWrite(led10,LOW);}

if (temps11<15 && flag11==1)  {if ( digitalRead(11)== 1 ) {digitalWrite(11,LOW);}  else {digitalWrite(11,HIGH);}}  //clignotement pendant 15=6s/0.4s stop
if (temps11>15 && flag11==1)  {flag11=0;
                               if (flagnight==1) {digitalWrite(11,HIGH);}
                               if (flagnight==0) {digitalWrite(11,LOW);}
                              }
}//fin routineinterruption



///////////////////////////////////////////// Boucle correspondant à la fonction main
void loop() {  

while (Serial.available()) { c=Serial.read();//Serial.print(c,DEC);  
if (c==48)        {digitalWrite(led11,LOW);flagnight=0;}       //0 arret en continu
if (c==49)        {digitalWrite(led12,HIGH);digitalWrite(led10,LOW);flag12=1;flag10=0;temps12=0;}        //1  direction gauche +5s
if (c==50)        {digitalWrite(led11,HIGH);flag11=1;temps11=0;}                                         //2  feu stop
if (c==51)        {digitalWrite(led10,HIGH);digitalWrite(led12,LOW);flag10=1;flag12=0;temps10=0;}        //3  direction droite +5s
if (c==52)        {digitalWrite(led11,HIGH);flagnight=1;}                                                //4  allumage en continu
                            }

} // fin loop






A la place de faire de nombreux essais, sur le vélo pour vérifier le programme de la mesure vitesse et de la décélération, un Arduino génère les impulsions de l'aimant.
(https://i89.servimg.com/u/f89/17/56/35/17/a447.jpg) (https://servimg.com/view/17563517/7994)



Voici le code du générateur de front qui fait varier la vitesse pour verifier le bon fonctionnement du programme
Code: [Select]

#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
#include <TimerOne.h>
#include <math.h>


 
#define led12     12       //



LiquidCrystal lcd(9, 3, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables



unsigned    int   temps=0;
unsigned    int tempsmono=0;
            float  tempsperiode=0;
            float   tempsdecelerat;
            float  tempsdec=0;
            float  a=0;
            float  b=0;
            float deceleration;
            bool flag;
            

// the setup function runs once when you press reset or power the board
void setup() {
 

pinMode(led12, OUTPUT);   //

 Serial.begin(9600);     //57600

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

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 3  32khz    


  a=0.144;                 //((400-40)/tdecel);   400  correspond à 4.5km/h , 40 à 45km/h utilsation 4 aimants    (4.5-45)/(2.5s*3.6)=4.5m/s^2
  b=40;                    //coefficient de le deceleration
    Serial.print(a,3);
    Serial.print(";");
    Serial.println(b,3) ;                              
}//fin setup



// Interruptions  tous les 1ms fait par le timer1***********************************
void Routinetimer1()  {
temps++;
tempsperiode++;
tempsmono++;

//*
if (tempsperiode<50)  {deceleration=2000;}     //creation profil acceleration et decele
if (tempsperiode>=50 &&  tempsperiode<2500)  {deceleration=-0.2*(tempsperiode-50)+400;        
                                              if (deceleration<40) {deceleration=40;}
                                              }    //acceleration
if (tempsperiode>=2500 &&  tempsperiode<3500)  {deceleration=40;}                                              
if (tempsperiode>=3500 &&  tempsperiode<6000)  {deceleration=a*(tempsperiode-3500)+b;}      //deceleration  

if (tempsperiode>=6000 && tempsperiode<7000 )  {deceleration=1000;}
if (tempsperiode>=7000)  {tempsperiode=0;}
//*/
              
//Serial.print(tempsperiode,0) ;
//Serial.print(";");
//Serial.println(deceleration,0) ;    
//deceleration=40;           //4 aimants,  400=>4.5km/h   40=>45km/h    valeur fixe de vitesse
  
if (temps>=deceleration  && flag==0) {digitalWrite(led12,HIGH);tempsmono=0;flag=1;temps=0; }  //monostable=10ms
if (flag==1 && tempsmono>=4)        {digitalWrite(led12,LOW);flag=0;}




}//fin routineinterruption


///////////////////////////////////////////// Boucle correspondant à la fonction main
void loop() {  
 


} // fin loop


Avec la batterie, du compteur, on pourrait faire aussi un éclairage blanc vers l'avant
Mais, cela sera une autre histoire….


Title: Eclairage arriere velo automatique MPU6050 ESP32 Oled
Post by: iutgeiisoissons on Sep 17, 2020, 08:08 pm
Voici le programme du capteur accéléromètre MPU6050 mais avec un ESP32+OLED et un filtre passe bas du troisième ordre, pour un éclairage automatique arrière de vélo.
(https://i89.servimg.com/u/f89/17/56/35/17/p1050139.jpg) (https://servimg.com/view/17563517/8790)
La méthode de test et des explications sont téléchargeables sur ce lien
https://www.fichier-pdf.fr/2020/09/17/esp32-mpu6050-arduino-filtre-passe-bas-1hz/ (http://)

Code: [Select]

#include "Arduino.h"
#include "heltec.h"
#include "Wire.h"
//#include "BluetoothSerial.h"    //https://randomnerdtutorials.com/esp32-bluetooth-classic-arduino-ide/
                                  //


#define MPU_ADDRESS 0x68  // I2C address of the MPU-6050
int Te=100000  ; //periode d'echantillonnage micro seconde  =>0.1s

int16_t accX=0;
int16_t accY=0;
int16_t accZ=0;

 float accX_0=0;
 float accY_0=0;
 float accZ_0=0;

float accY_1 = 0;  // recurence n-1
float accY_2 = 0;  // recurence n-2
float accY_3 = 0;  // recurence n-3
float YaFout=0;
float YaF =0;
float YaF1 =0;
float YaF2 =0;
float YaF3 =0;

float  Y[127];     //12.7s



byte var=1;
byte i=0;   //incrementation for te curve
bool flagmesure=1;
bool flagenvoie=1;
bool flagstop=0;
bool flagfrein=0;
bool flagrear=0;
bool flaglight=0;
int16_t temps=0;
int16_t tensionbatt;




hw_timer_t * timer = NULL;
portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
uint32_t cp0_regs[18];

//******************************************************************
void IRAM_ATTR onTimer() {      //IRAM et DRAM   routine d'interruption toutes les TE 0.1s
//digitalWrite(33,HIGH);
 portENTER_CRITICAL_ISR(&timerMux);

xthal_set_cpenable(1);  xthal_save_cp0(cp0_regs);   // // Save FPU registers
if ( digitalRead(25)== 1 ) {digitalWrite(25,LOW);}  else {digitalWrite(25,HIGH);}    //led sur la carte heltec

flagmesure=1;
    
  xthal_restore_cp0(cp0_regs);  xthal_set_cpenable(0);  // and turn it back off
  portEXIT_CRITICAL_ISR(&timerMux);
  
//  digitalWrite(33,LOW);
}//fin routine interrupt







//*********************************
void setup(){
pinMode(0, INPUT_PULLUP);   //bouton prg carte heltec ESP32
pinMode(25, OUTPUT);   //led
//pinMode(13, OUTPUT);   //mesure temps instruction oscilloscope
pinMode(21, OUTPUT);   // lecture batterie lithium
 
 Serial.begin(115200);

 Wire.begin(4,15,400000);       //Wire.begin(I2C_SDA, I2C_SCL);       0x3C oled   et MPU6050  broche 4 et 15

  Heltec.begin(true /*DisplayEnable Enable*/, false /*LoRa Disable*/, true /*Serial Enable*/);
  Heltec.display->flipScreenVertically();
  Heltec.display->setFont(ArialMT_Plain_24);           //10, 16, 24
  Heltec.display->setTextAlignment(TEXT_ALIGN_LEFT);

 
Wire.beginTransmission(MPU_ADDRESS);
 Wire.write(0x6B);  // PWR_MGMT_1 register
 Wire.write(0x00);     // set to zero (wakes up the MPU-6050)
 Wire.endTransmission();              // End the transmission

// Configure the acceleromter's sensitivity
Wire.beginTransmission(MPU_ADDRESS); // Start communication with MPU
Wire.write(0x1C);                    // Request the ACCEL_CONFIG register
Wire.write(0x00);                     // Apply the desired configuration to the register : ±2g=±20ms^-2     1g=16384
//Wire.write(0b00010000);             // Apply the desired configuration to the register : ±8g=±20ms^-2  1g=4096
Wire.endTransmission();              // End the transmission

// Configure low pass filter
Wire.beginTransmission(MPU_ADDRESS); // Start communication with MPU
Wire.write(0x1A);                    // Request the CONFIG register
//Wire.write(0x00);                    // Set Digital Low Pass Filter about ~260Hz   DLPF_CFG
Wire.write(0x06);                    // Set Digital Low Pass Filter about ~5Hz   DLPF_CFG
Wire.endTransmission();              // End the transmission

Wire.endTransmission(true);        //end the transmission

  timer = timerBegin(0, 80, true);
  timerAttachInterrupt(timer, &onTimer, true);
  timerAlarmWrite(timer, Te, true);      
  timerAlarmEnable(timer);

}


//************************
void loop(){

//if ( digitalRead(13)== 1 ) {digitalWrite(13,LOW);}  else {digitalWrite(13,HIGH);}     //teste du temps de la boucle
if (digitalRead(0)==0)   {var++;delay(1500); }    //utilisation du bouton prg de la carte ESP32 heltec
if (var>=5)   {var=1;flagenvoie=1; }              //4 valeurs pour afficher les valeurs numeriques ou courbes ou pause ou envoie des données
if ( touchRead(13)<30 )   {flagfrein=1;} else {flagfrein=0;}    //touchRead(13)



if ((flagmesure==1 && (var==1 | var==2)))   {    //mesure tous les 0.1ms
  temps++;
Wire.beginTransmission(MPU_ADDRESS);
Wire.write(0x3B);  // starting with register 0x3B (ACCEL_XOUT_H)
Wire.endTransmission(false);           // End the transmission
Wire.requestFrom(MPU_ADDRESS,6);   // Request 16 bytes from the MPU-6050

// Wait until all the bytes are received
while(Wire.available() < 6);

accX  = (Wire.read() << 8 | Wire.read()); // reading registers: 0x3B et 0x3C     MSB et LSB
accY  = (Wire.read() << 8 | Wire.read()); // reading registers: 0x3D
accZ  = (Wire.read() << 8 | Wire.read()); // reading registers: 0x3F

accX_0=accX/1638.0;   //en m/s^2  pour initilisation à 2*gravitation
accY_0=accY/1638.0;
accZ_0=accZ/1638.0;

accY_3=accY_2;
accY_2=accY_1;  //recurence n-2
accY_1=accY_0;  //recurence n-1

YaF3=YaF2;
YaF2=YaF1;
YaF1=YaF;         //filtre numerique passe bas 3éme orde Frequence de coupure=1Hz
YaF=accY_0+3*accY_1+3*accY_2+3*accY_3+0.278059*YaF3-1.18289*YaF2+1.76*YaF1;   //filtre numerique passe bas  Frequence de coupure=1Hz
YaFout=YaF/66;        //55 en theorie

i++;
if (i>=127) {i=0;}
//Y[i]=accY_0;    //sans filtre
Y[i]=YaFout;      //avec filtre    

if (YaFout>=2)  {flagstop=1;temps=0;}     //declenchement lumiere peandant 5seconde clignotant
if (YaFout<=-1) {flagstop=0;flagrear=0;temps=0;flaglight=0;}   //si acceleration arret lumiere arriere
if (flagstop==1 && temps<=50) {flagrear=1;}
if (temps>50) {flagrear=0;flaglight=0;}  
if (flagrear==1) {       if (flaglight== 1) {flaglight=0;}  else {flaglight=1;}     }  
                      

flagmesure=0;
 }  //fin if flagmesure




switch (var) {
  case 1:        //affichage value
//mesure de la charge de la batterie lithium 18650
digitalWrite(21,LOW);                    //active le pont diviseur
tensionbatt=analogRead(37);              //avec pont diviseur 100K et 220k  4.2V=>1.3125  donc 1630 decimale
tensionbatt=(tensionbatt/39+4);      //(volt*10) 12 bits 4096    0.35V chute de tension dans le transitor     3.3*3.2/409.6=1/39
tensionbatt = map(tensionbatt, 30, 42, 0, 100);    //map(value, fromLow, fromHigh, toLow, toHigh)   % de la charge
                                                   //2.9V=>-8%   3V=>0%    4.2V=100%    

//affichage  acceleration Y et  poucentage de la charge de la batterie
Heltec.display->clear();       //affichage numerique acceleration si appuie sur PRG
//Heltec.display->drawString(0, 0, "IUT GEII Soissons");
//Heltec.display->drawString(0, 11, "X "+String(accX_0,1)+"   ");
Heltec.display->drawString(0, 0, "Y "+String(accY_0,1)+"  ");          //acceleration filtré à 5HZ par le MPU6050
Heltec.display->drawString(83,0, String(tensionbatt)+"%");           //en poucentage de la charge
Heltec.display->drawString(0, 25,"Yf"+String(YaFout,1)+"   ");
Heltec.display->drawString(83, 25,String(flagfrein));
Heltec.display->drawString(100, 25,String(flaglight));
Heltec.display->display();
 break;  //case 1

case 2:       //affichage curve
 Heltec.display->clear();
 Heltec.display->drawHorizontalLine(0,32,127);  //(x,y,length)      //trace les axes
 for (byte im = 0; im <= 127; im++) {    // affichage de la courbe
 Heltec.display->setPixel(im,(32-Y[im]*3));   //mettre la courbe au millieu et augmenter l'echelle de 3
 Heltec.display->display();  }
 break;  //case 2

case 3:       //mode pause

break;  //case 3



case 4:       //send data monitor
if (flagenvoie>=1) {
 for (byte im = 0; im <= 127; im++) {    // affichage de la courbe
 Serial.print( Y[im]);Serial.println(";"); }
 Serial.println("stop");
flagenvoie=0;     }
break;  //case 4
 

 }//end switch
 
 
 }//end loop



Le programme complet avec l'odomètre arrive, mais le programme sera moins lisible, donc on préfère le décomposer en plusieurs programmes.
Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Oct 02, 2020, 07:11 pm
Voici le programme du compteur de velo avec un capteur a effet hall et un aimant avec un ESP32+OLED qui gere plus facilement la commande du feu arriére que le capteur d'acceleration.
Les explications sont ici
https://www.fichier-pdf.fr/2020/10/02/esp32-odometre-alarme-capacimetrertc-heure/ (http://)
le MPU6050 a été gardé pour realiser une alarme.
Il reste plus qu'à faire un tracker avec un GPS et l'envoie d'une notification…..
Mais aussi  realiser un boitier mécanique étanche, car pour l'instant ce n'est pas terrible

(https://i89.servimg.com/u/f89/17/56/35/17/p1050146.jpg) (https://servimg.com/view/17563517/8810)
on va s'inpirer du boitier suivant
(https://i89.servimg.com/u/f89/17/56/35/17/a110.png) (https://servimg.com/view/17563517/8811)
Title: Eclairage à led de vélo avec ESP32 TTGO OLED
Post by: g2gaston on Oct 21, 2020, 11:26 am
J'ai essayé votre programme sur un ESP32 TTGO avec un oled couleur d'aliexpress
Mais j'ai un souci car je n'arrive pas à afficher quelques choses sur le oled pourtant j'ai bien télécharge les bibliothèques comme expliqué ici, ainsi que d'inclure les chemins ou sont les bibliothèques et le driver.
cela compile bien
https://github.com/Xinyuan-LilyGO/TTGO-T-Display (https://github.com/Xinyuan-LilyGO/TTGO-T-Display)
https://www.instructables.com/Select-Color-Display-for-ESP32/ (https://www.instructables.com/Select-Color-Display-for-ESP32/)

La variable i s'incrémente bien sur le moniteur série donc l'ESP32 fonctionne
Pourriez-vous m'eclairer, SVP, car je suis dans le brouillard

Je mets  le minimum du programme pour faire fonctionner le oled ici

Code: [Select]
#include <TFT_eSPI.h>
#include <SPI.h>
//#include "WiFi.h"
#include <Wire.h>
//#include <Button2.h>
#include "esp_adc_cal.h"

#include <C:\Users\geii\Documents\Arduino\libraries\TFT_eSPI\User_Setups\Setup25_TTGO_T_Display.h>
//#include <C:\Users\geii\Documents\Arduino\libraries\TFT_eSPI\User_Setups\Setup24_ST7789.h>
//#include <User_Setup.h\Setup25_TTGO_T_Display.h>


//#include <C:\Users\geii\Documents\Arduino\libraries\TFT_eSPI\User_Setups/Setup18_ST7789.h>
//#include <C:\Users\geii\Documents\Arduino\libraries\TFT_eSPI\TFT_Drivers/ST7789_Defines.h>


//#define ST7789_DRIVER
//#define ILI9341_DRIVER

//#define CGRAM_OFFSET      // Library will add offsets required


//#define TFT_MOSI            19    //SDA
//#define TFT_SCLK            18    //SCL
//#define TFT_CS              5     //CS
//#define TFT_DC              16    //RS
//#define TFT_RST             23    //reset

//#define TFT_BL          4  // Display backlight control pin

#define TFT_BACKLIGHT_ON HIGH  // HIGH or LOW light OLED or not



//#define TFT_WIDTH  135
//#define TFT_HEIGHT 240
TFT_eSPI tft = TFT_eSPI (TFT_WIDTH, TFT_HEIGHT);  // édité



/*
#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF

#define SMOOTH_FONT
*/


//#define SPI_FREQUENCY  27000000
//#define SPI_FREQUENCY    40000000   // Maximum for ILI9341


//#define SPI_READ_FREQUENCY  6000000 // 6 MHz is the maximum SPI read speed for the ST7789V

char buff[512];
int vref = 1100;
int i;

#define ADC_PIN 34

void setup()
{
 
Serial.begin(115200);

pinMode(2, OUTPUT);   //led
//pinMode(34, INPUT);   //led

tft.init();
tft.setRotation(1);
tft.fillScreen(TFT_BLACK);
tft.setTextSize(2);
tft.setTextColor(TFT_WHITE);
tft.setCursor(0, 0);
tft.setTextDatum(MC_DATUM);


if (TFT_BL > 0) { // TFT_BL has been set in the TFT_eSPI library in the User Setup file TTGO_T_Display.h
         pinMode(TFT_BL, OUTPUT); // Set backlight pin to output mode
         digitalWrite(TFT_BL, TFT_BACKLIGHT_ON); // Turn backlight on. TFT_BACKLIGHT_ON has been set in the TFT_eSPI library in the User Setup file TTGO_T_Display.h
    }
   

tft.setTextSize(1);
uint16_t v = analogRead(ADC_PIN);
float battery_voltage = ((float)v / 4095.0) * 2.0 * 3.3 * (vref / 1000.0);
String voltage = "Voltage :" + String(battery_voltage) + "V";
Serial.println(voltage);
tft.fillScreen(TFT_BLACK);
tft.setTextDatum(MC_DATUM);
tft.drawString(voltage, tft.width() / 2, tft.height() / 2 );
delay(1000);
tft.drawString("Press again to wake up", tft.width() / 2, tft.height() / 2 );
delay(1000);

     tft.fillRect(0,0,240,135, TFT_BLUE); // erase the screen display
     tft.setTextSize(3);   // (num colonne , num ligne)
     tft.setCursor(0, 35); // (x colonne , y ligne) - F6CZV
     tft.print("VFO"); // F6CZV
delay(1000);

}




void loop()
{
  i++;
  if ( digitalRead(2)== 1 ) {digitalWrite(2,LOW);}  else {digitalWrite(2,HIGH);}
  Serial.println(i);
//tft.setRotation(0);

tft.fillScreen(TFT_RED);
delay(1000);
tft.fillScreen(TFT_BLUE);
//espDelay(1000);
delay(1000);
tft.fillScreen(TFT_GREEN);
delay(1000);
}


il y a une instrumentation de velo sur ce forum ici, j'ai envoyé un mail mais sans reponse
http://cyclurba.fr/forum/570020/dn-codage-protocole-sn-rie-bbs0x.html?from=571&discussionID=18542&messageID=638753&rubriqueID=102&pageprec (http://"http://\"http://\\"http://\\"http://\\"http://cyclurba.fr/forum/570020/dn-codage-protocole-sn-rie-bbs0x.html?from=571&discussionID=18542&messageID=638753&rubriqueID=102&pageprec""""")


Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: lesept on Oct 21, 2020, 12:44 pm
Ca peut venir du fait que le constructeur

Code: [Select]
TFT_eSPI tft = TFT_eSPI(135, 240); // Invoke custom library
est avant les define des pins du SPI.

J'utilise ce même module TTGO et ça fonctionne bien.
Il faut sélectionner

Code: [Select]
#define ILI9341_DRIVER

dans le fichier User_Setup.h de la bibliothèque TFT_eSPI. Les autres lignes doivent commentées :
Code: [Select]
// Only define one driver, the other ones must be commented out
#define ILI9341_DRIVER
//#define ST7735_DRIVER      // Define additional parameters below for this display
//#define ILI9163_DRIVER     // Define additional parameters below for this display
//#define S6D02A1_DRIVER
//#define RPI_ILI9486_DRIVER // 20MHz maximum SPI
//#define HX8357D_DRIVER
//#define ILI9481_DRIVER
//#define ILI9486_DRIVER
//#define ILI9488_DRIVER     // WARNING: Do not connect ILI9488 display SDO to MISO if other devices share the SPI bus (TFT SDO does NOT tristate when CS is high)
//#define ST7789_DRIVER      // Full configuration option, define additional parameters below for this display
//#define ST7789_2_DRIVER    // Minimal configuration option, define additional parameters below for this display
//#define R61581_DRIVER
//#define RM68140_DRIVER
//#define ST7796_DRIVER
//#define SSD1963_480_DRIVER    // Untested
//#define SSD1963_800_DRIVER    // Untested
//#define SSD1963_800ALT_DRIVER // Untested


Title: Re: Eclairage à led de vélo (7.5W à l’avant et 3 W à l’arrière) avec Arduino
Post by: iutgeiisoissons on Jan 17, 2021, 04:08 pm
A partir d'un d'éclairage arrière chinois à 5€, un Arduino pro mini a été programmé pour optimiser les performances de l'éclairage de la LED en mode flash et d'optimiser l'autonomie.
En effet, un capteur de luminosité permet de faire d'augmenter l'éclairage  de la led lorsque la luminosité extérieure est importante pour être bien vu de jour, mais aussi par temps de brouillard.
C'est éclairage est devenu le plus performant de ce qui existe sur la marché.
https://www.fub.fr/tests-eclairages (https://www.fub.fr/tests-eclairages)
Mais, il est possible de paramétrer l'éclairage par Bluetooth comme on peut le voir sur la photo suivante
(https://i89.servimg.com/u/f89/17/56/35/17/p1050464.jpg) (https://servimg.com/view/17563517/9404)
En PDF, la méthodologie et le programme  pour optimiser l'éclairage et les choix effectués ainsi que le programme…..
https://www.fichier-pdf.fr/2021/01/17/rear-light-bike-3w-arduino-nano-bluetooth-mpu6550/ (https://www.fichier-pdf.fr/2021/01/17/rear-light-bike-3w-arduino-nano-bluetooth-mpu6550/)

D'autres prototypes devraient voir le jour avec amélioration et  la minimisation du volume de l'électronique et du boitier.