Justifier et clarifier point par point des séquences particulières conduira inévitablement à une impasse si le fonctionnement global du programme n’est pas parfaitement analysé. Ce chapitre fait un petit tour d’horizon pour mettre en place le scénario global. Ensuite seulement on creusera plus finement les entrailles du logiciel pour en accaparer certaines subtilités.
Principe fondamental de mesure de la capacité d’un accumulateur.
Capacité précise généralement la caractéristique de base d’un Condensateur en électricité et s’exprime en Farads, ou plus exactement des sous multiples du genre µF. Dans le cas moins courant d’une batterie d’accumulateur, le vocable fait référence à Capable de fournir de l’énergie. Ce thème a été abordé dans le chapitre n°01 et fourni avec des exemples numériques. La capacité d’une batterie est à comparer à celle d’un réservoir. Ce dernier est rempli avec des molécules d’eau. Pour l’accumulateur, ce sont des électrons qui sont « entassés ». Ouvrez le robinet, le réservoir va se vider plus ou moins rapidement en fonction du débit. Pour un réservoir électrique, il en va strictement de même. Le tuyau devient un circuit filaire conducteur qui va d’une borne à l’autre. Le robinet, une résistance qui freine plus ou moins le débit d’électrons qui pour la circonstance prend le nom de courant ou d’Intensité et s’exprime en Ampère. Pour calculer la capacité d’un réservoir quand on ne peut mesurer ses dimensions, on multiplie le débit du fluide par le temps qu’il faut pour le vider. (Simplifions à outrance et supposons ici que ce débit est constant comme le supposait l’instituteur à l’école primaire quand on calculait le temps mis pour se vider par un lavabo qui fuit !) Dans le cas d’un réservoir électrique, le calcul est totalement analogue :
Notez que si on trouve que vider le réservoir va prendre trop de temps, rien n’interdit en cours de processus, de noter ce qui a été actuellement prélevé, d’augmenter le débit, et de prendre en compte cette nouvelle valeur pour calculer ce qui restait. C’est ici que l’équivalent informatique va se montrer d’une grande souplesse. À chaque 
seconde, (Intervalle de temps choisi par le programmeur pour simplifier les calculs.) le logiciel devra mesurer avec précision l’Intensité. Puis il calculera « le nombre d’électrons » qui sont passés dans le circuit. Il ajoutera ce petit paquet à un total cumulé qui par nature correspondra en fin de décharge à la Capacité de l’accumulateur testé. Chaque petit paquet correspondra à une Ampère Seconde si le courant est exprimé en Ampères. Comme on désire présenter la capacité en Ampères Heures, il suffira de diviser le cumul par 3600 à la fin du processus, ou pour chaque « petit paquet » ce qui permet d’afficher en permanence la capacité actuellement confirmée. Mieux que tout ce verbiage, l’organigramme de la Fig.48 résume le principe de base du processus mis en œuvre dans ce projet. Quand le mesurage débute pour un nouveau test, le nombre d’électrons qui ont été prélevés est nul, donc la capacité est annulée en (1). En (2) la précision de la mesure sera directement impactée par le respect rigoureux d’exactement UNE SECONDE. Pas besoin d’insister sur le soin qui devra être apporté à la précision et la finesse en (3) pour déterminer la valeur instantanée du courant. Notez que « Mesurer » est mis entre guillemets car nous devrons y revenir. Enfin en (4) on ne fait que cumuler à chaque seconde le petit paquet d’électrons qui a traversé le robinet électrique. Pour déterminer le moment où l’accumulateur sera considéré comme entièrement déchargé, on mesure à chaque fois la tension qu’il présente à ses bornes. Au nominal, c’est à dire pendant une très grande majorité de son utilisation, la tension avoisine 12V. Quand la batterie est globalement déchargée, assez rapidement la tension s’effondre. À 11V on peut déjà considérer qu’elle est vidée, et il importe impérativement de la recharger sans traiter. Pour ménager une marge de sécurité, dans le programme la valeur adoptée est de 10,8V sachant que pour passer de 11V à 10,8V sur l’élément de la Fig.1 il ne faut que trois minutes, la résistance interne à ce stade augmentant assez rapidement.
Délai d’exactement UNE SECONDE entre deux mesures.
Fondamental en électronique, en informatique, en robotique, calibrer le temps qui s’écoule est tellement impératif que tous les microcontrôleurs actuels sont pourvus de ressources internes dédiées à cette préoccupation. Exemple : un servomoteur est piloté en envoyant à son asservissement des impulsions de fréquence et de durées calibrées. Nous n’aurons vraiment aucune difficulté à gérer ce paramètre temporel. Dérivé directement de la Fig.48, l’organigramme de la Fig.49 présente en (5) la valeur du test et surtout montre en (7) qu’à chaque mesure l’écran LCD sera rafraîchi pour présenter les nouvelles valeurs du moment. En fonction des options imposées par l’opérateur, 
il sera possible d’indiquer la température du radiateur, la tension actuelle aux bornes de la batterie et bien d’autres paramètres encore. En fonction de ce qui sera écrit sur l’écran LCD, l’ATmega328 prendra des durées différentes. Les calculs pour afficher la valeur de la température ainsi que ceux pour déterminer la grandeur du courant débité également. Pourtant, toute la boucle située entre (2) et son retour en (6) devra présenter une durée d’exactement UNE SECONDE quel que soit le temps passé dans les innombrables instructions situées entre les deux. Avec tout ce que cache le microcontrôleur de la carte Arduino, nous avons à notre disposition plusieurs moyens pour gérer le temps. C’est la fonction millis() du langage C++ compilé de l’IDE qui va faciliter considérablement le chronométrage de la boucle « rose » sans avoir à tenir compte des variations de temps consommés par les instructions situées dans la boucle. Elle fait appel à l’une des particularités de l’ATmega328. Sur sa puce électronique est implanté un compteur binaire totalement indépendant qui est incrémenté par l’horloge interne du circuit intégré mille fois par seconde. Sur un RESET, ce compteur est remis à zéro. L’électronique de ce compteur intègre « 32 Bits », il peut aller jusqu’à 4294967295 sans repasser à zéro. Un rapide calcul montre que suite à un RESET il faut 40 jours pour arriver à le « remplir ». Ce compteur contient le temps qui s’est écoulé depuis un RESET en mS, sa précision est considérable puisque c’est l’horloge à quartz de la carte électronique qui le pilote. La fonction millis() retourne sous la forme d’un unsigned long la valeur lue dans le 
compteur électronique. L’utilisation de cette facilité informatique est résumée sur la Fig.50 qui présente la séquence dédiée que l’on trouvera dans la boucle de base. Le reste de la boucle se charge vérifier si l’opérateur a sollicité le clavier, s’il faut déclencher une alerte etc. Considérons l’organigramme. L’instruction (2) prend la valeur actuelle du compteur et ajoute 1000. Sans trop se creuser les méninges, 1000mS fait bien UNE SECONDE. Lorsque le compteur dépasse cette valeur de Référence, le test en (1) devient positif et tout ce qui se trouve en (3) sera réalisé. À partir du moment où ces instructions consomment moins d’une seconde, le processus sera déclenché avec une précision d’une milliseconde. Ces explications ne sont valides que si la séquence (3) ET le reste de la boucle totalisent une durée inférieure à la seconde. Vu que l’ATmega328 cavale à 16MHz, bien que le programme complet semble « meu meu », l’ensemble des instructions déroulées quelle que soit la combinatoire logicielle reste de très loin inférieur à cette valeur critique et exactement UNE SECONDE sera parfaitement satisfait.
Ajustement précis de la durée de la boucle de base.
Comme nous allons le constater dans ce chapitre, le programmeur ne maîtrise pas toujours le comportement du microcontrôleur, et tout particulièrement quand son programme fait appel à des séquences dont il ignore complètement l’écriture et le déroulement. Ceux qui refusent de se prendre la tête pour des considérations techniques peuvent royalement ignorer ce chapitre, il ne s’adresse qu’à ceux qui aiment bien se creuser les méninges sans justification objective.
Donnant dans la facilité, les explications du chapitre précédent ont fait l’impasse sur des petits détails insignifiants. Vous avez noté sur la Fig.5 que la sortie binaire D3 peut allumer une LED verte à notre convenance. Dans la séquence qui est déclenchée une fois par seconde, on inverse l’état de ce témoin lumineux. Ainsi on voit battre le cœur de la carte électronique, confirmant que le programme ne s’est pas perdu dans une quelconque boucle infinie. Logiquement, cette LED doit changer d’état exactement une fois par seconde. (Sauf quand le programme attend que l’opérateur clique sur le clavier. Dans ce cas pour l’avertir elle clignote très rapidement.) La sortie D3 et GND sont disponibles sur un connecteur HE14. Possédant un périodemètre d’une précision à sept chiffres significatifs, il m’est possible de mesurer avec rigueur la cadence du clignotement. Dans le programme, au lieu d’ajouter exactement 1000 à Référence, on utilise une constante #define T_base_millisecondes.
En ajustant finement sa valeur, on doit pouvoir aboutir à un temps de boucle principal à une milliseconde près donc compris entre 0,999S et 1,001S. Dans ce but, après avoir mesuré la durée exacte de la boucle quand l’équilibre thermique est atteint, (Autant pour l’appareil de mesure que pour la carte Arduino.) on corrige cette constante jusqu’à satisfaction. Par exemple si le temps mesuré pour la période est de 2,008215S, on en déduit que le comptage avec millis() prend 4mS de trop. En affectant la valeur 0.996 à la constante T_base_millisecondes on doit aboutir à une durée de cycle strictement égale à 2,000NNNS. Les décimales NNN sont aléatoires puisque l’on calibre la boucle à une ±1mS. Testant diverses valeurs, le tableau de la Fig.51 présente les résultats obtenus, les µS n’étant pas indiquées car non significatives. On constate qu’au mieux nous serons à ±3mS. Cette différence s’explique par divers phénomènes qui interviennent de façon discrète. Sans que le programmeur n’en soit forcément conscient, plusieurs instructions de l’IDE utilisent les interruptions. C’est en particulier le cas de millis() qui n’est pas forcément prioritaire. Par ailleurs il suffit que le test soit effectué entre deux comptages pour ajouter ou retrancher une unité. Il s’agit d’une relation de phase entre l’horloge quartz et la boucle de base au moment du test. Bref, l’imprécision sera de 3 pour 1000. Dans le pire des cas, c’est à dire pour une grosse batterie, le résultat affiché sera de 49,85Ah au lieu de 50,00Ah. Pas de quoi en faire une crise d’urticaire, d’autant plus que la valeur étant minimisée, nous sommes certains que l’élément testé fait au moins ce qui est affiché. Pour une batterie de 22Ah l’imprécision ne sera plus que de 0,07Ah car il y a proportionnalité.
Mesurer l’intensité avec précision.
Physiquement, mesurer directement la grandeur d’un courant n’est pas élémentaire. On sait faire, en mesurant le champ magnétique qu’il engendre autour du conducteur électrique. Toutefois, cette technique est assez complexe et n’est pas très efficace pour les faibles intensités. Aussi, depuis les débuts de la « fée électricité », on se contente d’intercaler une résistance dans le circuit. La tension aux bornes de cette dernière est mesurée. La loi d’Ohm par le simple calcul I = U / R déduit le courant qui circule. Habituellement, la chute de tension U mesurée aux bornes du shunt R inséré dans le circuit perturbe ce dernier. Pour minimiser cette influence néfaste, on 
choisit pour R une résistance aussi réduite que possible. U est alors très faible et sa mesure impose un voltmètre particulièrement sensible. Au contraire, dans notre cas, R est de forte valeur et à ses bornes nous aurons globalement 12V. Les conditions sont idéales. N’importe quel technicien déduit de la formule utilisée, que la précision du calcul dépendra directement de celle de la valeur de R et de celle du CAN qui sur A1 sera chargé d’évaluer U. Passons en revue les méthodes qui permettent d’affiner la détermination des paramètres pertinents. Les trois composants mis en parallèle sont réputés à 5%. (La résistance théorique sera de 2,666…Ω) Il faut également tenir compte de la chute de tension en ligne et sur le gros bornier. Pour déduire avec précision la valeur réelle de la résistance du circuit complet, on branche une alimentation de laboratoire capable de débiter 5A sous 12V. On mesure à l’extérieur avec un ampèremètre et un voltmètre précis I et U, et la loi d’Ohm permet de calculer la résistance réelle du circuit quand l’ensemble est entièrement câblé. Sur le prototype la valeur déduite fait 2,7Ω. Conclusion : Conduire ces essais n’était pas indispensable, les composants approvisionnés sont très précis et la perte en ligne dérisoire. En tête de programme sont réunies les constantes que vous pourrez modifier à votre convenance. Pour repérer facilement la liste, la première ligne de, celle qui indique la version du logiciel est complétée par //@@@@@@@@@@@@@@@@@@@@@@@@@@@@ et dépasse les autres. Elle est ainsi facilement repérable. Pour pouvoir procéder à des essais en situation sans pour autant consommer 4,5A car vous ne disposez certainement pas d’une alimentation de laboratoire aussi musclée, (Sans compter le gaspillage d’énergie) il suffit d’enlever le fusible. Pour ne pas déclencher une ALERTE de « Pas de FUSIBLE ! » il faut dans le programme désactiver le test. Une deuxième ligne mise en évidence par //@@@@@@… peut donc être validée. Vous effacez les deux « / » pour valider goto Sauter_test_fusible; et le programme acceptera une tension élevée sur A2. Indiquer la valeur précise pour R se trouve dans la directive : #define R_Bloc_thermique 2.7.
Déterminer U avec précision.
Caractéristique fondamentale des convertisseurs analogiques numériques de l’ATmega328 : Il ne faut pas dépasser +5Vcc sur leurs entrées. Comme certaines batteries très chargées peuvent aller jusqu’à +17Vcc, on divise la tension mesurée par quatre. Sur la Fig.5 c’est le pont diviseur constitué de R2, R3, R4 et R5 qui est chargé de cette adaptation. Naturellement, dans le logiciel on multipliera par 4 la valeur numérisée pour obtenir la tension réelle. Le facteur de division sera directement influencé par l’imprécision des résistances. Si celles que vous utilisez font partie d’un même lot de fabrication, la dispersion de caractéristiques sera insignifiante. Par contre, si les composants sont un peu « disparates », la division s’en écartera. Pour assurer une précision logicielle, comme pour tous les autres paramètres critiques, une constante #define Correction_U_Batterie 1.015 sur le prototype corrige finement la valeur du coefficient. Dans le programme, deux lignes de code assez élémentaires assurent la transposition de la valeur CAN_U_Batterie issue de A1 :
Le CAN retourne un entier. La tension U_Batterie sera codée dans un réel. La ligne assure la compatibilité du passage de la valeur numérisée. Une entrée analogique numérise entre 0 et 1023 lorsque la tension qui lui est soumise évolue entre 0 et 5Vcc. Pour obtenir la valeur en volts à partir de la CAN il suffit d’appliquer la proportionnalité : U = CAN / 1023 * 5. Dans notre cas, la tension réelle est quatre fois plus grande. Donc U = (CAN / 1023 * 5) * 4. C’est la ligne ‚ qui se charge de ce petit calcul, dans lequel on a « regroupé » 5 * 4 = 20. La valeur pour Correction_U_Batterie devrait être 1.000 exactement. Bien que les quatre composants soudés sur le circuit imprimé font partie d’un même lot, on constate qu’il faut corriger de 13/1000. C’est que ce coefficient corrige simultanément l’intégralité des dispersions matérielles, et notamment la non linéarité du CAN.
Franchement, si vous ne disposez pas d’un voltmètre de précision pour effectuer les mesures, ne changez pas cette valeur. En revanche, commandez un lot de dix résistances de 10kΩ, elles seront toutes identiques, car issues d’une même fabrication, comme sur le prototype.
Brainstorming … stérile.
Encore un chapitre dans lequel on va jouer au Sudoku. Traduisez : On va se prendre la tête juste pour le plaisir de cogiter. Dans deux chapitres ci-avant on a calculé le courant dans la résistance de décharge R en fonction de la tension à ses bornes. Toutefois, A1 mesure la tension entre GND et +Vcc. En toute rigueur R n’est pas soumise à la totalité de la grandeur mesurée car il y a une chute de tension aux bornes du fusible. Doit-on la prendre en compte ?
Pour répondre à cette question, alimentation de laboratoire encore sollicitée, le fusible a été soumis à divers courants et la tension aux bornes de son support mesurée avec précision. Le tableau de la Fig.52 résume les valeurs générée par ce test. Si on n’en tient pas compte, le débit dépassant légèrement 4A, l’erreur avoisinerait 0,10 pour 12 soit plus de 1%. Étant donné l’application, ce n’est pas très important, il serait parfaitement raisonnable d’oublier ce petit détail. Il se trouve qu’A2 mesure cette tension pour détecter l’absence de fusible et avertir le manipulateur. Comme l’ATmega328 passe son temps « à se tourner les pouces », autant lui faire plaisir et lui proposer un petit zeste de code en plus. Quand le convertisseur analogique numérique est soumis à des tensions aussi faibles, sa linéarisation n’est pas géniale. Aussi, on observe ce qu’affiche l’écran LCD en fonction de ΔU et l’on en déduit un autre coefficient correcteur. Sur le prototype, la directive #define Correction_U_Fusible 1.018 se charge de l’ajustement précis. (Dans les options d’affichage, on peut faire indiquer la valeur mesurée par A2 ce qui permet déterminer la valeur du coefficient de correction.) La séquence de code qui se charge du « traitement fusible » devient :
Dans laquelle U_sur_Fusible est déclaré de type float et 5 / 1023 transpose la CAN en volts.
La suite est ici.
