Dechargeur batt IUT Aisne

Projet du travail de réalisation :
TESTEUR DE BATTERIE A LAMPES (DE 8 A 20V)
Décharge de 30A à courant régulé
Étudiants :
M. CHARLOT Olivier
M. MIKUSIAK Stephen
Professeur : M. SIVERT Arnaud
Promotion 2009/2010
Sommaire :
Étude de la carte déchargeur
Présentation du testeur de batterie
Page : 3
Schéma fonctionnel
Page : 4
Modèle équivalent d'une batterie
Page: 5-6
But de la carte déchargeur
Page : 7
Schéma de câblage réalisé sous ISIS
Page : 8
Schéma de câblage réalisé sous ARES
Page : 9
Étude du transistor TIP122
Page : 10
Étude du convertisseur 12V-5V (7805)
Page : 11
Étude de la mesure du courant
Page : 12
Étude d'un potentiomètre de consigne
Page : 13
Programme du test des transistors
TIP122 un par un
Page : 14
Programme de la régulation du courant
Simulation du programme
Programme linéarisation de la régulation
Simulation du programme de
linéarisation
Page : 15
Page : 16
Page : 17
Page : 18
Programme final de la carte déchargeur
Schéma de simulation sous ISIS
Page : 18-23
Page : 24
La carte micro-contrôleur
La carte afficheur
But de la carte micro
Page : 25
Schéma de câblage réalisé sous ISIS
Page : 27
Schéma de câblage réalisé sous ARES
Page : 28
Liste des entrées-sorties du micro
Page : 29
Configuration du logiciel CCS
Page : 30-33
But de la carte afficheur
Page : 34
Schéma de câblage réalisé sous ISIS
Page : 34
Schéma de câblage réalisé sous ARES
Page : 35
Étude du bouton poussoir BP4
Page : 35
Programme pour le bouton poussoir
Page : 36
Conclusion
Page : 36
Conclusion du déchargeur à lampe
Page : 37
Déchargeur avec ventilateur de
voiture
Page : 37
PRESENTATION:
De nos jours, nous utilisons de plus en plus de système autonome en énergie
électrique. Par conséquent, les batteries sont de plus en plus utilisés (appareil photo,
baladeur mp3, lampe de poche, téléphone portable, capteur pour alarme, réveil, PC
portable, bloc de sécurité, voiture, chariot élévateur électrique, outillage sans fil…).
Donc nous allons réaliser un testeur de batterie qui permettra de tester la capacité
énergétique des batteries. Ce testeur sera réglable.
Objectifs :
Notre objectif est de connaitre la capacité énergétique d’une batterie pour savoir si elle est correcte.
En effet nous avons remarqué que de nombreuse batteries avait une tension correcte et pouvait
fournir de grand courant, mais que leur capacité énergétique était de 5A.H à la place de 50 A.H.
Le but de notre travail est donc de réaliser un testeur de batterie qui sera totalement réglable en
courant de décharge (limitation à 30 Ampères) et aussi en tension minimal car la batterie ne doit pas
se décharger totalement sous peine de destruction, il faudra donc la recharger aussitôt. Notre
système sera autonome car il sera alimenter directement par la batterie et ainsi il pourra être
facilement transportable et sans problème d'alimentation par prise secteur.
I) Présentation de l’alimentation et cahier des charges techniques
- Courant constant de décharge à 30A avec réglage du courant Max .
- Affichage LCD sur 4 lignes pour l'indication simultanée de tous les paramètres essentiels tels que
courant, tension, temps de décharge, et bien entendu capacité énergétique.
- Utilisation simple grâce à 2 potentiomètres qui permettent de régler le courant de décharge et la
tension d'arrêt du système.
- Utilisation d’un interrupteur pour la mise en marche du système.
- Utilisation d'un interrupteur pour la mise en marche des ventilateurs du système.
Remarques : Le testeur sera principalement centrer sur un courant traversant des lampes de type
halogène, bien sûr on pourrait prendre des résistances mais ces dernières devrait être très
encombrantes vu la puissance qu'elles devraient supporter ( 20W à 50 W). De plus, il est possible de
récupérer gratuitement dans une casse auto des lampes de 20W et 50W.
Par ailleurs on utilisera un µControleur qui permettra d'une part de commander des transistors afin
d'alimenter les lampes en fonction de la consigne de courant que l'on désire et d'autre part de réguler
le courant, afficher la tension et la capacité énergétique sur un afficheur LCD. Pour tester une
batterie il suffit de la décharger (en utilisant des lampes halogène pour notre système) et de faire un
calcul d'intégrale du courant en fonction du temps pour connaître sa capacité énergétique. Tout ceci
sera effectué par notre µcontrôleur. Notre déchargeur est prévu pour tester des batteries au plomb de
12V, de 10Ah à 100Ah. Cependant, il sera possible de tester des batteries ayant une tension de 8V à
20V. Maintenant que le cahier des charges est posé, nous allons présenter le schéma fonctionnel de
notre testeur de batterie.
Page - 3 - sur - 38 -
Schéma fonctionnel
Pour présenter simplement un système, on utilise le schéma fonctionnel qui est représenté sur la
figure suivante :
Les ventilateurs ainsi que le système sont commandés par des interrupteurs totalement
indépendants. Les consignes courant et tension seront réalisées par deux potentiomètres. La mesure
du courant permettra de réguler et connaître le courant de décharge de la batterie. La mesure de la
tension permettra la comparaison avec la tension de consigne et donc d'arrêter le système ou non.
Deux ventilateurs permettront de refroidir les transistors et les lampes du système. On remarquera
les différents organes du cahier des charges. Maintenant que la présentation globale a été effectuée.
Nous allons voir comment vont se dérouler les travaux de réalisation.
Le chargeur sera donc réalisé par 3 cartes électroniques.
La carte PIC 16F877
La carte LCD (4 lignes, 32 caractères) raccordée au port RD (connecteur J2).
La carte déchargeur raccordée aux ports A,B et C.
Avant de voir l’étude du déchargeur, nous allons voir comment ce comporte les
batteries.
Page - 4 - sur - 38 -
Modèle électrique équivalent des batteries
Une batterie est un convertisseur électro-chimique. En fonction de sa constitution (valeur, surface
des électrodes, dialectique, type d'électrode...) . Ces paramètres électriques sont bien évidement
différents.
Le modèle le plus simple est une FEM en série avec une résistance c'est le modèle d'un générateur
de tension.
Nous allons utiliser un modèle électrique très dépouillé de la batterie correspondant à une résistance
RB (Ω) et une force électrochimique EB (V). Il faut savoir qu’en fonction de la capacité énergétique
la valeur de RB et EB varie.
Pour connaître ces variations, il est possible de trouver ces courbes très facilement sur internet pour
chaque type d’accumulateur. Il faut savoir aussi que plus la batterie a une capacité énergétique
importante est plus sa résistance interne RB sera faible.
La force électrochimique EB est très facile à connaître car elle correspond à la tension de la batterie
à vide. De même la résistance RB, peut être déterminée par l’équation suivante :
U B moy − E B
IB
Équation 1: RB =
Figure 1 : modèle statique d’une batterie
RB
IB
EB
UB
UB=EB-RB IB
Lorsque la batterie se décharge la tension UB diminue progressivement comme on peut l'apercevoir
sur le graphique ci-dessous, de même pour la charge.
Page - 5 - sur - 38 -
Figure 2:
A partir de la figure précédente, on peut en déduire la capacité énergétique et la chute de tension ∆U
en fonction du courant de decharge par les calculs suivants :
I (A)
Temps de
C= I.t
Tension
Energie fournie
∆U=rI
décharge
décharge
(A.H)
moyenne
(Wh)
r=6mΩ
batterie
Doc. calcul
2,5A
20H
50AH
12,8V
12,5*50=650Wh x
x
20A
2H
40AH
12,4V
12,4*40=496Wh 0,4V 0,12V
50A
0,4H
20AH
12,2V
12,2*20=244Wh 0,6V 0,3V
De plus lors de la décharge, la tension chute rapidement. Puis, lors de la l’arrêt de décharge, la
tension remonte au bout d’un certain temps. Par conséquent, le modèle dynamique de la batterie
sera le suivant.
Figure 3:
r2
r1
EB
Équation 3: UB(p)=
UB
EB
- (r2 +
r1 ) . IB
Page - 6 - sur - 38 -
(1+Cr1p)
(1+Cr1p
On considère à T = 0, que la capacité est chargée donc, la tension aux bornes de Ub en fonction du
temps correspond à l'équation suivante par une réponse indicielle de :
Équation 2: Ub(t) = Eb – r2 Ib – r1 Ib (1 –
)
τ = C. r1
La résistance r2 provoque une chute de tension brutale lors d'un courant constant. Par contre, r1 et C
provoquent une diminution lente de la tension de sortie.
Par conséquent, lors d'une décharge à courant constant, on détermine la résistance r2 :
r2 = ∆ U brutal
Ib
On considère que la force électromotrice Eb est constante.
Ub ( t = τ ) - Ub( t = 0) = -r1Ib( 1UB
) = -r1 Ib . 0,63
r1=∆ U lent
Ib
Ub ( t = τ )=0,63.∆ U lent
IB
t
Il faut savoir que r1, r2 et C changent de valeur en fonction de la capacité énergétique. Ces
paramètres changent en fonction du nombre de cycle de charge, de l'état des électrodes...
En conclusion, il est difficile de connaître l'état de charge de la batterie en mesurant la tension en
charge ou en décharge.
Il n'est pas possible de connaître le bon fonctionnement d'une batterie en mesurant seulement la
tension car la FEM peut être correcte à 12V mais la résistance interne étant importante dû à une
oxydation donc il est impossible de la changer et le courant de décharge n'est pas celui voulu.
Parfois, la capacité énergétique est inférieure à la moitié de la capacité prévue malgré une charge
normale, à cause de la sulfatisation de la batterie.
C’est pour cela qu’il faut un dechargeur pour vérifier l’etat des batteries.
Page - 7 - sur - 38 -
II)Étude de la carte déchargeur :
But de la carte déchargeur :
La carte déchargeur permet :
–
–
–
–
–
–
De régler le courant de décharge
De connaître la mesure du courant grâce à un capteur à effet-hall LEM HASS 50S.
De connaître la tension de la batterie grâce à un comparateur et un filtre sallen-hey.
De réguler le courant grâce à la commutation des résistances (lampes 50W, 20W, 10W, 5 W…)
De convertir une tension 12V en 5V grâce à un convertisseur de type 7805.
De régler la tension d'arrêt de décharge.
La carte déchargeur utilise des lampes pour la consommation de courant et donc décharger une
batterie, ces lampes possèdent une résistance (7.2Ω pour les 20W et 2.8Ω pour les 50W) donc le
courant les traversant sera proportionnel à cette résistance et la tension de la batterie.
Nous avons aussi choisit des résistances de décharge de 100Ω, 50Ω, 20Ω pour avoir une certaine
finesse sur la consommation de courant. En effet, si nous utilisions que des lampes la finesse sur le
courant serait de l'ordre de 1,7A avec nos lampes de 20W.
Ainsi avec une résistance de 100Ω, nous avons une finesse de 120mA (I=U/R => 12/100=120mA)
Page - 8 - sur - 38 -
Schéma de câblage réalisé sous ISIS :
Page - 9 - sur - 38 -
Schéma de câblage réalisé sous ARES :
Echelle 1: En bleu les piste coté cuivre , en rouge les pistes coté composants
Nous pouvons constater que les transistors se trouvent sur le bord de la carte électronique car ces
derniers seront fixés sur un radiateur pour ne pas atteindre leur température de destruction qui est de
80°C.
Les pistes sont larges , en effet elle doivent supportées 30A. De plus, elles seront étamées
Nous allons étudier maintenant le fonctionnement des transistors qui commutent lampes .
Page - 10 - sur - 38 -
Étude du transistor TIP122 :
Le transistor TIP122 ne peut pas dépasser une température de 80°C et un ampérage de 5A donc
nous allons faire des tests pour vérifier si ce transistor peut commuter des lampes de 50W.
Pour cela, nous allons diminuer la résistance pour augmenter l'ampérage et relever la température
du transistor à l'aide d'un capteur de température.
Résistance
15,6 Ω
7,8 Ω
5,1 Ω
3,4 Ω
2,9 Ω
2,6 Ω
Vce
0,97 V
1,05 V
1,14 V
1,23 V
1,30 V
1,37 V
Ic
0,88 A
1,7 A
2,56 A
3,80 A
4,4 A
5A
P calcul
0,85 W
1,78 W
2,91 W
4,94 W
5,72 W
6,85 W
49°C
52°C
62°C
65°C
69°C
Température 42°C
La résistance interne des lampes de 50W que nous utilisons est de 2,8 Ω et nos tests nous ont
montrés que jusque 2,6 Ω le transistor fonctionné correctement.
Nous pouvons donc conclure que les transistors TIP122 sont correctes pour notre système.
Page - 11 - sur - 38 -
Étude du convertisseur 12V-5V (7805) :
Il s'agit d'un régulateur de tension linéaire sous forme de circuit intégré à trois broches. Il est très
simple d'utilisation : il suffit de brancher une broche à la masse, une autre vers la tension
d'alimentation (dans notre système la batterie) et on obtient en sortie une tension régulée de 5V. On
ajoute également des condensateurs en entrée et en sortie servant de réservoir d'énergie, de filtrage
et de découplage (diminution des composantes alternatives des tensions d'entrée et de sortie). Selon
la puissance dissipée par le composant ,en fonction du courant consommé en sortie et de la chute de
tension à ses bornes, il est quelquefois nécessaire de lui adjoindre un dissipateur.
Structure utilisé dans le projet:
Rôle des composants utilisés:
F1: Protège le circuit intégré en cas de surintensité;
D1: Anti-inversion de polarité, elle permet de protéger le régulateur , si la tension de la batterie est
inversé.
C50: réservoir d'énergie
C51: réservoir d'énergie
C52: réservoir d'énergie
C53: réservoir d'énergie
R54: limitation du courant dans la LED
D54: Indique le bon fonctionnement du 7805
Page - 12 - sur - 38 -
Étude de la mesure du courant:
Les amplificateurs-opérationnels seront alimentés entre 0 et 5V car on l'utilisera sa sortie en
analogique sur le micro contrôleur qui n'accepte que du 0-5V.
Étude du comparateur
Ce comparateur sert à amplifier et comparer la valeur de Vout à celle de Vref (capteur de courant à
effet-hall LEM HASS-50). Puis la valeur mesurée sera ensuite convertie par le convertisseur
analogique numérique du µcontrôleur afin d'avoir une valeur exploitable en programmation pour
ensuite l'afficher sur le LCD.
Nous avons ici un amplificateur soustracteur donc R33=R34 ; R35=R36
Donc Vs= Vout.R35 - Vref.R36
R33
Vs=K×(Vout-Vréf) avec K= R35 = 220k = 2,2 amplification de la différence de tension
R33 100k
Étude du filtre sallen-key:
Le but du filtre sallen-key est d'éliminer tous les parasites susceptible de perturbé la mesure du
courant .
Fonction de transfert:
Fréquence de coupure F.C= ½ ×π×RC = 160 Hz
Page - 13 - sur - 38 -
Étude d'un potentiomètre de consigne :
Présentation :
Appelé aussi "Résistance variable", et parfois Rhéostat. Le potentiomètre peut être considéré
comme une résistance dont on peut faire varier la valeur ohmique entre deux points, par simple
action mécanique sur un axe rotatif ou rectiligne.
Nous allons prendre pour notre étude le potentiomètre de consigne de la tension d'arrêt, cependant
le potentiomètre de consigne du courant fonctionne exactement de la même manière.
En programmation il faut récupérer la valeur du potentiomètre grâce au port analogique/numérique
du micro-contrôleur et ensuite afficher cette valeur sur le LCD.
//***************************mesure de la consigne tension**********************
set_adc_channel (3);
delay_us(20);
Uconsigne=read_adc(ADC_START_AND_READ);
if (Uconsigne<80) {Uconsigne=80;}
//limitation : ne peut pas être inférieur à 8V
if (Uconsigne>140) {Uconsigne=140;}
//limitation : ne peut pas être supérieur à 14V
if (Mtension<=Uconsigne) {flagarret=1;}
//arrêt si la tension de la batterie est inférieur
à la consigne
//***************************Affichage de U.consigne****************************
lcd_gotoxy(1,3);
lcd_putc("UA=");
affiche(10,Uconsigne);
Page - 14 - sur - 38 -
Programme du test des transistors TIP122 un par un :
Pour voir si tous nos transistors fonctionnent bien nous avons fait un simple programme qui
commande les résistances une après l'autre, un affichage sur LCD permettra aussi de connaître
quelle résistance est commandée.
x=5000;
//nombre de ms
//************************************************//
//*****
GESTION DU PORT B
*************//
//************************************************//
for(alpha=0x01;alpha<=0x80;(alpha++))
//successivement pin B0,1,2,3,4,5,6,7
{
lcd_gotoxy(1,1);
switch (alpha)
{
case 0x01:printf(lcd_putc,"broche B0 a 1");break;
case 0x02:printf(lcd_putc,"broche B1 a 1");break;
case 0x04:printf(lcd_putc,"broche B2 a 1");break;
case 0x08:printf(lcd_putc,"broche B3 a 1");break;
case 0x10:printf(lcd_putc,"broche B4 a 1");break;
case 0x20:printf(lcd_putc,"broche B5 a 1");break;
case 0x40:printf(lcd_putc,"broche B6 a 1");break;
case 0x80:printf(lcd_putc,"broche B7 a 1");break;
default:printf("erreur");break;
}
output_B(alpha);
//sortie pin=1
delay_ms(x);
//délais de x ms
alpha=(alpha*2)-1;
}
output_B(0);
//port_B=0
//************************************************//
//*****
GESTION DU PORT C
*************//
//************************************************//
for(alpha=0x01;alpha<=0x20;(alpha++))
//successivement pin C0,1,2,3,4,5
{
lcd_gotoxy(1,1);
switch (alpha)
{
case 0x01:printf(lcd_putc,"broche C0 a 1");break;
case 0x02:printf(lcd_putc,"broche C1 a 1");break;
case 0x04:printf(lcd_putc,"broche C2 a 1");break;
case 0x08:printf(lcd_putc,"broche C3 a 1");break;
case 0x10:printf(lcd_putc,"broche C4 a 1");break;
case 0x20:printf(lcd_putc,"broche C5 a 1");break;
default:printf("erreur");break;
}
output_C(alpha);
//sortie pin=1
Page - 15 - sur - 38 -
delay_ms(x);
alpha=(alpha*2)-1;
}
output_C(0);
//delais de x ms
//port_C=0
Programme de la régulation du courant :
La régulation du courant sera faite en bit à bit c'est à dire par incrémentation :
#include "main.h"
#include <LCD420d.C>
#use fixed_io(b_outputs= PIN_B0, PIN_B1,PIN_B2,PIN_B3,PIN_B4, PIN_B5,PIN_B6,PIN_B7 )
#use fixed_io(C_outputs= PIN_C0, PIN_C1, PIN_C2,PIN_C3,PIN_C4,PIN_C5,PIN_C6,PIN_C7 )
#use fixed_io(E_outputs= PIN_E1, PIN_E2 )
unsigned int16 x,alpha,beta;
void main()
{
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
setup_adc_ports(AN0_AN1_AN2_AN3_AN4);
setup_adc(ADC_CLOCK_INTERNAL);
setup_psp(PSP_DISABLED);
setup_spi(FALSE);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
lcd_init();
enable_interrupts(INT_RTCC);
enable_interrupts(GLOBAL);
OUTPUT_B(0);
OUTPUT_C(0);
//resolution du timer0 6.4us
//resolution du timer0 6.4us
while(1)
{
x=10;
//temps d'échantillonnage en ms
for(alpha=0x00;alpha<=0xFF;alpha++)
{
output_B(alpha);
delay_ms(x);
}
for(beta=0x01;beta<=0x3F;beta++)
{
output_C(beta);
delay_ms(x);
for(alpha=0x00;alpha<=0xFF;alpha++)
{
output_B(alpha);
delay_ms(x);
}
}
} //fin du programme
Page - 16 - sur - 38 -
Par simulation on obtient la courbe suivante :
On voit bien que la courbe n'est pas linéaire, car l'incrémentation de alpha provoque une
augmentation du nombre de résistances à commuter, donc une augmentation du courant.
Mais par exemple lorsque alpha=0x0F (4 résistances sont commutées) et passe ensuite à 0x10, une
seule résistance est commutée à présent, il y a donc moins de courant. Il faudra donc passer de 0x0F
à non pas 0x10 mais à une valeur plus grand, c'est ce que nous allons voir dans le programme de
linéarisation de la régulation en courant.
Page - 17 - sur - 38 -
Programme de linéarisation de la régulation du courant:
La linéarité de la régulation a était faite en simulation en mode pas à pas avec le logiciel ISIS, pour
nous aider à choisir de quelle à quelle valeur de alpha nous incrémentons pour ne pas obtenir une
diminution de courant entre les commutations.
while(1)
{
if (alpha==0xFF){alpha=0xFE;}
if (beta==0x3F) {beta =0x3F;}
alpha++;
if (alpha==0x0F){alpha=0x13;}
if (alpha==0x1F){alpha=0x24;}
if (alpha==0x2F){alpha=0x33;}
if (alpha==0x3F){alpha=0x59;}
if (alpha==0x5F){alpha=0x65;}
if (alpha==0x6F){alpha=0x73;}
if (alpha==0x7F){alpha=0xD8;}
if (alpha==0xDF){alpha=0xE4;}
if (alpha==0xEF){alpha=0xF3;}
if ((alpha==0xFF)&&(beta==0x00))
{ alpha=0xD8;
beta=0x01;
}
if ((alpha==0xFF)&&(beta==0x01))
{ alpha=0xD9;
beta=0x03;
}
if ((alpha==0xFF)&&(beta==0x03))
{ alpha=0xED;
beta=0x07;
}
if ((alpha==0xFF)&&(beta==0x07))
{ alpha=0xF3;
beta=0x17;
}
if ((alpha==0xFF)&&(beta==0x17))
{ alpha=0xEE;
beta=0x1F;
}
if ((alpha==0xFF)&&(beta==0x1F))
{ alpha=0xEE;
beta=0x3F;
}
output_B(alpha);
output_C(beta);
}
Page - 18 - sur - 38 -
On obtient, donc le graphique suivant par simulation, qui est linéaire à présent.
Programme final de la carte déchargeur :
#include "chargeur.h"
//#include <LCD.C>
#include <LCD420d.C>
//#SEPARATE block de memoire de 2kilo
#org 0x1F00, 0x1FFF void loader16F877(void) {} //for the 8k 16F876/7
/* port B,C en sortie */
#use fixed_io(b_outputs= PIN_B0, PIN_B1,PIN_B2,PIN_B3,PIN_B4, PIN_B5,PIN_B6,PIN_B7 )
#use fixed_io(C_outputs= PIN_C0, PIN_C1, PIN_C2,PIN_C3,PIN_C4,PIN_C5 )
//#use fixed_io(C_inputs= PIN_C6, PIN_C7)
//liaison RS232
unsigned int16 Mcourant; // valeur du convertisseur analogique
unsigned int8 Mtension; // valeur du convertisseur analogique
unsigned int8 Iconsigne;
unsigned int8 Uconsigne;
unsigned int16 tempsregule;
unsigned int8 dixiemetension;
unsigned int8 MtensionDec;
unsigned int8 DivT;
unsigned int8 alpha,beta; //écrire sur le port B et C
unsigned int8 flagarret;
unsigned int8 flagD3;
Page - 19 - sur - 38 -
unsigned int16 counter1;
unsigned int8 heure;
unsigned int8 minute;
unsigned int8 seconde;
unsigned int16 dixiemeseconde;
unsigned int32 capacite;
unsigned int32 capaciteAH;
unsigned int32 dixcapaciteAH;
const int32 capamax=6000000; //48AH=172800AS*6=
#locate alpha=0x06 // table map port B=adress 06h et portc 07h
//******************************************************************************
//******************************************************************************
//***************** Interruption toutes les 1 ms **************************************
//******************************************************************************
//******************************************************************************
#int_RTCC
// timer0 8bit à 1ms
RTCC_isr()
{
set_timer0(99); //256-(1ms/(0.2us*32))=99 pour 1ms
if (flagarret==1) //****Arret du systeme*******
{
alpha=0x00;
beta=0x00;
output_B(alpha);
output_C(beta);
}
else
{
tempsregule++;
//tempsregule + 1ms
if(tempsregule>=10)
// 10=10 ms Temps d'echantillonage
{
tempsregule=0;
//remise à 0 de tempsregule
dixiemeseconde=dixiemeseconde++;
if (flagD3==1)
{
alpha=0x00;
beta=0x00;
output_B(alpha);
output_C(beta);
}
else
{
//*******régule du courant *********************
if (Mcourant<Iconsigne)
{
if (alpha==0xFF){alpha=0xFE;}
if (beta==0x3F) {beta =0x3F;}
alpha++;
if (alpha==0x0F){alpha=0x13;}
if (alpha==0x1F){alpha=0x24;}
Page - 20 - sur - 38 -
if (alpha==0x2F){alpha=0x33;}
if (alpha==0x3F){alpha=0x59;}
if (alpha==0x5F){alpha=0x65;}
if (alpha==0x6F){alpha=0x73;}
if (alpha==0x7F){alpha=0xD8;}
if (alpha==0xDF){alpha=0xE4;}
if (alpha==0xEF){alpha=0xF3;}
if ((alpha==0xFF)&&(beta==0x00))
{
alpha=0xD8;
beta=0x01;
}
if ((alpha==0xFF)&&(beta==0x01))
{
alpha=0xD9;
beta=0x03;
}
if ((alpha==0xFF)&&(beta==0x03))
{
alpha=0xED;
beta=0x07;
}
if ((alpha==0xFF)&&(beta==0x07))
{
alpha=0xF3;
beta=0x17;
}
if ((alpha==0xFF)&&(beta==0x17))
{
alpha=0xEE;
beta=0x1F;
}
if ((alpha==0xFF)&&(beta==0x1F))
{
alpha=0xEE;
beta=0x3F;
}
output_B(alpha);
output_C(beta);
}
if (Mcourant>Iconsigne)
{
if ((alpha<=0x04)&&(beta<=0x00))
{
output_B(0x00);
output_C(0x00);
}
else
{
alpha--;
if (alpha==0x00) {beta--;}
output_B(alpha);
Page - 21 - sur - 38 -
output_C(beta);
}
}
}
}//fin temps regule
} //fin else flag arret
//*******Faire toutes les secondes (horloge digital h\m\s)************
counter1++;
if ((counter1>1000))
// compteur 1ms*100O= 1s
{
counter1=0;
if (Mcourant>=5) {seconde++;}
//valeur courant 0.83 A
//coef=6
if (seconde>=59) {seconde=0; minute++;}
if (minute>=59) {minute=0; heure++;}
capacite=capacite+Mcourant;
if (capacite>=capamax) capacite=capamax;
//saturation de la capacité
} //fin counter1
}
//fin de l'interruption
//******************************************************************************
//******************************************************************************
//***************** fonction affichage *********************************************
//******************************************************************************
//******************************************************************************
void affiche(unsigned int8 divT,unsigned int16 variable)
{
MtensionDec=variable/divT; //division par 10
dixiemetension=(variable-MtensionDec*divT);
dixiemetension=dixiemetension*10 ;
dixiemetension=dixiemetension/divT;
printf(lcd_putc,"%02u",MtensionDEC);
lcd_putc(".");
printf(lcd_putc,"%1u",dixiemetension);
}
void main()
{
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32); //resolution du timer0 6.4us
setup_adc_ports(AN0_AN1_AN2_AN3_AN4);
setup_adc(ADC_CLOCK_INTERNAL);
setup_psp(PSP_DISABLED);
setup_spi(FALSE);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32); //resolution du timer0 6.4us
lcd_init();
Page - 22 - sur - 38 -
enable_interrupts(INT_RTCC);
enable_interrupts(GLOBAL);
OUTPUT_B(0x00);
OUTPUT_C(0x00);
alpha=0x00;
beta=0x00;
flagarret=0;
Iconsigne=0; //limitation pour 1 A
heure=0;
minute=0;
seconde=0;
dixiemeseconde=0;
capacite=0;
flagD3=1;
//******************************************************************************
//******************************************************************************
//*************************** Programme Principale ********************************
//******************************************************************************
//******************************************************************************
while(1)
{
if (input(PIN_D3)==0)
//appui sur le bouton poussoir
{
if (flagD3==1) {flagD3=0;}
//changer l'état du flagD3
else {flagD3=1;}
delay_ms(100);
}
//**************************mesure tension batterie ****************************
set_adc_channel (0);
delay_us(20);
Mtension=read_adc(ADC_START_AND_READ);
//**************************Affichage U batterie********************************
lcd_gotoxy(1,2);
lcd_putc("U=");
affiche(10, Mtension);
//***************************mesure de la consigne tension**********************
set_adc_channel (3);
delay_us(20);
Uconsigne=read_adc(ADC_START_AND_READ);
if (Uconsigne<80) {Uconsigne=80;}
//limitation : ne peut être inférieur
a 8V
if (Uconsigne>140) {Uconsigne=140;}
//limitation à 14V
if (Mtension<=Uconsigne) {flagarret=1;}
//arrêt si la tension de la batterie
est inférieur à la consigne
//***************************Affichage de U.consigne****************************
lcd_gotoxy(1,3);
lcd_putc("UA=");
affiche(10,Uconsigne);
Page - 23 - sur - 38 -
//Iconsigne=0
if (flagarret==0)
{
//***************************Affichage de la durée *****************************
lcd_gotoxy(1,4);
lcd_putc("Duree=");
lcd_gotoxy(9,4);
printf(lcd_putc,"%02u",heure );
printf(lcd_putc,"h");
printf(lcd_putc,"%02u" ,minute );
printf(lcd_putc,"m");
printf(lcd_putc,"%02u",seconde);
printf(lcd_putc,"s");
//***************************mesure de la consigne courant**********************
set_adc_channel (2);
delay_us(20);
Iconsigne=read_adc(ADC_START_AND_READ);
if (Iconsigne>180) {Iconsigne=180;}
//limitation à 30 Ampères
}
else { ICONSIGNE=0;}
//***************************Affichage de I.consigne****************************
lcd_gotoxy(1,1);
lcd_putc("I.CONSIGNE =");
affiche(6,Iconsigne);
//division par 6
//***************************Mesure courant batterie****************************
set_adc_channel (1);
delay_us(20);
MCourant=read_adc(ADC_START_AND_READ);
//***************************Affichage de I batterie****************************
lcd_gotoxy(10,2); //R=0.135 6 tour ampli de 1.8
lcd_putc("I =");
affiche(6,Mcourant);
//division par 6
//***************************affichage capacité énergétique*********************
lcd_gotoxy(10,3);
lcd_putc("C =");
capaciteAH=capacite/21600; // 3600*divT=3600*6=21600
dixcapaciteAH=(capacite-capaciteAH*21600);
dixcapaciteAH=(dixcapaciteAH*10)/21600;
printf(lcd_putc,"%02Lu",capaciteAH);
lcd_putc(".");
printf(lcd_putc,"%1Lu",dixcapaciteAH);
} //while(1)
} //main
Page - 24 - sur - 38 -
Schéma de simulation réaliser sous ISIS:
Voici le schéma de câblage qui nous a permis de simuler tous les tests que l'on avait besoin .
Page - 25 - sur - 38 -
III ) La carte micro contrôleur avec le PIC 16F877 :
But de la carte micro contrôleur :
La carte micro-contrôleur est un élément indispensable au bon fonctionnement de notre système .
En effet , nous utilisons un afficheur LCD gérer grâce au port D du micro-contrôleur , La régulation
de notre courant de décharge se fera grâce aux ports B et C . Notre courant et tension de consigne
pour le système seront seront traités par le Port A grâce à deux potentiomètres, ce port comprend un
convertisseur analogique numérique qui permet de convertir la valeur mesuré en valeur décimal
compatible avec l'écran LCD. Bien évidement , nous utiliserons de la programmation en langage C
grâce au logiciel CCS (lien) et ce programme sera implanté dans la carte micro a l'aide d'une liaison
RS232.
Page - 26 - sur - 38 -
Schéma de câblage réalisé sous ISIS :
Page - 27 - sur - 38 -
Schéma de câblage réalisé sous ARES :
Schéma ISIS du micro contrôleur 16F877 seul :
Nous utiliserons l'intégralité des ports du µcontrôleur pour notre système, donc nous allons voir
comment sont utilisées chacune des entrées et sorties qu'elles soient analogique ou numérique.
Page - 28 - sur - 38 -
Liste des entrées-sorties du micro contrôleur :
PORT A:
Broche A0=Mesure Tension de la batterie
Broche A1=Mesure Courant de la batterie
Broche A2=Mesure de la consigne de courant
Broche A3=Mesure de la consigne de la tension d'arrêt du système
PORT B :
Les broches B0,1,2,3,4,5,6,7 sont utilisées pour commander les transistors Q1,2,3,4,5,6,7;8
PORT C:
Les broches C0,1,2,3,4,5 sont utilisées pour commander les transistors Q9,10,11,12,13,14
Les broches C6 et C7 ne sont pas utilisées dans notre système car elles servent en réception
et transmission de données qui ne sont pas utilisées dans notre système.
PORT D:
Broche D0= Entrée E de l'afficheur LCD
Broche D1= Entrée RS de l'afficheur LCD
Broche D2= Entrée RW de l'afficheur LCD
Broche D3= Bouton poussoir (pause système)
Broche D4= Entrée D4 de l'afficheur LCD
Broche D5= Entrée D5 de l'afficheur LCD
Broche D6= Entrée D6 de l'afficheur LCD
Broche D7= Entrée D7 de l'afficheur LCD
Page - 29 - sur - 38 -
Pour le bon fonctionnement de notre système, le PIC a besoin d'être configurer correctement à l'aide
d'un programme en langage C qui est compiler grâce au logiciel CCS . Nous allons donc voir
comment créer notre projet correctement.
Lancer le logiciel CCS, puis dans le logiciel faire «clique img dossier / New / Project Wizard»,
Enregistrer votre projet dans un dossier de votre choix.
Une fois fait une fenêtre apparaitra pour la configuration du PIC veuillez configurer comme suit .
Dans général
choisir PIC16F877
Comme on peut le voir sur le schéma électrique du PIC, le quartz est à 20 MHz. Donc écrire
cette fréquence et choisir (higt speed oscilator > 4MHz)
Page - 30 - sur - 38 -
Dans communication
On configurera la liaison RS232 (série) en 8 bits, sans parité à 19200 bauds pour pouvoir
charger le programme dans le PIC avec une simple liaison série. En effet, on peut apercevoir sur le
schéma électrique du PIC le circuit MAX 232 qui permet de faire une liaison série. Cette liaison
permettra de télécharger votre programme avec le programme PICdownloader.exe.
Le PIC16F877 a déjà un programme interne installé par le professeur avec "PIC START plus" et
"MPLAB IDE" qui permet de gérer la liaison série. Mais, pour cela il ne faut jamais écraser le
programme de la liaison série interne. Donc, il faut rajouter dans votre programme la
ligne suivante :
#org 0x1F00, 0x1FFF void loader16F877(void) {} //for the 8k 16F876/7
Page - 31 - sur - 38 -
Dans analog
–
on a besoin de 4 entrées analogiques. Donc, on choisira (A0, A1, A2, A3,A5) mais nous
n'utiliserons pas la broche A5, la résolution se fera en 255 bits
Dans interrupts:
-Timer0 avec résolution de 6,4µs pour un dépassement max de 1,6ms, choisit pour la
période d'échantillonage de 1ms.
Page - 32 - sur - 38 -
Pour l’afficheur (4 lignes, 20 caractères), il faut le programme LCD420.h mais celui-ci
demande d’utiliser le port b, donc il faut modifier le programme pour qu’il fonctionne sur le port d.
Ceci fait il faut maintenant taper les lignes de programme.
Lorsque le programme sera terminer il faudra l'envoyer dans le micro contrôleur comme suit :
-
Brancher le micro contrôleur, au PC avec un câble série RS232,
La carte micro sera alimenté par le 7805 de notre carte déchargeur grâce aux ports qui sont
alimentés,
Lancer PIC downloader avec votre fichier.hex, cliquer sur WRITE et appuyer sur la touche
reset pour télécharger le programme dans la mémoire flash du PIC.
Page - 33 - sur - 38 -
IV)
La carte afficheur LCD et bouton poussoir :
Non utilisées
bouton pause/reprise système
But de la carte afficheur
L'afficheur LCD permet de contrôler visuellement toutes les informations du système, il comporte
les mesures de courant et tension de la batterie ainsi que les consignes courant et tension que nous
lui imposons, la capacité énergétique de la batterie élément le plus important de ce testeur et enfin
un système de « montre » pour compter le temps et ainsi voir très facilement depuis combien de
temps fonctionne le système. Il sera également équipé d'un bouton poussoir qui permettra à tous
moment de stopper la décharge de la batterie tous en gardant les informations sur l'afficheur LCD,
la décharge reprendra lors d'un deuxième appuis sur ce même bouton poussoir, lorsque le système
est en pause le temps est lui aussi en pause ce qui permet vraiment de ne compter que le temps de
décharge de la batterie.
Schéma de câblage de la carte afficheur réalisé sous ISIS
Page - 34 - sur - 38 -
Schéma de câblage de la carte afficheur réalisé sous ARES
Études du bouton poussoir BP4 :
La broche D3 est relié comme on peut le voir sur le schéma ci-dessus au bouton poussoir BP4.
Initialement la broche D3 est relié au +5V avec la résistance R20 mais lors de l'appui sur ce bouton
Page - 35 - sur - 38 -
poussoir RP4 la broche D3 est relié à la masse et est donc à 0V. C'est ce passage de 1 à 0 logique
que nous voulons détecter grâce au micro-contrôleur.
Programme pour le bouton-poussoir BP4 :
Détection de l'appui sur le bouton poussoir :
while(1)
{
if (input(PIN_D3)==0)
{
if (flagD3==1) {flagD3=0;}
else {flagD3=1;}
delay_ms(100);
}
}
//appui sur le bouton poussoir
//changer l'état du flagD3
On utilise ensuite ce flagD3 dans l'interruption pour soit arrêter le système soit pour faire la
régulation.
if (flagD3==1)
{
alpha=0x00;
beta=0x00;
output_B(alpha);
output_C(beta);
}
else
{
Faire la régulation...
}
Par ailleurs le flagD3 sera initialisé à «1» pour que le système soit d'origine en pause.
Conclusion :
Grâce à un simple bouton poussoir et quelques lignes de code nous arrivons à mettre le système en
pause.
Page - 36 - sur - 38 -
Conclusion du déchargeur à lampe :
–
Ce déchargeur nous permet de tester la capacité énergétique de nos batteries (scooter, karting
…) et de vérifier leur bon fonctionnement.
–
Avec le système, tous les ports du micro-contrôleur PIC16F877 sont utilisés avec les 14
résistances à commuter.
–
On pourrait utiliser un multiplexeur 4 entrées et 16 sorties et donc augmenter le nombre de
résistance à commuter pour plus de courant. Par ailleurs utiliser un autre micro-contrôleur comme le
PIC18F6520 qui possède plus de ports.
Mais à la place d’utiliser des lampes, on pourrait utiliser des ventilateurs de voitures que l’on a
récupérer à la casse auto. Il est plus facile de faire varier la charge électrique car elle dépend de la
vitesse de rotation du moteur.
Page - 37 - sur - 38 -
En effet, les ventilateurs de voiture consomment des courants important ; 17A. Pour faire varier la
puissance, il suffit de modifier la tension aux bornes du moteur DC du ventilateur, de ce fait il va
moins vite donc consomme moins de courant.
La tension est facilement modulable par l'intermédiaire d'un hacheur abaisseur et d'une PWM qui
fera varier le rapport cyclique.
La consigne de courant est réglable par l'intermédiaire de 2 boutons poussoirs, par ailleurs comme
sur le déchargeur à lampe une consigne de tension d'arrêt serait indispensable pour ne pas
endommager la batterie.
Pour avoir plus de courant de décharge (supérieur à 17A), il suffit de mettre plusieurs ventilateurs.
Deux ventilateurs permettront de décharger jusque 34A.
Le schéma fonctionnel ressemble au déchargeur à lampe
Mesure courant
Batterie à
décharger
Ventilateur 1
Hacheur
Boutons poussoir
Select
-incrémentation
-décrémentation
µ-contrôleur
Ventilateur 2
Mesure tension
Buzzer
Affichage
L’avantage du déchargeur à ventilateur, c’est donc sa simplicité pour réguler le courant.
L’inconvénient c’est le bruit des ventilateurs. Mais, dans le déchargeur à lampes, il a fallu placer 2
ventilateurs pour évacuer la chaleur des lampes.
Mais la réalisation du déchargeur à ventilateur sera une autre histoire.
Page - 38 - sur - 38 -