Embed Size (px)
Citation preview
16/01/2019
TP déductif Arduino
- CAN et surveillance de charge d’une batterie LiPo 2 éléments
MLK - ECST
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
TP déductif 1
Objectif ...................................................................................................................................... 2
Présentation du matériel .......................................................................................................... 2
Modélisation de la charge d’une batterie LiPo ......................................................................... 2
Mesure de la tension de batterie :............................................................................................. 4
Programme préliminaire : Test du Convertisseur Analogique Numérique ......................... 4
Illustration de la chaîne d’information ................................................................................. 5
Modélisation mathématique de la chaîne d’information ..................................................... 5
Calcul du pourcentage de charge ........................................................................................... 7
Affichage sur le LCD RGB ..................................................................................................... 8
Pour aller plus loin : CGRAM .............................................................................................. 10
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
2
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
Compétences spécifiques : Utilisation d’un modèle mathématiques avec un Arduino
Pré-requis : Structures fondamentales en langage Arduino
Type : TP Déductif
Objectif
L’objectif final de ce TP est de proposer un modèle mathématique d’une batterie LiPo et de l’utiliser pour
indiquer l’état de sa charge sur l’afficheur LCD d’un Arduino.
Présentation du matériel
Arduino UNO
Interface grove1
Potentiomètre et LCD RGB2 I2C3
Modélisation de la charge d’une batterie LiPo
Les batteries Lithium Polymère sont très utilisées dans le modélismes car elles ont
l’avantage d’avoir une très bonne densité massique : C’est la technologie qui offre la
meilleure capacité (en Ah) pour la masse (en kg) la plus faible.
Elle a cependant des inconvénients : Elle peut prendre feu en cas de mauvaise
utilisation et sa durée de vie est assez limitée ; Environ 2 ans même si elle n’est pas
utilisée. Aussi, son recyclage est difficile, couteux et souvent réalisé dans de
mauvaises conditions par des personnes vulnérables et surexploitées.
À titre de comparaison et pour information, il existe d’autres technologies de batteries :
Li-Ion sensiblement les mêmes avantages que les LiPo mais moins instables. C’est pour cela quelles
sont utilisées dans les Smartphones, etc.
NiMh meilleure densité volumique : celles qui occupe le moins de place (m3) pour une capacité (Ah)
donnée ; Utilisées dans les premières voitures électriques pour gagner de l’espace utile bien que la
tendance actuelle (en 2019) est d’utiliser des batteries lithium.
Plomb meilleure prix pour une même capacité. Très utilisée dans les systèmes statiques où le poids
n’est pas un inconvénient. Facilement recyclable.
Remarque : En théorie toutes les technologies sont recyclables…
Mais revenons à notre batterie LiPo…
Contrairement à ce que l’on pourrait imaginer, la charge d’une batterie n’est pas proportionnelle à sa tension :
0V ne correspond pas à 0% car la tension de batterie ne tombe jamais à 0V sauf si elle est détruite. De plus, une
batterie de tension 7,4V nominale offre à pleine charge une tension de 8,4V.
Voici le profile de charge d’une batterie LiPo 2 éléments, soit de tension 7,4V nominale :
Tension Batterie (V) 6,00 6,60 7,20 7,30 7,40 7,50 7,58 7,66 7,74 7,84 7,94 8,20 8,40
Pourcentage de charge (%) 0 5 10 12 20 30 40 50 60 70 80 90 100
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
TP déductif 3
Compléter le graphique représentant la charge de la batterie en % en fonction de sa tension :
Remarquez que pour une meilleure lisibilité, l’axe des abscisses ne commence pas à 0V mais à 6V.
Les tableurs comme Excel peuvent donner l’équation d’une courbe mais le résultat n’est pas toujours
concluant :
Quelle est la courbe qui se rapproche le plus de la réalité ?
___________________________________________________________________________
Quels sont les inconvénients de ce modèle mathématique pour sa précision pour la résolution avec un
Arduino ?
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
4
Pour s’affranchir de ces problèmes, nous modéliserons la charge de la batterie sur trois intervalles. Vous
pouvez remarquez que, dans ces intervalles, les caractéristiques sont linéaires de la forme : y = a . x + b
De 6,00V à 7,30V soit [6,00 ; 7,30[
pourcentage = 8,3333 x tensionBatterie - 50
De 7,30V à 7,94V soit [7,30 ; 7,94[
pourcentage = 111,06 x tensionBatterie - 800,88
De 7,94V à 8,40V soit [7,94 ; 8,40[
pourcentage = 43,233 x tensionBatterie - 263,65
Mesure de la tension de batterie :
Le Arduino UNO utilise un microcontrôleur ATMEL. Il possède, comme les microcontrôleurs PIC, un
microprocesseur et d’autres fonctions intégrées dans un même boîtier : EPROM, RAM, CAN, etc.
Le CAN (Convertisseur Analogique Numérique) 10 bits de l’Arduino Uno permet de convertir une tension
électrique (Analogique) pouvant varier de 0 à 5V en un nombre binaire (Numérique) compris entre
0b0000000000 et 0b1111111111 soit en base décimale de 0 à 1023. Il y a donc 210 combinaisons possibles.
On dit qu’il a une résolution de 5 / 210 ≈ 4,9 mV également appelé quantum du convertisseur.
Programme préliminaire : Test du Convertisseur Analogique Numérique
Câbler un potentiomètre sur la carte
Arduino conformément au code ci-
contre. Lisez et comprenez le
programme ainsi que les
commentaires. Taper et tester ce
dernier (testCAN.ino) sur la carte en
faisant varier le potentiomètre et en
observant les résultats sur le moniteur
série.
Commentez les résultats obtenus ?
__________________________
__________________________
__________________________
Rappelez quel intervalle de tension est applicable à l’entrée du convertisseur ?
___________________________________________________________________________
Rappelez quel intervalle de tension est fourni par un batterie LiPo ?
___________________________________________________________________________
Remarquez qu’il y a donc un problème de compatibilité électrique entre la tension de la batterie 8,4V qui est
trop grande devant la tension d’entrée maximale 5V du convertisseur. Il va donc falloir adapter cette tension
de batterie à l’aide d’un diviseur de tension. On réalise cette fonction avec à l’aide de deux résistances dont le
dimensionnement n’est pas l’objet de ce TP. Nous allons juste nous intéresser à son coefficient k.
// Test du CNA 10 bits #define analogPin 3 // potentiomètre connecté // sur l’entrée analogique pin 3 unsigned int valeurBrute = 0; // variable pour stocker // le résultat de la conversion void setup() { Serial.begin(9600); // Configuration de la vitesse de transfert } void loop() { valeurBrute = analogRead(analogPin); // Conversion analogique // vers Numérique Serial.println(valeurBrute); // Affichage du résultat // numérique sur le moniteur }
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
TP déductif 5
Illustration de la chaîne d’information
x k / q
Modélisation mathématique de la chaîne d’information Calculer le coefficient k du diviseur de tension qui permet de passer de la tension de batterie de 8,4V à la
tension d’entrée du convertisseur de 5V : Il faut donc que 8,4 x k = 5
k = _________________________________________________________________________
Rappeler le quantum q du convertisseur 10 bits qui permet d’obtenir le nombre 1023 lorsque sa tension
d’entrée est de 5V : Il faut donc que 5 / q = 1023
q = _________________________________________________________________________
De cette chaîne d’information, on peut retrouver l’expression mathématique du nombre en sortie du
convertisseur que l’on appellera valeurBrute dans le programme :
valeurBrute = tensionBatterie x k / q
On en déduit l’expression de la tension de batterie que l’on devra afficher avec le programme Arduino à partir
de la valeur brute donnée par le convertisseur :
tensionBatterie = valeurBrute x q / k
Pour des raisons pratiques, nous allons "simuler" la tension de batterie avec le potentiomètre grove à l’entrée
de la carte Arduino. Ainsi, nous n’aurons à câbler ni le diviseur de tension, ni la batterie. Le coefficient k du
diviseur demeure utilisé dans le programme pour afficher la valeur que nous aurions obtenue si la batterie
était réellement câblée. En outre, il est difficile d’observer les variations d’une tension de batterie sans y passer
des heures à attendre qu’elle se charge ou se décharge.
Lisez et comprenez le programme ci-dessus ainsi que les commentaires. Taper et tester le croquis (mesureTensionBatterie.ino) sur la carte en faisant varier le potentiomètre et en observant les résultats sur le moniteur série.
Remarquez qu’il faut utiliser le point et non la virgule pour les nombres décimaux (float). C’est une erreur difficilement décelable car l’IDE Arduino ne la détectera pas forcément puisqu’elle n’est pas une erreur de syntaxe proprement dite.
// Mesure de la tension de batterie
#define analogPin 3 // Potentiomètre connecté sur l’entrée analogique broche 3
unsigned int valeurBrute = 0; // Variable résultat de la conversion analogique numérique
float tensionBatterie = 0; // Variable tension de batterie
const float VmaxCAN = 5.0; // Constante tension Max d’entrée convertisseur
const float q = VmaxCAN / 1023; // Constante quantum du convertisseur
const float k = VmaxCAN / 8.4; // Constante coefficient du diviseur de tension
void setup()
{
Serial.begin(9600); // Configuration vitesse de transfert du moniteur série
}
void loop()
{
valeurBrute = analogRead(analogPin); // Lancement de la conversion analogique Numérique
tensionBatterie = (valeurBrute * q) / k; // Calcul de la tension de batterie
Serial.println("--------------------"); // Affichage des résultats
Serial.print("valeurBrute = ");
Serial.println(valeurBrute); // Affichage du résultat de la conversion sur le moniteur
Serial.print("q = ");
Serial.println(q, 10); // Affiche la valeur du quantum avec 10 chiffres après la virgule
Serial.print("k = ");
Serial.println(k, 10); // Affiche la valeur de k avec 10 chiffres après la virgule
Serial.print("tensionBatterie = ");
Serial.println(tensionBatterie, 10); // Affichage de la tension batterie avec 10 chiffres après la virgule
delay(1000);
}
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
6
En utilisant votre programme, complétez les résultats ci-dessous :
valeurBrute 0 128 256 384 512 640 768 896 1023
tensionBatterie
Quelle est l’allure de la caractéristique du convertisseur ?
___________________________________________________________________________
Dans la suite du TP, le programme ci-dessus sera implanté dans une fonction dont le prototype est le suivant :
void mesureTensionBatterie(void) ;
Cette fonction ne prend et ne rend pas de paramètres car les variables ont été déclarées de façon globale.
// Mesure de la tension de batterie
#define analogPin 3 // Potentiomètre sur l’entrée analogique broche 3
unsigned int valeurBrute = 0; // Variable résultat de la conversion analogique
numérique
float tensionBatterie = 0; // Variable tension de batterie
const float VmaxCAN = 5.0; // Constante tension Max d’entrée convertisseur
const float q = VmaxCAN / 1023; // Constante quantum du convertisseur
const float k = VmaxCAN / 8.4; // Constante coefficient du diviseur de tension
void setup()
{
Serial.begin(9600); // Vitesse de transfert du moniteur serie
}
void loop()
{
mesureTensionBatterie(); // Appel de la nouvelle fonction mesureTensionBatterie
delay(1000);
}
void mesureTensionBatterie(void) // Nouvelle fonction mesureTensionBatterie
{
valeurBrute = analogRead(analogPin); // Lancement de la conversion analogique Numérique
tensionBatterie = (valeurBrute * q) / k; // Calcul de la tension de batterie
Serial.println("--------------------"); // Affichage des résultats
Serial.print("valeurBrute = ");
Serial.println(valeurBrute); // Résultat de la conversion sur le moniteur série
Serial.print("q = ");
Serial.println(q, 10); // Affiche du quantum avec 10 chiffres après la virgule
Serial.print("k = ");
Serial.println(k, 10); // Affiche de k avec 10 chiffres après la virgule
Serial.print("tensionBatterie = ");
Serial.println(tensionBatterie, 10); // Affichage de la tension batterie sur le moniteur
}
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
TP déductif 7
Modifiez le programme et vérifiez qu’il se comporte de la même façon que précédemment.
La fonction mesureTensionBatterie( ) peut être placée dans un autre onglet de l’interface IDE Aduino.
Coupez et collez la fonction dans un nouvel onglet de l’interface IDE Arduino que vous nommerez
mesureTensionBatterie. Téléversez et vérifiez le même comportement que précédemment.
Calcul du pourcentage de charge Pour le calcul du pourcentage de charge, nous allons utiliser les fonctions mathématiques définies
précédemment :
De 6,00V à 7,30V soit [6,00 ; 7,30[
pourcentage = 8,3333 x tensionBatterie - 50
De 7,30V à 7,94V soit [7,30 ; 7,94[
pourcentage = 111,06 x tensionBatterie - 800,88
De 7,94V à 8,40V soit [7,94 ; 8,40[
pourcentage = 43,233 x tensionBatterie - 263,65
Nous allons donc utiliser l’algorithme suivant pour déterminer le pourcentage de charge :
Si tensionBatterie ≤ 6 alors pourcentage = 0 ;
Sinon Si tensionBatterie < 7,3 alors pourcentage = 8,3333 x tensionBatterie - 50 ;
Sinon Si tensionBatterie < 7,94 alors pourcentage = 111,06 x tensionBatterie - 800,88 ;
Sinon Si tensionBatterie < 8,40 alors pourcentage = 43,233 x tensionBatterie - 263,65 ;
Sinon pourcentage = 100 ;
Cet algorithme sera réalisé par la fonction void calculPourcentage(void) qui ne prendra ni ne rendra de
paramètre (void). Le résultat du calcul du pourcentage sera stocké dans une variable globale poucentage de
type float. Cette fonction sera créée dans un nouvel onglet de l’interface IDE Arduino nommé
calculPourcentage et appelée dans la fonction loop.
Complétez et vérifiez le comportement de votre programme sur le moniteur série.
Remarquez que les chaînes de caractères "Alternative 1" à "Alternative 5" permettent de vérifier si le calcul
s’effectue bien avec la bonne formule ; dans le bon test.
void calculPourcentage(void)
{
if (tensionBatterie<6)
{
pourcentage=0;
Serial.println("Alternative 1");
}
else if (tensionBatterie<7.3)
{
pourcentage = (8.3333 * tensionBatterie) - 50;
Serial.println("Alternative 2");
}
else if ( ) / à compléter
{
pourcentage = ; / à compléter
Serial.println("Alternative 3");
}
else if ( ) / à compléter
{
pourcentage = ; / à compléter
Serial.println("Alternative 4");
}
else
{
pourcentage = ; / à compléter
Serial.println("Alternative 5");
}
Serial.print("pourcentage = ");
Serial.print(pourcentage); // Affiche avec 2 chiffres après la virgule par défaut
Serial.println(" %");
}
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
8
Affichage sur le LCD RGB En plus d’afficher le pourcentage de charge, nous allons faire varier la couleur de l’écran du vert au rouge, en
passant par le orange, à mesure que la batterie se décharge et inversement.
La fonction qui permet de changer la couleur de l’écran est lcd.setRGB(rouge,vert,bleu). Les trois paramètres,
codés sur un octet, représentent les composantes RVB. On peut donc, en théorie, réaliser l’ensemble du spectre
du noir au blanc.
Pour notre gestion de charge batterie, nous
laisserons la composante bleue à 0 et nous ferons
varier respectivement les composantes rouge et
verte de 255 à 0 et de 0 à 255 au fur et à mesure
que la batterie se charge.
On remarque donc sur le graphique ci-contre que
les courbes obtenues sont de type linéaire :
y = a . x + b
avec a le coefficient directeur a = ∆y / ∆x
et b l’ordonnée à l’origine
On peut donc en déduire les équations des composantes bleue et verte en fonction de la charge de la batterie :
Bleu = 0
Vert = ((255 - 0) / (100 - 0)) * pourcentage + 0
Vert = 2,55 * pourcentage
Trouver l’équation de la composante Rouge en détaillant votre calcul :
Rouge = __________________________________________________________________
Rouge = __________________________________________________________________
Pour que l’afficheur LCD fonctionne, il faut ajouter les bibliothèques de fonctions relatives à l’afficheur LCD.
L’affichage sera réalisé par la fonction void affichage(void) qui ne prendra ni ne rendra de paramètre (void).
Les résultats du calcul des composantes seront stockés dans trois variables globales rouge, vert, bleu. Cette
fonction sera créée dans un nouvel onglet nommé affichage et appelée dans la fonction loop.
Complétez l’onglet principal :
// Onglet principal
// CAN et Batterie LiPo
#include <Wire.h>
#include "rgb_lcd.h"
rgb_lcd lcd ;
#define analogPin 3 // Potentiomètre connecté sur l’entrée analogique broche 3
unsigned int valeurBrute = 0; // Variable résultat de la conversion analogique numérique
float tensionBatterie = 0; // Variable tension de batterie
const float VmaxCAN = 5.0; // Constante tension Max d’entrée convertisseur
const float q = VmaxCAN / 1023; // Constante quantum du convertisseur
const float k = VmaxCAN / 8.4; // Constante coefficient du diviseur de tension
float pourcentage = 0; // Variable pourcentage de charge batterie de 0.0 à 100.0
unsigned char rouge = 0 ; // Variable composante rouge de 0 à 255
unsigned char vert = 0 ; // Variable composante verte de 0 à 255
unsigned char bleu = 0 ; // Variable composante bleue de 0 à 255
void setup()
{
Serial.begin(9600); // Configuration vitesse de transfert du moniteur série
lcd.begin(16, 2); // Initialisation du LCD 2 lignes de 16 caractères
}
void loop()
{
mesureTensionBatterie();
calculPourcentage();
affichage();
delay(100);
}
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
TP déductif 9
Complétez l’onglet affichage :
Remarquez les espaces après les unités "V " et "% ". Ils permettent d’effacer les éventuelles restes
d’affichages précédents.
Remarquez également que si le moniteur série n’est plus nécessaire alors les lignes qui y font référence
peuvent être mises en // commentaire dans l’ensemble du programme.
Câblez un LCD sur l’un des connecteurs I2C. Testez votre programme : Observez les valeurs affichées sur le
LCD ainsi que les variations de la couleur de l’écran en fonction de la charge de la batterie.
On souhaite améliorer cette fonction de façon à obtenir le format d’affichage suivant, en faisant apparaître des
0 non significatif :
TT EE NN SS II OO NN :: 00 00 88 .. 33 44 VV
CC HH AA RR GG EE :: 00 99 66 .. 99 11 %%
Nous allons donc utiliser l’algorithme suivant pour déterminer le pourcentage de charge :
Si valeur < 10 alors afficher "00" ;
Sinon SI valeur < 100 alors afficher "0" ;
afficher valeur ;
Complétez l’onglet affichage :
Complétez l’onglet affichageAvec0 :
// Onglet affichage
void affichage(void)
{
bleu = 0;
vert = 2.55 * pourcentage;
rouge = ; // à compléter
lcd.setRGB(rouge, vert, bleu) ;
lcd.setCursor(0, 0);
lcd.print(tensionBatterie);
lcd.print("V ");
lcd.setCursor(0, 1);
lcd.print(pourcentage);
lcd.print("% ");
}
// Onglet affichage
void affichage(void)
{
bleu = 0;
vert = 2.55 * pourcentage;
rouge = -2.55 * pourcentage + 255;
lcd.setRGB(rouge, vert, bleu) ;
lcd.setCursor(0, 0);
lcd.print("Tension: ");
affichageAvec0(tensionBatterie);
lcd.print("V");
lcd.setCursor(0, 1);
lcd.print("Charge : ");
affichageAvec0(pourcentage);
lcd.print("%");
}
// Onglet affichageAvec0
void affichageAvec0(float valeur)
{
if(valeur<10)
{
lcd.print("00");
}
else if(valeur<100)
{
lcd.print("0");
}
lcd.print(valeur);
}
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
10
Pour aller plus loin : CGRAM On remarque qu’il y a un espace non exploité sur la ligne du bas de l’écran. On va en profiter pour afficher
graphiquement l’état de la batterie. Pour ce faire, on va utiliser 6 des 8 caractères programmables de
l’afficheur LCD qui correspondent aux codes '0' à '7' de la CGRAM (Character Generator RAM) :
TT EE NN SS II OO NN :: 00 00 77 .. 66 00 VV
CC HH AA RR GG EE :: 00 44 33 .. 11 88 %%
Les 6 pictogrammes à générer sont les suivants : ils seront nommés batterie0 à batterie5 et stockés
respectivement dans les caractères '0' à '5' de la CGRAM.
Pour générer un caractère, il faut utiliser la fonction prédéfinie
lcd.createChar(0,batterie0) où le paramètre 0 est la position du
caractère dans la CGRAM et le paramètre batterie0 est un tableau de
8 octets qui représentent les pixels de notre pictogramme. Voici ci-
contre la syntaxe Arduino du tableau batterie0.
Remarquez que 0b représente la base binaire, que chaque '1'
correspond à un pixel noir et chaque '0' correspond à un pixel blanc.
La création des pictogrammes personnalisés sera effectuée par la fonction void caracteres(void) dans un
nouvel onglet caractere. Cette fonction sera appelée dans la fonction setup.
Dans l’interface Arduino, complétez la fonction setup de l’onglet principal :
Créez l’onglet caractere conformément à l’exemple ci-dessous :
byte batterie0[8] = {
0b01110,
0b11111,
0b10001,
0b10001,
0b10001,
0b10001,
0b10001,
0b11111
};
batterie0
batterie1
batterie2
batterie3
batterie4
batterie5
void setup()
{
Serial.begin(9600); // Configuration vitesse de transfert du moniteur série
lcd.begin(16, 2); // Initialisation du LCD 2 lignes de 16 caractères
caractere(); // Appel de la fonction qui génère les caractères
}
// Onglet caractere
byte batterie0[8] = { // Création d’un tableau de 8 octets nommé batterie0
0b01110, // caractère représentant une batterie vide
0b11111,
0b10001,
0b10001,
0b10001,
0b10001,
0b10001,
0b11111
};
// A Compléter pour chaque caractère batterie1 à batterie5
void caractere(void)
{
lcd.createChar(0, batterie0); // Écriture en CGRAM du caractère représentant une batterie vide
}
TP déductif Arduino - CAN et surveillance de charge d’une batterie LiPo 2 éléments
TP déductif 11
Maintenant que chaque nouveaux pictogrammes sont stockés en CGRAM, il ne reste plus qu’à demander
leur affichage par intervalle du pourcentage de la batterie conformément à l’algorithme ci-dessous :
Positionner le curseur de l’afficheur à gauche de la deuxième ligne ;
Si pourcentage < 10 alors afficher le pictogramme batterie0 ;
Sinon Si pourcentage < 30 alors afficher le pictogramme batterie1 ;
Sinon Si pourcentage < 50 alors afficher le pictogramme batterie2 ;
Sinon Si pourcentage < 70 alors afficher le pictogramme batterie3 ;
Sinon Si pourcentage < 90 alors afficher le pictogramme batterie4 ;
Sinon afficher le pictogramme batterie5 ;
Pour afficher un caractère personnalisé, il faut utiliser la commande lcd.write (et non lcd.print).
Complétez l’onglet affichage :
Remarquez que la valeur 0 pose une ambigüité de type lors de l’écriture du caractère batterie vide. Il faut donc
forcer le type octet non signé avec la syntaxe suivante : lcd.write((unsigned char)0);
Testez votre programme. En fonction du pourcentage de charge de la batterie, observez :
Les valeurs affichées sur le LCD ;
Les variations de la couleur de l’écran ;
Les changement du pictogramme de la batterie.
Faire constater le fonctionnement par votre professeur.
// Onglet affichage
void affichage(void)
{
bleu = 0;
vert = 2.55 * pourcentage;
rouge = -2.55 * pourcentage + 255;
lcd.setRGB(rouge, vert, bleu) ;
lcd.setCursor(0, 0);
lcd.print("Tension: ");
affichageAvec0(tensionBatterie);
lcd.print("V");
lcd.setCursor(1, 1); // à rajouter
lcd.print("Charge: "); // à rajouter
affichageAvec0(pourcentage);
lcd.print("%");
// Complétez avec le code ci-dessous
lcd.setCursor(0, 1); // Position du pictogramme batterie en bas à gauche du LCD
if(pourcentage<10)
{
lcd.write((unsigned char)0); // Affichage du pictogramme batterie0 : Batterie vide
}
else if(pourcentage<30)
{
lcd.write(1);
}
else if(pourcentage<50)
{
lcd.write(2);
}
else if(pourcentage<70)
{
lcd.write(3);
}
else if(pourcentage<90)
{
lcd.write(4);
}
else
{
lcd.write(5); // Affichage du pictogramme batterie5 : Batterie pleine
}
}
