Voir la source de Commande et instrumentation de trottinette électrique 500W avec Arduino méga

{{Tuto Details
|Type=Technique
|Area=Électronique, Énergie, Transport
|Tags=Véhicule électrique,
|Description=Trottinette Electrique 500W avec Arduino méga
|Difficulty=Moyen
|Cost=1
|Currency=EUR (€)
|Duration=1
|Duration-type=jour(s)
|Licences=Attribution - Pas d'utilisation commerciale + Partage dans les Mêmes Conditions (CC-BY-NC-SA)
|Main_Picture=Commande_et_instrumentation_de_trottinette_électrique_500W_avec_Arduino_méga_st10.jpg
}}
{{Introduction
|Introduction=Commande de moteur DC 500W avec un Arduino mega pour limiter le courant de démarrage et faire varier la vitesse de la trottinette. La batterie est en 24V, 10A.h. le tableau suivant résume leur caractéristiques 

'''3. Programme en boucle ouverte'''

Pour tester la programmation, nous simulons le programme dans ISIS, comme on peut le voir sur la figure suivante. De plus, nous avons un afficheur LCD pour afficher des données (rapport cyclique correspondant à la PWM à 32Khz, le courant moteur, la tension moteur, l'action sur les boutons poussoirs. En effet, 4 boutons poussoirs sont utilisés.

BP1 pour incrémenter manuellement le rapport cyclique, BP2 le  décrémenter. BP3 mettre le rapport cyclique à 0, correspondant au contact frein.

La vitesse du moteur est pratiquement proportionnelle au rapport cyclique

https://i58.servimg.com/u/f58/17/56/35/17/a211.jpg

Nous avons réalisé notre propre amplificateur de courant qui s'appelle un hacheur abaisseur mais il est possible d'acheter un shield

Il existe de nombreuses cartes pour Arduino pour commander des moteurs DC surtout de faibles puissances et aussi de grandes puissances comme on peut l'observer sur les liens suivants.

<nowiki>http://www.robotpower.com/products/MegaMotoPlus_info.html</nowiki>

<nowiki>http://www.robotshop.com/en/dc-motor-driver-2-15a.html</nowiki>

https://www.pololu.com/file/0J51/vnh3sp30.pdf

https://i58.servimg.com/u/f58/17/56/35/17/a310.jpg

mais, tous ces hacheurs shields mesurent le courant en interne mais il n'y a pas de limitation de courant.

Pour avoir une limitation de courant il faut une boucle de courant analogique en utilisant des AOP ou CI spécialisée ou une boucle de courant numérique rapide.

Mais quel doit être la valeur du courant de limitation ?

Le choix de la valeur du courant est normalement pour le Service de fonctionnement 1 heure pour pouvoir effectuée des montées relativement longue sans atteindre la température critique du moteur.

Dans notre cas, le courant de limitation devra etre de

Imoteur limitation=Puissance/Ubatterie=500W/24 V=20A

De plus, le transistor de puissance du hacheur ne peut supporter que 50A dans notre cas.

Mais en boucle ouverte, il n'a pas de régulation de courant, pour ne pas avoir de dépassement du courant maximum, une rampe du rapport cyclique sera utilisé.

Une routine d'interruption de 0.1 seconde sera utilisé pour faire la mesure de la tension est du courant (échantillon de mesure, sample ). Ce temps de sampler est arbitraire, mais ne permet pas d'être plus rapide que le temps de montée du courant car la constante de temps électrique du moteur étant de  L/R= 1.5ms.

Le fonctionnement en boucle ouverte avec une rampe de 25.5s (8bit et routine d'interruption de 0.1s) permet de bien comprendre la problématique du fonctionnement d'une commande à moteur DC.

l'affichage se fera seulement tous les 0.2s pour avoir une stabilité des chiffres à l’écran. De plus, un filtrage numérique, se fera sur le courant et la tension sur 4 valeurs donc sur 0.4s.

'''Algo boucle ouverte'''

Routine d'interruption toutes les 0.1S

Lire tension et courant

Boucle loop (scrutation des boutons poussoirs)

Si BP1=1 alors incrementer PWM

Si BP2=1 alors décrementer PWM

Si BP3=1 alors PWM=0

Affichage des variables tous les 0.2s

'''code'''

<nowiki>{{</nowiki>

// include the library code:

<nowiki>#</nowiki>include <LiquidCrystal.h>

<nowiki>#</nowiki>include <SoftwareSerial.h>

<nowiki>#</nowiki>include <TimerOne.h>

<nowiki>#</nowiki>define SERIAL_PORT_LOG_ENABLE 1

<nowiki>#</nowiki>define Led     13       // 13 pour la led jaune sur la carte

<nowiki>#</nowiki>define BP1     30       // 30 BP1

<nowiki>#</nowiki>define BP2     31       // 31 BP2

<nowiki>#</nowiki>define BP3     32       // 32 BP3

<nowiki>#</nowiki>define LEDV    33       // 33 led

<nowiki>#</nowiki>define LEDJ    34       // 34 led

<nowiki>#</nowiki>define LEDR    35       // 35 led

<nowiki>#</nowiki>define relay   36       // 36 relay

<nowiki>#</nowiki>define PWM10    10      //11   timer2

LiquidCrystal lcd(27, 28, 25, 24, 23, 22); // RS=12, Enable=11, D4=5, D5=4, D6= 3, D7=2, BPpoussoir=26

// Configuration des variables

unsigned   int UmoteurF = 0;  // variable to store the value coming from the sensor

unsigned   int Umoteur = 0;

unsigned   int Umoteur2 = 0;

unsigned   int Umoteur3 = 0;

unsigned   int Umoteur4 = 0;

unsigned   int ImoteurF = 0;

unsigned   int Imoteur = 0;

unsigned   int Imoteur2 = 0;

unsigned   int Imoteur3 = 0;

unsigned   int Imoteur4 = 0;

byte Rcy=0 ;    //rapport cyclique  8bit

unsigned    int temps;

// the setup function runs once when you press reset or power the board

void setup() {

pinMode(Led, OUTPUT);   //led carte arduino

pinMode(LEDV, OUTPUT);

pinMode(LEDR, OUTPUT);

pinMode(LEDJ, OUTPUT);

pinMode (PWM10,OUTPUT);     // broche (10) en sortie  timer2

//  digitalWrite(LEDV,LOW);

Timer1.initialize(100000);         // initialize timer1, and set a 0,1 second period =>  100 000

Timer1.attachInterrupt(callback);  // attaches callback() as a timer overflow interrupt

lcd.begin(20, 4);

Serial1.begin(9600);

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

//<nowiki>http://www.pobot.org/Modifier-la-frequence-d-un-PWM.html</nowiki>

//   analogWriteResolution(bits)      <nowiki>https://www.arduino.cc/en/Reference/AnalogWriteResolution</nowiki>

lcd.setCursor(0,1);

lcd.print("Rcy");

lcd.setCursor(10,1);

lcd.print("Um");

lcd.setCursor(5,1);

lcd.print("Im");

lcd.setCursor(10,1);

lcd.print("Um");

lcd.setCursor(20,1); //afficheur 4lignes*20 caracteres

lcd.print("BP1+");

lcd.setCursor(25,1);

lcd.print("BP2-");

lcd.setCursor(29,1);

lcd.print("BP3=0");

}

// Interruptions  tous les 0.1s

void callback()  {

temps++;

//toogle state ledv for check

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

else {digitalWrite(LEDV,HIGH);}

analogWrite(PWM10,Rcy);   //frequence

Umoteur=analogRead(A0);

Imoteur=analogRead(A1);

Imoteur2=Imoteur;

Imoteur3=Imoteur2;

Imoteur4=Imoteur3;

ImoteurF=(Imoteur4+Imoteur3+Imoteur2+Imoteur)/4 ;

Umoteur2=Umoteur;

Umoteur3=Umoteur2;

Umoteur4=Umoteur3;

UmoteurF=(Umoteur4+Umoteur3+Umoteur2+Umoteur)/4 ;

}//fin routine

// Boucle correspondant à la fonction main

void loop() {

// BP + LED

if ((digitalRead(BP1))==1) {

lcd.setCursor(20,0);      //colonne, ligne

lcd.print("BP1");

digitalWrite(LEDR, LOW);

digitalWrite(LEDJ, LOW);

Rcy++;                        //incrementation PWM

if ( Rcy>254)  {Rcy=254;}

delay(100);               //8bits*100ms=25S   pente de l'incremetation 25ssecondes

}

if ((digitalRead(BP2))==1) {

lcd.setCursor(20,0);

lcd.print("BP2");

Rcy--;

if ( Rcy<2)  {Rcy=2;}  //PWM presque à 0, arret moteur

delay(100);

digitalWrite(LEDR, HIGH);

digitalWrite(LEDJ, HIGH);

}

if ((digitalRead(BP3))==1) {

lcd.setCursor(20,0);

lcd.print("BP3");

Rcy=2;               //PWM presque à 0, arret moteur

}

if (temps>=2)  {

lcd.setCursor(0,0);

lcd.print("                "); //effacement ligne donnée

lcd.setCursor(0,0);

lcd.print(Rcy);

lcd.setCursor(5,0);

ImoteurF=(ImoteurF)/20;     //resistance (5/1024)*(10/0.25ohm) si ACS712 66mV/A

//pour resistance 1ohm (ImoteurF)/20;   simulation 5/25

lcd.print(ImoteurF);

lcd.setCursor(10,0);

UmoteurF=UmoteurF*10/38;                              //10/38   10/30 simula

if (Umoteur>ImoteurF){UmoteurF=UmoteurF-ImoteurF;  }  //U-R*I

lcd.print(UmoteurF);

temps=0;

}//fin if temps

} // fin loop

<nowiki>}}</nowiki>
}}
{{Materials
|Step_Picture_00=Commande_et_instrumentation_de_trottinette_électrique_500W_avec_Arduino_méga_st9.jpg
}}
{{Separator}}
{{Tuto Step
|Step_Title=2. Bibliographie :
|Step_Content='''2. Bibliographie :'''

Lien download :

'''sketch_escooter_feed_back_reel_V1.ino''' 

<nowiki>https://drive.google.com/file/d/0B_fB3GAsM02FSlRTWHdyRkhuUW8/view?usp=sharing</nowiki>

'''escooter_ampli_SIMULINK.mdl'''

<nowiki>https://drive.google.com/file/d/0B_fB3GAsM02FOW9OdmlhdDhJZGc/view?usp=sharing</nowiki>

'''escooter feed back ISIS.DSN'''

<nowiki>https://drive.google.com/file/d/0B_fB3GAsM02FOXdRWFN5OWRMQkE/view?usp=sharing</nowiki>

En anglais

<nowiki>https://forum.arduino.cc/index.php?topic=477397.0</nowiki>

article : « Etude de trottinettes électriques 100W et 500W (Arduino), Revue 3EI 2017 »

En attente

'''3. Programme en boucle ouverte''' 

Pour tester la programmation, nous simulons le programme dans ISIS, comme on peut le voir sur la figure suivante. De plus, nous avons un afficheur LCD pour afficher des données (rapport cyclique correspondant à la PWM à 32Khz, le courant moteur, la tension moteur, l'action sur les boutons poussoirs. En effet, 4 boutons poussoirs sont utilisés.

BP1 pour incrémenter manuellement le rapport cyclique, BP2 le  décrémenter. BP3 mettre le rapport cyclique à 0, correspondant au contact frein. 

La vitesse du moteur est pratiquement proportionnelle au rapport cyclique

https://i58.servimg.com/u/f58/17/56/35/17/a211.jpg

Nous avons réalisé notre propre amplificateur de courant qui s'appelle un hacheur abaisseur mais il est possible d'acheter un shield

Il existe de nombreuses cartes pour Arduino pour commander des moteurs DC surtout de faibles puissances et aussi de grandes puissances comme on peut l'observer sur les liens suivants. 

<nowiki>http://www.robotpower.com/products/MegaMotoPlus_info.html</nowiki>

<nowiki>http://www.robotshop.com/en/dc-motor-driver-2-15a.html</nowiki>

https://www.pololu.com/file/0J51/vnh3sp30.pdf

https://i58.servimg.com/u/f58/17/56/35/17/a310.jpg

mais, tous ces hacheurs shields mesurent le courant en interne mais il n'y a pas de limitation de courant. 

Pour avoir une limitation de courant il faut une boucle de courant analogique en utilisant des AOP ou CI spécialisée ou une boucle de courant numérique rapide.

Mais quel doit être la valeur du courant de limitation ?

Le choix de la valeur du courant est normalement pour le Service de fonctionnement 1 heure pour pouvoir effectuée des montées relativement longue sans atteindre la température critique du moteur.

Dans notre cas, le courant de limitation devra etre de 

Imoteur limitation=Puissance/Ubatterie=500W/24 V=20A

De plus, le transistor de puissance du hacheur ne peut supporter que 50A dans notre cas.

Mais en boucle ouverte, il n'a pas de régulation de courant, pour ne pas avoir de dépassement du courant maximum, une rampe du rapport cyclique sera utilisé.

Une routine d'interruption de 0.1 seconde sera utilisé pour faire la mesure de la tension est du courant (échantillon de mesure, sample ). Ce temps de sampler est arbitraire, mais ne permet pas d'être plus rapide que le temps de montée du courant car la constante de temps électrique du moteur étant de  L/R= 1.5ms.

Le fonctionnement en boucle ouverte avec une rampe de 25.5s (8bit et routine d'interruption de 0.1s) permet de bien comprendre la problématique du fonctionnement d'une commande à moteur DC.

l'affichage se fera seulement tous les 0.2s pour avoir une stabilité des chiffres à l’écran. De plus, un filtrage numérique, se fera sur le courant et la tension sur 4 valeurs donc sur 0.4s.

'''Algo boucle ouverte'''

Routine d'interruption toutes les 0.1S

Lire tension et courant

Boucle loop (scrutation des boutons poussoirs) 

Si BP1=1 alors incrementer PWM

Si BP2=1 alors décrementer PWM

Si BP3=1 alors PWM=0

Affichage des variables tous les 0.2s

'''code'''

<nowiki>{{</nowiki>

// include the library code:

<nowiki>#</nowiki>include <LiquidCrystal.h>

<nowiki>#</nowiki>include <SoftwareSerial.h>

<nowiki>#</nowiki>include <TimerOne.h>

<nowiki>#</nowiki>define SERIAL_PORT_LOG_ENABLE 1

<nowiki>#</nowiki>define Led     13       // 13 pour la led jaune sur la carte

<nowiki>#</nowiki>define BP1     30       // 30 BP1

<nowiki>#</nowiki>define BP2     31       // 31 BP2           

<nowiki>#</nowiki>define BP3     32       // 32 BP3

<nowiki>#</nowiki>define LEDV    33       // 33 led

<nowiki>#</nowiki>define LEDJ    34       // 34 led

<nowiki>#</nowiki>define LEDR    35       // 35 led

<nowiki>#</nowiki>define relay   36       // 36 relay

<nowiki>#</nowiki>define PWM10    10      //11   timer2    

LiquidCrystal lcd(27, 28, 25, 24, 23, 22); // RS=12, Enable=11, D4=5, D5=4, D6= 3, D7=2, BPpoussoir=26

// Configuration des variables

unsigned   int UmoteurF = 0;  // variable to store the value coming from the sensor

unsigned   int Umoteur = 0;

unsigned   int Umoteur2 = 0;

unsigned   int Umoteur3 = 0;

unsigned   int Umoteur4 = 0;

unsigned   int ImoteurF = 0;  

unsigned   int Imoteur = 0;

unsigned   int Imoteur2 = 0;

unsigned   int Imoteur3 = 0;

unsigned   int Imoteur4 = 0;

byte Rcy=0 ;    //rapport cyclique  8bit

unsigned    int temps;

// the setup function runs once when you press reset or power the board

void setup() {

pinMode(Led, OUTPUT);   //led carte arduino

pinMode(LEDV, OUTPUT);

pinMode(LEDR, OUTPUT);

pinMode(LEDJ, OUTPUT);

pinMode (PWM10,OUTPUT);     // broche (10) en sortie  timer2

//  digitalWrite(LEDV,LOW);

Timer1.initialize(100000);         // initialize timer1, and set a 0,1 second period =>  100 000

Timer1.attachInterrupt(callback);  // attaches callback() as a timer overflow interrupt

lcd.begin(20, 4);  

Serial1.begin(9600); 

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

//<nowiki>http://www.pobot.org/Modifier-la-frequence-d-un-PWM.html</nowiki>

//   analogWriteResolution(bits)      <nowiki>https://www.arduino.cc/en/Reference/AnalogWriteResolution</nowiki>

lcd.setCursor(0,1);

lcd.print("Rcy");

lcd.setCursor(10,1);

lcd.print("Um");

lcd.setCursor(5,1);

lcd.print("Im");

lcd.setCursor(10,1);

lcd.print("Um");

lcd.setCursor(20,1); //afficheur 4lignes*20 caracteres

lcd.print("BP1+");

lcd.setCursor(25,1);

lcd.print("BP2-");

lcd.setCursor(29,1);

lcd.print("BP3=0");

}

// Interruptions  tous les 0.1s

void callback()  {

temps++;

//toogle state ledv for check 

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

else {digitalWrite(LEDV,HIGH);}

analogWrite(PWM10,Rcy);   //frequence

Umoteur=analogRead(A0);

Imoteur=analogRead(A1);

Imoteur2=Imoteur;

Imoteur3=Imoteur2;

Imoteur4=Imoteur3;

ImoteurF=(Imoteur4+Imoteur3+Imoteur2+Imoteur)/4 ;

Umoteur2=Umoteur;

Umoteur3=Umoteur2;

Umoteur4=Umoteur3;

UmoteurF=(Umoteur4+Umoteur3+Umoteur2+Umoteur)/4 ;

}//fin routine

// Boucle correspondant à la fonction main 

void loop() {  

// BP + LED

if ((digitalRead(BP1))==1) {

lcd.setCursor(20,0);      //colonne, ligne

lcd.print("BP1");

digitalWrite(LEDR, LOW);    

digitalWrite(LEDJ, LOW); 

Rcy++;                        //incrementation PWM

if ( Rcy>254)  {Rcy=254;}

delay(100);               //8bits*100ms=25S   pente de l'incremetation 25ssecondes

}  

if ((digitalRead(BP2))==1) {

lcd.setCursor(20,0); 

lcd.print("BP2");

Rcy--;

if ( Rcy<2)  {Rcy=2;}  //PWM presque à 0, arret moteur

delay(100);  

digitalWrite(LEDR, HIGH);

digitalWrite(LEDJ, HIGH); 

} 

if ((digitalRead(BP3))==1) {

lcd.setCursor(20,0);

lcd.print("BP3"); 

Rcy=2;               //PWM presque à 0, arret moteur

}

if (temps>=2)  {

lcd.setCursor(0,0);

lcd.print("                "); //effacement ligne donnée

lcd.setCursor(0,0);     

lcd.print(Rcy);

lcd.setCursor(5,0);

ImoteurF=(ImoteurF)/20;     //resistance (5/1024)*(10/0.25ohm) si ACS712 66mV/A

//pour resistance 1ohm (ImoteurF)/20;   simulation 5/25

lcd.print(ImoteurF);

lcd.setCursor(10,0);

UmoteurF=UmoteurF*10/38;                              //10/38   10/30 simula

if (Umoteur>ImoteurF){UmoteurF=UmoteurF-ImoteurF;  }  //U-R*I

lcd.print(UmoteurF);

temps=0;

}//fin if temps

} // fin loop

<nowiki>}}</nowiki>

https://i58.servimg.com/u/f58/17/56/35/17/dsc_0614.jpg
|Step_Picture_00=Commande_et_instrumentation_de_trottinette_électrique_500W_avec_Arduino_méga_st5.jpg
}}
{{Tuto Step
|Step_Title=caractéristique et  programme en boucle ouverte précédent
|Step_Content=La routine d'interruption  dure que 250 micro seconde, la boucle du programme principal qui scrute l'action de boutons poussoirs est de 13micros et le temps d'affichage de toutes les données est de 11ms. Donc, on peut améliorer la période d'échantillonnage donc la rapidité de la régulation du courant.

L'Arduino permet de faire l'instrumentation de la trottinette donc de connaitre la puissance, la consommation en A.h et W.h, de mesurer la vitesse, de connaitre la consommation en fonction des W.h/km, de mesurer la température du moteur et d'avoir une sécurité de fonctionnement.

Mais pour l'instant nous allons voir comment limiter le courant

'''4. Programme en boucle fermé,  commande à courant limité'''

la période d’échantillonnage passera à 0.01 seconde (routine d'interruption)

si le courant est inférieur à la valeur désirée, alors la le rapport cyclique peut être augmenté ou diminué jusqu’à la valeur désirée qui est la consigne.

par contre si le courant moteur est supérieur à la valeur de limitation, il y a une diminution rapide du rapport cyclique.

pour ne pas avoir de dépassement de la valeur du rapport cyclique celui si sera saturé à 254 maximum et à la valeur minimum 6.

'''code'''

if (Imoteur<4000)                    // pas de limitation de courant à (20A*10)*20=4000

{if (consigne>Rcy)   {Rcy=Rcy+1;}   // rampe de de la Pwm +1*0.01seconde  integrateur pur

if (consigne<Rcy &&  Rcy!=0)    {Rcy=Rcy-1;}     //la decrementation est faite seulement pour la poignée d'acceleration ou avec BP2

if ( Rcy>254)  {Rcy=254;}           //limitation du rapport cyclique

analogWrite(PWM10,Rcy);   //frequence 32kHz timer2}     

}

if (Imoteur>4000)  { Rcy=Rcy-5;              //pas de filtrage du courant, pour etre plus rapide  

if ( Rcy<6)  {Rcy=5;}       //rcy n'est pas signé, ni la PWM   donc Rcy minimun ne doit pas etre inferieur à 6                     

analogWrite(PWM10,Rcy);   //frequence 32kHz timer2}      
}}
{{Tuto Step
|Step_Title=10. mesure de la vitesse (tachymetre)
|Step_Content=La mesure de la vitesse est effectuée avec un capteur effet hall SS495 ou A1324 qui permet de compter chaque tour de roue. Il suffit de rentrer la périmètre de la roue de la trottinette (130mm de rayon donc 0.816m  dans le cas 

Pour avoir la vitesse, il suffit juste de diviser le nombre de tour de roue sur un temps arbitraire de 1s pour avoir une vitesse minimum de de 0.81m/s donc de 2.93 km/h. De plus, un filtrage moyen avec 3 valeurs sera utilisé pour afficher la vitesse. A 25km/h, il y aura 8.5 tours.

Pour compter les tours, une routine d'interruptions extérieure sera utilisée sur l'entrée INT0 21 de la carte mega.

<nowiki>http://www.locoduino.org/spip.php?article64</nowiki>

Pour simuler la vitesse, un pulse sur l'entrée 21 sera utilisé avec un rapport cyclique de 10%.

https://i58.servimg.com/u/f58/17/56/35/17/a018.jpg

'''code'''

void INT0b21() {

Tspeed++;   //interruption exterieure pour compter le nombre de tour

}

//dans le set up declarer la routine d'interruption lorsque le front 5V de la detection de l'aimant se fait

attachInterrupt(digitalPinToInterrupt(21), INT0b21, RISING );  //interruption exterieur

//dans loop

if (temps09>=5)  {        //boucle de 1 seconde

lcd.setCursor(13,2);      // effacement de la vitesse

lcd.print("kph     ");

lcd.setCursor(16,2); 

speed1=Tspeed*2937;      //1tour*816*3.6/1s=2.937km/h

speed2=speed1;           //Tspeed (rate/seconde)

speed3=speed2;

speedF=(speed1+speed2+speed3)/3000;   //pour mettre en kph

lcd.print(speedF,1);    //affichage au dixieme pres

Tspeed=0;   //reset compteur

temps09=0;  //reset time

}

Pour améliorer la précision de la mesure de la vitesse, il est possible que le temps échantillonnage de la mesure de la vitesse soit en fonction de la vitesse.

exemple : 

pour les vitesses inferieures à 10km/h echantillon à 1seconde, mais au dessus de 10km/h echantillon à 2 secondes.

11. Mesure distance pour connaitre l'autonomie 

La distance correspond au nombre de tour total de la roue multipliée par le périmètre de la roue.

Donc il ne faut pas remettre à 0, le nombre de tour à chaque échantillon.

Par contre, la remise à zéro de la distance sera  effectuée lors l'appuie sur le reset de l'Arduino Mega.

L'affichage de la distance s'effectuera au deuxième près.

A 32km/h, il faudra 2 minutes pour faire 1km comme on peut l'observer sur la figure suivante :

https://i58.servimg.com/u/f58/17/56/35/17/a019.jpg

'''code'''

void INT0b21() {

Tspeed++;   //interruption exterieure pour compter la vitesse

nbrRate++;

}

lcd.setCursor(13,4);      

lcd.print("km      ");  //

distance=(nbrRate*816)/1000;  //distance m

distance=distance/1000;  //distance km

lcd.setCursor(15,4);      

lcd.print(distance,1);  

on peut observer l'installation Electrique avec le hacheur, l'arduino, et l'afficheur lors de la mise au point du programme

https://i58.servimg.com/u/f58/17/56/35/17/dsc_0613.jpg

'''12. Synthèse''' 

L'espace RAM est utilisé que à 4% et l'espace ROM à 3%, pour un Arduino mega. Donc, on pourrait prendre un arduino un peu plus petit.

Mais, il y a 8 cellules Lipo pour faire l'alimentation 24V pour alimenter le moteur via le hacheur. Par conséquent, la mesure de la tension de chaque élément sera sur l'Arduino avec un connecteur JST. Cette mesure permet de savoir si une cellule à une résistance interne qui commence à poser problème et pour savoir si l'équilibrage de chaque cellule a bien été effectué.

Il est possible de passer à 36V avec 12 cellules aussi avec l'ardui mega sans utiliser de shield exterieur qui multiplexe 24 entrées analogiques sur l'entrée A0

Il est possible d'envoyer toutes les données à un smarthphone via le bluetooth HC06 par les broches 20, 21, RX1 et TX1. Mais  L'application sous android realisée sous JAVA Studio ne peut pas etre partagé sur ce forum. Cette partie ne sera pas explicitée.

Apres avoir fait l'instrumentation de cette trotinnette, une etude devrait etre effectué sur la precision des mesures, il est possible de [http://www.fichier-pdf.fr/2015/09/07/instrumentation-vehicule-faible-consommation-eco-marathon/ lire]

« Instrumentation d'un véhicule motorisé électrique faible consommation de type « éco marathon » Revue 3EI  N°81, Juillet 2015

http://www.fichier-pdf.fr/2015/09/07/instrumentation-vehicule-faible-consommation-eco-marathon/
|Step_Picture_00=Commande_et_instrumentation_de_trottinette_électrique_500W_avec_Arduino_méga_st2.jpg
}}
{{Tuto Step
|Step_Title=en cours d’écriture :
|Step_Content=Voici les schémas électriques, 3 cartes sont utilisées

une carte qui va s'afficher dans l'arduino, mesure température, courant, et qui fait le lien vers la carte afficheur  

https://i58.servimg.com/u/f58/17/56/35/17/pont_d11.jpg

voici le typon

https://i58.servimg.com/u/f58/17/56/35/17/pont_d10.jpg

une carte 4 boutons poussoirs et un  afficheur LCD recouper d'ancien système microcontrôleur qui utilisait des connecteurs HE10

https://i58.servimg.com/u/f58/17/56/35/17/bouton10.jpg

voici le typon double face

https://i58.servimg.com/u/f58/17/56/35/17/bouton11.jpg

une carte hacheur qui va s'enficher dans la première carte.

le schema electrique de la commande du  hacheur n'a rien à voir avec la carte réelle car l'optocoupleur n'est pas simulable, et il n'y a pas de modele spice de nos composants

a la place d'utiliser, un optocoupleur un driver IRF2110 est preferable d'utilisation.

le condensateur entre le Drain et la source permet de minimiser les oscillations lors des commutations.

de plus, il permet de minimiser les pertes à la commutations dans le transistor.

https://i58.servimg.com/u/f58/17/56/35/17/hacheu10.jpg<div class="post"><div class="inner" id="msg_3261991" data-origID="msg_3261991" >video
youtube  :  "study trotinette electric e-scooter 100W et 350W, wiring"  
https://www.youtube.com/watch?v=QqJ2-YiE8Tg&list=PLfZunVn_gcq7EOurXuWU2sRFmh6CbiUiL&index=75<nowiki>https://www.google.fr/search?q=sepduino&oq=sepduino&aqs=chrome..69i57j0l5.15544j0j7&sourceid=chrome&ie=UTF-8#q=sebduino</nowiki>

un livre
« je réalise mon véhicule électrique » chez DUNOD
</div><div></div></div>
|Step_Picture_00=Commande_et_instrumentation_de_trottinette_électrique_500W_avec_Arduino_méga_st3.jpg
}}
{{Notes}}
{{Tuto Status
|Complete=Cochez cette case si vous considérez ce tutoriel terminé
}}
'''5. Programme en boucle fermé,  commande à courant limité avec poignée d'accélération'''

Une poignée d'accélération fournit une tension 0.8V lorsqu'elle n'est pas actionnée et une tension 4.5V lorsque la poignée est à fond.

A la place d'utiliser des boutons poussoirs pour augmenter ou diminuer la consigne de vitesse, une poignée d'accélération sera donc utilisée

Upoignee=analogRead(A3); //la relation en Upoignée et la consigne qui correspondra au rapport cyclique correspond à 

'''code'''

if (Upoignee>100) { consigne=(Upoignee/2);     //0=a*200+b    et 255=a*800+b   

consigne= consigne-100;

}               

else { consigne=0;   }               

if (Upoignee<100) { consigne=0;  }     //redondance   

'''6. Programme mesure température et sécurité du moteur avec la mesure courant'''

La mesure de température extérieure peut être facilement effectuée par le composant LM35 qui fournit 0.01V par degrés Celsius 

'''code'''

température=analogRead(A2); //lm35 0.01V/°C

temperature=temperature/2;       //coefficient de mesure de temperature

lcd.setCursor(5,2);

lcd.print("      ");

lcd.setCursor(5,2);

lcd.print(temperature);   // affichage en °C

lcd.setCursor(9,2);      // effacement de l'affichage secu

lcd.print("     ");

if (temperature>80 ) {lcd.setCursor(9,2);         // si temperature extern moteur est superieur à 80°C

lcd.print("secuT");  

Rcy=0;}

De plus, une sécurité thermique par la mesure du courant moteur sera ajoutée. 

si le courant de limitation est superieur à 10s alors le moteur ne sera plus alimenté pendant 30s.

un affichage "secu" sur l'afficheur LCD sera indiqué.

Cette sécurité permet de couper le moteur lors de pente trop importante et lors du blocage du moteur mais il faudrait rajouter la mesure de la vitesse dans ce dernier cas

'''code'''

if (timesecurite>=10000 ) {flagarret=1;      

// si courant de limitation pour un courant de plus de 10s

timerepos=0;

consigne=0;

Rcy=0;   

timesecurite=0;}       //   alors arret moteur pendant un temps d'arret 

if (flagarret==1 ) {lcd.setCursor(9,2);         // si courant de limitation pour un courant de plus de 20s

lcd.print("secU");  }     //   alors arret moteur pendant 60 un temps d'arret et affichage 

if (timerepos>=30000 &&  flagarret==1) {flagarret=0;

lcd.setCursor(9,2);      // apres un temps de repos ici de 30s

lcd.print("       ");   }  

on peut observer l'affichage si la température est supérieure à 80°C

https://i58.servimg.com/u/f58/17/56/35/17/a017.jpg

Une sécurité thermique par la mesure du courant moteur (relais thermique numérique) qui permet de connaitre l'image de la température interne du moteur serait idéale. Mais pour cela, il faut bien connaitre le modelé thermique du moteur.

'''7. Programme mesure de la capacité énergétique de la batterie'''

La capacité énergétique d'une batterie est en A.H, nous afficherons la valeur en mA.H pour avoir une grande précision. La capacité sera en A.Seconde dans l’équation suivante. Donc pour avoir en mA.H, il faudra divisé par la capacité par 3600.

Capacité(A.s)<sub>n</sub>=I*Te+C<sub>n-1</sub>   avec Te=0.01s et I multiplié par 10

Donc dans la routine d'interruption

'''code'''

capacity=ImoteurF+capacity ;

et dans l'affichage 

lcd.setCursor(0,3); //affichage de la capacité énergétique

lcd.print("C mA.h=");

capacity1=capacity/(18000);   //18000=3600*5  5=>coefficient mesure courant

lcd.print(capacity1);

pour vérifier mettre un courant de 10A avec une résistance ajustable et au bout de 30s, la capacité devra etre de 83mA.H

'''8. Bilan puissance et modélisation avec SIMULINK'''

La modélisation permet de bien comprendre le véhicule et sa commande. De plus, il est possible de compiler la partie régulation directement en programme Arduino à partir de la simulation sous Simulink. Mais il ne sera pas possible de simuler l'instrumentation avec l'afficheur LCD.

Sur la figure suivante, on peut observer la simulation de la programmation du hacheur avec la limitation de courant avec Simulink. Sur la figure suivante, l'encadrée en vert montre la commande du rapport cyclique pour faire varier la vitesse et l'encadrée en rouge la limitation du courant. Le correcteur de la régulation est ici un simple intégrateur mais il est possible d'effectuer une multitude de commande.

https://i58.servimg.com/u/f58/17/56/35/17/azub_c15.jpg<div class="post"><div class="inner" id="msg_3235325">Sur la figure precedente, on peut observer que le courant est bien limité à 25A de 2s à 9.5s. Puis, le courant atteint 10.8A en régime établi de vitesse à 22.5km/h. les dynamiques sont similaires aux essais effectués.
Avec une pente de 5%, le rapport cyclique n'atteint tout juste 100% comme on peut l'observer sur la figure suivante. La vitesse atteindra péniblement 19km/h avec un courant de 24A et une puissance moteur de 580W.
Voir l'article : Etude de trottinettes électriques 100W et 500W (Arduino),
'''9. Première conclusion''' 
Il est facile de commander un moteur DC de 500W avec un Arduino et quelques composants
Donc de réparer nombreuses trottinettes qui sont en moteur DC.
mais il faut quelques connaissances (automatique, moteur) pour savoir gérer correctement le moteur et limiter son courant pour ne pas l'endomager
l'affichage de la vitesse, la distance, de l'heure de fonctionnement pour connaitre les Watt.heure/km pourra etre aussi réalisé avec un menu 2.
le programme .ino en fichier attaché,  
mais il n'est pas possible de mettre un fichier attaché .dns de ISIS labcenter electronic ?
c'est quoi ce forum !
il serait souhaitable que le compilateur puisse générer le.cof pour pouvoir debugger dans isis et tester le programme ligne par ligne....
Arduino doit encore faire beaucoup d'effort pour être au mémé niveau que d'autre microcontrôleur

https://forum.arduino.cc/Themes/default/images/icons/clip.png 

8.47 KB

downloaded 10 times
</div></div><div id="msg_3235325_footer" class="attachments"><div class="floatleft"></div></div>
|Step_Picture_00=Commande_et_instrumentation_de_trottinette_électrique_500W_avec_Arduino_méga_st4.jpg
}}