Bonjour à tous,
Pour ma première publication sur ce forum voici un petit projet d'instrument de mesure fait maison. Il s'agit d'un milliohmmètre, que je compte utiliser pour mesurer la résistance de fils, interrupteurs, relais... et partir à la chasse aux courts-circuits.
Cette dernière utilisation sera d'ailleurs grandement simplifiée grâce à l'ajout, en plus de l'affichage, d'une sortie audio à la façon de ce qui est présenté par Bertrand, que je remercie, dans sa vidéo sur sa sonde de court-circuit.
J'ai pensé que ça pourrait être intéressant de partager le processus complet de réalisation depuis la conception jusqu'à la fabrication et mise en boîtier en passant par les nombreux tests des différentes parties qui composent le projet. J'écris donc ces lignes à mesure de son avancement et y ajouterai régulièrement du contenu jusqu'à son achèvement.
I : Carte d'entrée analogiqueLa première, et sans doute plus importante partie du système est la carte analogique, qui prend en entrée la « charge » dont on souhaite déterminer la résistance, et qui ressort une tension proportionnelle à celle-ci (si l'on omet toutefois le décalage à l'origine).
En voici le schéma :
Il s'agit là de la V2 qui inclus quelques petites corrections qui se sont avérées nécessaires après la réception et le test des cartes V1 que j'ai manuellement modifiées. Je vous présenterai ça plus tard.
Cette carte repose sur un amplificateur différentiel à base de lm358 qui mesure la tension aux bornes de ce que l'on veut mesurer, tension créée par un courant de mesure de 10mA qui traverse la charge.
Le gain de l'amplificateur est de 100, ce qui résulte en une sortie analogique de 1mV/mOhm.
Il y a évidemment un décalage à l'origine qui sera compensé dans le logiciel du microcontrôleur qui lira la sortie grâce à un convertisseur analogique/numérique (sur la carte de contrôle que je présenterai plus tard, il n'est pas montré ici).
Le tout est alimenté par un transformateur 12V puisqu'il s'agit d'un instrument de table et non portable. Le choix des 12V vient simplement du fait que j'ai plusieurs de ces transformateurs dans les tiroirs, rien de bien critique ici. Le montage fonctionnera aussi sans doute en remplaçant la section alimentation par une pile 9V pour une version portable.
La source de courant de test est simplement composée de deux transistors : Q2 est polarisé par R2 qui le rend passant, le courant d'émetteur passe ensuite à travers R4 et développe une tension à ses bornes. Quand cette tension atteint environ 600mV une partie du courant passe alors dans la jonction base-émetteur de Q1 qui devient passant et « vole » le courant de base de Q2, ceci limite le courant de collecteur (et donc d'émetteur) de Q2 de façon à ce que la tension aux bornes de R4 soit égale à la tension de seuil de la jonction PN base-émetteur de Q1, qui est de plus ou moins 600mV.
Par simple application de la loi d'Ohm on trouve que la valeur de R4 nécessaire pour obtenir un courant de 10mA est de R4 = 600mV/10mA = 60 Ohm. La valeur utilisée de 62 Ohm correspond simplement à la valeur courante la plus proche. Les 600mV étant de toute façon approximatifs il faudra mesurer la valeur réelle obtenue dans le montage pour obtenir la sensibilité précise de la carte et s'en servir de paramètre de calibration dans le logiciel du microcontrôleur.
La section de détection de charge vise à allumer une DEL si une charge est présente en entrée. Elle fonctionne ainsi :
Si la tension différentielle entre E+ et E- reste en dessous d'environ 600mV, Q3 ne sera pas activé, Q4 sera donc passant et D12 brillera. Si par contre la tension différentielle est supérieure à environ 600mV, Q3 deviendra passant et volera le courant de base de Q4 qui sera bloquant et L12 ne brillera pas.
Une tension différentielle d'entrée de 600mV correspond à une charge de 60 Ohm (car je rappelle que le courant traversant la charge est de 10mA). Ainsi L12 brillera si la charge a une résistance inférieure à 60 Ohm, ce qui permettra de détecter un « mauvais court-circuit » même si celui-ci est en dehors de la plage de mesure de l'instrument.
Correction V2 :
Ajout de D13 pour compenser le rehaussement de tension de D8.
La section d'entrée comporte simplement des protections ayant pour but de rendre l'instrument plus robuste car après tout c'est censé être un (modeste) instrument de laboratoire et qui sait comment il sera utilisé et quelles erreurs de branchement absolument stupides il subira.
Les diodes D6 et D7 limitent la tension différentielle positive d'entrée à environ 1,4V ce qui correspond aussi à la tension à vide de l'instrument, ce qui est je l'espère trop faible pour endommager une charge délicate. Ces diodes permettent aussi de protéger l'instrument au cas où une source de tension serait connectée par erreur à son entrée. Dans ce cas les diodes limiteraient la tension à 1,4V, et si cela créé un courant trop important le fusible F1 sautera et déconnectera l'entrée.
D9 quant à elle protège des tensions négatives.
D8 permet d'ajouter un seuil de 0,6-0,7V et ainsi de « remonter » le signal d'entrée car l'amplificateur opérationnel n'est pas très linéaire si ses entrées sont proche de 0V (je n'utilise pas d'alimentation symétrique).
La section de réglage de la tension de décalage permet de compenser à la fois le seuil de D6 mais aussi l'erreur sur la tension d'entrée de l'AOP, qui est une des imperfections du LM358 et présente à divers degrés dans n'importe quel AOP. En réglant une tension qui sera présentée à l'entrée inverseuse de l'AOP on règle le décalage à l'origine de la sortie du montage. Ainsi si on court-circuite les sondes d'entrée on peut régler le potentiomètre de façon à ce que la tension sortie soit confortablement dans la zone linéaire de l'AOP, par exemple 0,5V me semble être une bonne valeur. Toute mesure d'une charge retournera ensuite une tension supérieure ou égale à ce seuil qui correspondra au décalage à l'origine de la sortie de la carte analogique. Ce décalage sera mesuré par le microcontrôleur quand l'utilisateur calibrera le décalage (« fera la zéro ») afin de le supprimer des mesures, et de se débarrasser du même coup de la résistance des pistes, câbles et sondes menant à la charge.
Correction V2 :
Le second AOP du boîtier LM358 est utilisé comme suiveur pour réduire l'impédance de sortie de cette section.
La section amplificateur est un des montages de base des AOP, un simple amplificateur différentiel de gain 100. C6 permet de former un filtre passe bas afin de réduire quelque peu le bruit et R13 et DZ1 limitent la tension de sortie à 4,7V afin qu'elle n'excède pas la tension d'entrée maximale du CA/N (autour de 5V).
Pour cette partie du projet j'ai décidé de concevoir et commander un véritable circuit imprimé, que je vous montrerai un peu plus tard. Les autres parties seront faites manuellement sur carte de prototypage.
Note: La photo de droite montre la carte V1 modifiée manuellement et donc électriquement équivalente à la V2.
Voilà pour le début de ce projet, je me rends compte que j'ai beaucoup écrit car je souhaite partager tous les détails du processus de conception/réalisation/test au fur et à mesure. Je vous remercie si vous m'avez lu jusque-là . N'hésitez pas à me dire si ça vous intéresse et que vous voulez voir la suite ou si vous avez de questions.
En tout cas j'espère que ça pourra aider, inspirer, instruire ou du moins divertir quelques curieux.
Mise à jour du 03/10/2021 :J'ai maintenant monté et testé la carte. En voici un petit résumé.
Pour les tests la carte est alimentée en 16VCC par une alimentation ajustable, dans le véritable montage elle sera alimentée en alternatif par un petit transformateur 12V mais je n'ai pas encore assemblé la carte d'alim. Comme la tension d'alimentation passe par un pont de diodes (D1, D2, D3, D4) on peut l'alimenter en continu ou alternatif sans que ça ait une grande importance.
Tout d'abord j'ai mesuré la tension d'entrée en circuit ouvert, qui représente la tension maximale à laquelle peut être soumise la charge. Sans grande surprise celle-ci est limitée à 1,359V par D6 et D7.
J'ai ensuite mesuré le courant de sortie, qui est celui qui traversera la charge pour en mesurer la résistance. Comme me l'a fait remarquer Papyblue, utiliser une si simple source de courant à transistor créé une source de courant qui dépend de la température, plus précisément avec un coefficient thermique négatif, c'est à dire que si la température augmente le courant diminuera. Ceci est dû principalement au fait que le seuil de la jonction PN base-émetteur de Q1 diminue avec la température, or c'est précisément ce seuil qui détermine la valeur du courant régulé(et la valeur de R4, qui augmente avec la température et renforce cet effet, mais cette cause secondaire est moins importante il me semble).
J'ai procédé à une caractérisation sommaire de la source de courant pour voir si ça pourrait nuire à la précision de l'instrument, sa sensibilité étant proportionnelle au courant de la source.
J'ai donc mesuré le courant au moment de la mise sous tension de la carte, puis après différents intervalles de temps. En voici le résultat :
courant sortie: 9,701mA (mise en marche)
courant sortie: 9,689mA (après 1 min) (-0,124%)
courant sortie: 9,660mA (après 5 min) (-0,42%)
courant sortie: 9,579mA (après 1h) (-1,26%)Ceci est mesuré avec une charge fictive connectée à la sortie 12V de la carte, destinée à alimenter les autre cartes. Le courant de sortie est de 70mA, ce qui correspond à une valeur probablement légèrement surévaluée de la consommation des autre cartes du système. Le but étant d'intégrer dans la mesure l'échauffement généré par le régulateur U1 et le pont de diodes dans le pire cas possible.
Le résultat est que la valeur du courant varie de 1,26 % au bout d'1h, est-ce un problème ? Je dirais oui et non. Certes cela affectera la précision des mesures, mais il m'est d'avis que d'autres facteurs comme la résistance de contact entre les sondes et la charge, la résolution du convertisseur A/N, le bruit dans le système seront susceptibles de causer des erreurs comparables ou supérieures. De plus je n'ai pas besoin d'une précision extrême pour cet instrument.
On pourrait cependant proposer des améliorations pour réduire ce problème. L'une d'elles proposée par papyblue serait de remplacer Q1 par une référence de tension à trois broches comme le TL431, ces référence offrent en effet bien plus de stabilité thermique qu'un simple transistor. Il suifferait de changer la valeur de R4 en conséquence car la tension de la référence n'est pas la même que le seuil de la jonction base-émetteur d'un transistor. Je n'en ai pas en stock et je souhaitais construire un système très simple avec des composants que la plupart des bidouilleurs auront, mais j'ajouterai peut-être quelques références de tension à ma prochaine commande de composants pour faire un essai.
Une autre amélioration serait de retirer le régulateur et le pont de diodes et de les placer sur la carte d'alimentation, on retirerait ainsi la principale source de chaleur de la carte analogique.
Pour la suite du test j'ai voulu simuler l'utilisation finale et mesurer une résistance connue. J'ai donc utilisé une résistance de puissance de valeur nominale 470mOhm et mesurée par une autre méthode (courant de 1A + mesure de la tension aux bornes) comme étant 473mOhm.
J'ai donc d'abord mesuré la tension de sortie avec les sondes court-circuitées pour « faire le zéro » et ai obtenu 320,5mV (après un petit réglage initial du potentiomètre pour être sur une plage correcte. Ce réglage n'a besoin d'être effectué qu'une fois). J'ai ensuite mesuré la tension de sortie avec la charge de test et ai obtenu 774,5mV.
Prenant en compte le courant de test de 9,689mA et en supposant que le gain de l'amplificateur est bien de 100 comme prévu, la sensibilité devrait être de 0,9689mV/mOhm.
En utilisant cette valeur on obtient la valeur mesurée de la charge de test de (774,5-320,5)/0,9689 = 468,9mOhm.
Ce qui est très proche de la valeur mesurée par l'autre méthode et parfaitement dans la marge d'erreur de celle-ci, car le courant de 1A de l'autre méthode va évidemment faire chauffer la charge et augmenter sa résistance, cette méthode la surestime donc légèrement.
Tous ces calculs seront évidemment effectués par le microcontrôleur une fois l'instrument terminé et la valeur en mOhm sera directement affichée.
La charge de test de valeur nominale 470mOhm.
Mise à jour du 07/10/2021 :II : AlimentationPour l'alimentation ce sera un simple transformateur 230V -> 12V avec quelques protections et un interrupteur marche/arrêt. J'ai deux types de transfos dans les tiroirs qui pourraient faire l'affaire, un 2VA et un 12VA. Comme je ne pense pas avoir besoin de plus de 100mA je pense que le 2VA suffira.
Mais avant toute chose faisons un petit bilan de puissance approximatif :
Carte analogique :
10 mA de courant de mesure
2*2 mA pour les DEL (J'ai augmenté la valeur de R1 et R8 à 4,7kOhm, elles étaient trop lumineuses avec 2,2 kOhm/4,5 mA)
5mA pour le régulateur linéaire
1mA pour l'amplificateur
le reste est négligeable
total: 20 mA, mesuré: 19,51 mA
Carte de contrôle :
10 mA pour le microcontrôleur (ATMEGA328P, peut réduire la consommation en utilisant les modes sommeil)
5 mA pour le transducteur piezzo
5 mA pour le régulateur
total: 20 mA
Carte affichage :
afficheur 7 segments :
maximum 1,25 mA par segment * 7 segments * 4 sections + 1,25 mA * 1 virgule (alim 5 V, résistances 680 Ohm, pas sûr que j'utilise les virgules)
total: 36,25 mA
Total système : maximum 76,25 mALe petit transfo devrait donc suffire.
Mise à jour du 08/10/2021 :Et voici la petite carte d'alim :
Rien de bien compliqué ici, un bornier d'entrée 230V, un porte fusible, une thermistance CTN (le composant circulaire noir). En y réfléchissant après coup pas très utile pour un si petit transformateur, je l'ai mise par habitude des plus gros transfos toriques qui ont un courant d'appel très important ayant tendance à faire sauter les fusibles, dans ce cas la thermistance réduit le courant d'appel en présentant une résistance importante à froid, puis cette résistance diminue à chaud et ainsi n'interfère pas avec le fonctionnement de l'alimentation.
Bon, je digresse, le composant bleu est une varistance à oxyde métallique, celle-ci est placée en parallèle du secteur après le fusible. C'est une protection contre les surtensions, la varistance n'est pas conductrice si la tension à ses bornes est inférieure à une tension seuil, ici autour de 470V, et au-delà elle agit comme un court-circuit, ce qui permet de soit atténuer la surtension si elle est de faible énergie, soit de faire sauter le fusible en cas de surtension sur le secteur, évitant ainsi qu'elle ne cause des dégâts à l'instrument (et potentiellement à l'utilisateur).
Un second bornier permet de connecter un interrupteur marche/arrêt en série avec le fil de phase.
Vient ensuite le transformateur, puis le petit composant jaune qui ressemble à un condensateur céramique mais n'en est pas un. Il s'agit d'un petit fusible à thermistance réarmable. Celui-ci est situé du côté secondaire et permet d'éviter la surchauffe du transformateur, ou la destruction du fusible primaire qui n'est pas réarmable, si la sortie de l'alimentation est accidentellement court-circuitée.
Vient ensuite le bornier de sortie qui délivre la tension alternative du secondaire du transformateur.
Évidemment je ne pourrais trop vous répéter de prendre toutes les précautions nécessaires si vous réalisez des montages alimentés depuis le secteur. Une tension de 230 V (et même de 120 V en Amérique du Nord) peut être mortelle, si vous n'êtes pas sûr de vous utilisez un bloc d'alimentation externe vous fournissant directement la basse tension nécessaire à votre montage.
Voici le dessous de la carte, j'ai retiré les pastilles de cuivre entre les conducteurs haute tension afin d'avoir une distance d'isolation supérieure, et recouvert d'une couche de silicone car je n'aime pas trop avoir des conducteurs 230 V à nu, que ce soit pour les phases de tests ou une fois en boîtier.
Mise à jour du 11/10/2021 :Maintenant quelques petits tests pour vérifier le bon fonctionnement de l'alimentation et évaluer ses limites. Tout d'abord la tension de sortie à vide :
17,64 Vca, c'est un peu haut pour du 12 V nominal mais après tout c'est un tout petit transformateur, la régulation ne peut pas être très bonne.
Ensuite plus important : évaluer le courant maximal que peut fournir la carte d'alimentation tout en garantissant la stabilité de la tension à la sortie du régulateur 12 V. Pour cela j'ai réalisé un petit adaptateur sur un bornier qui réplique une version simplifiée l'étage d'alimentation de la carte d'entrée, il contient un pont de diodes, un condensateur de 1000 µF et un régulateur L7812 :
Je le connecte ensuite à la sortie de la carte d'alimentation (enfin plus exactement carte transformateur), connecte une charge fictive en sortie du régulateur (les pinces crocodiles) et connecte également une sonde d'oscilloscope pour observer la tension régulée :
En augmentant le courant de charge par paliers de 10 mA jusqu'à l'apparition d'ondulations, on peut ainsi déterminer le courant maximal que peut fournir ce transformateur en garantissant un bon fonctionnement du régulateur :
90 mA :
100 mA :
D'après ces résultats je vais donc considérer que le courant continu maximal que peut consommer le système en étant alimenté par ce transformateur 2 VA est de 90mA, c'est légèrement inférieur à ce que j'anticipais mais si on se tient au bilan de puissance préliminaire ça devrait suffire. Il est bon de noter que l'oscillogramme reste plat à 90mA après une période de chauffe de l'alimentation de 1h.
Petite vérification de la température du transformateur :
Rien à signaler.
La carte d'alimentation est donc validée jusqu' à 90mA en sortie du régulateur. Passons maintenant à la carte de contrôle et à l'affichage.
Mise à jour du 14/10/2021 :III : AffichageJ'ai hésité pendant un moment entre utiliser un afficheur à cristaux liquides 2à—16 caractères et un afficheur à 7 segments, pour finalement me décider à utiliser le second.
Les raisons sont les suivantes :
_Je n'ai pas besoin d'afficher du texte mais uniquement des chiffres
_L'afficheur 7 segments offre une meilleure lisibilité que l'ACL
_N'en ayant pas précédemment utilisé je voulais essayer
Je vais donc créer un afficheur à partir de 4 éléments OPD-S5621LE-BW.
Les cathodes des 8 diodes (7 segments + virgule) sont connectées ensemble alors que les anodes sont accessibles indépendamment.
La carte de contrôle sera construite autour d'un microcontrôleur ATMEGA328P, raison étant que j'en ai en réserve, que j'ai l'habitude de m'en servir, qu'il est disponible en boîtier DIP, qu'il peut être programmé directement avec du code C++ arduino et qu'il contient toutes les fonctions dont j'ai besoin pour ce projet.
Cependant il ne dispose que de 23 entrées/sorties, ce qui est insuffisant pour contrôler directement les 32 diodes de l'afficheur (4 sections * (7 segments+1 virgule) ). Ne souhaitant pas utiliser de décodeurs/multiplexeurs je vais opter pour un multiplexage temporel en connectant les anodes identiques des 4 sections ensemble et utiliser des transistors aux cathodes pour activer séquentiellement les sections.
On peut ainsi réduire à 12 le nombre de sorties nécessaires pour le contrôle de l'afficheur.
Voici un schéma simplifié à 2 sections pour en illustrer le fonctionnement :
Ici les sorties 1 à 8 permettent d'activer les segments choisis pour afficher les chiffres. Les sorties 9 et 10 permettent d'activer la section 1 ou 2. Ainsi à tout instant seule une section est allumée (mais plusieurs segments le sont). En commutant les sections suffisamment rapidement l'utilisateur verra les 2 allumées à mi-luminosité à cause du temps de réponse de l'oeuil humain.
Le fonctionnement à 4 sections est exactement le même, avec 4 transistors et 4 broches d'activation des sections, l'intensité lumineuse perçue est alors divisée par 4.
Après quelques petits tests j'ai pu déterminer qu'un courant continu de 1,20 mA par segment permet une bonne visibilité et lisibilité. J'ai donc choisi la valeur de 680 Ohm pour les résistances d'anode, ce qui avec une alimentation de 5V et si on considère que la tension des diodes (rouges) est de 1750 mV donne un courant de (5000 mV - 1750 mV) / 680 Ohm = 4,78 mA. Comme chaque section n'est activée qu'un quart du temps le courant moyen est donc de 4,78 / 4 = 1,19 mA.
Les 4,78 mA/segment peuvent être fournis directement par les sorties du microcontrôleur.
Par contre le courant sortant de la broche de cathode d'une section est au maximum de 4,78 x 8 = 38,24 mA. Ce qui est trop pour être conduit a la masse par une sortie du microcontrôleur, d'où la présence des transistors.
J'utilise ici des BC546 qui permettent de contrôler des courants allant jusqu'à 100mA, mais n'importe quel petit transistor NPN générique fera probablement l'affaire.
Maintenant le fonctionnement expliqué voici la carte d'affichage à proprement parler :
Cette carte sera fixée au panneau de façade de l'appareil et ne contient que les afficheurs, les autres composants, résistances et transistors, seront placés sur la carte de contrôle.
Mise à jour du 26/10/2021 :IV : Carte de contrôle
Voici la carte de contrôle du système, elle est basée sur le microcontrôleur 8 bits ATMEGA328P en boîtier DIP.
Il s'agit du même microcontrôleur que celui des cartes Arduino uno et Arduino nano. J'utilise cette particularité pour le programmer en C++ arduino, ce qui facilite le développement du logiciel.
Voici le brochage du microcontrôleur, extrait de sa fiche technique :
Comme j'ai réalisé cette carte « à la volée » directement sur carte de prototypage je n'en ai pas dessiné de schéma complet. La carte est cependant très simple et en voici les caractéristiques :
L'alimentation est fournie par la sortie 12V de la carte d'entrée et est abaissée à 5V par un régulateur linéaire. Quelques condensateurs assurent le filtrage de l'alim. Un petit dissipateur thermique est installé sur le régulateur non pas parce qu'autrement celui-ci surchaufferait, mais pour minimiser ses variations de température et l'influence que cela aurait sur sa tension de sortie, qui est utilisée à la fois comme alimentation mais aussi comme référence de tension du convertisseur A/N.
Des petits condensateurs céramique sont placés au plus près des broches d'alimentation du microcontrôleur (VCC-GND et AVCC-GND) pour limiter au maximum le bruit et assurer un fonctionnement stable.
La broche de référence de tension du convertisseur A/N (AREF) est connectée à l'alimentation 5V à travers un filtre LC de 10uH et 1uF céramique. Là encore au plus près des broches.
On peut voir ici la bobine (composant vert ressemblant à une résistance) entre les broches du microcontrôleur :
Le microcontrôleur commande l'afficheur via le réseau de résistances et de transistors présenté dans la section précédente et implémenté sur cette carte. Un connecteur 12 broches relie la carte de contrôle et la carte d'affichage.
Une sortie du microcontrôleur est également reliée via une résistance au connecteur du transducteur piezzo-électrique. Celui-ci fournit une indication sonore de la valeur mesurée, avec une fréquence plus élevée pour des résistances plus faibles. Ceci est inspiré de la sonde de court-circuit présentée par Bertrand dans une de ses vidéos.
Le transducteur piezzo peut être déconnecté via un interrupteur qui sera installé sur le panneau de commande de l'appareil. Un connecteur pour relier celui-ci est également présent sur la carte de contrôle.
La tension de sortie de la carte d'entrée est mesurée par une entrée analogique (CA/N) du microcontrôleur. Une technique de suréchantillonage par moyenne glissante est utilisée afin d'augmenter la résolution effective de mesure. Un palier du CA/N 10 bits correspondant à 5000/1024 ~== 5 mV, correspondant environ à 5 mOhm, le suréchantillonage permet de mesurer des variations inférieures à 1mV, soit ~== 1mOhm au prix d'une bande passante mesurable réduite, ce qui n'est d'aucune importance ici, les variations du signal étant de toute façon très lentes grâce au filtrage présent sur la carte d'entrée et sur la carte de contrôle (un condensateur de 1uF en entrée).
Après quelques tests je me suis aperçu que le signal d'entrée était « trop » propre et ne disposait pas d'assez de bruit pour faire varier la mesure d'au moins 1 bit. C'est une condition nécessaire pour que le suréchantillonage fonctionne, car celui-ci effectue la moyenne de plusieurs mesures pour en créer une synthétique de résolution supérieure. Mais si tous les échantillons de la moyenne sont égaux, alors la moyenne ne permet pas d'augmenter la précision.
J'ai donc relié la broche d'entrée analogique du microcontrôleur à l'une des broches de contrôle de l'affichage, commutant à quelques centaines de Hertz, via une résistance de forte valeur. Ceci a pour effet d'injecter du bruit dans la mesure et de permettre au suréchantillonage/moyennage d'avoir l'effet désiré.
Après quelques tests j'ai trouvé qu'une amplitude de 20mV crête à crête superposée au signal normal, correspondant à 4 bits de poids faible du CA/N permettait une bonne réponse du système.
Signal d'entrée, mesuré au niveau de la broche CA/N du microcontrôleur, avec ~=20mV c-c de bruit injecté :
Un bouton poussoir sur le panneau de commande, relié à une entrée du microcontrôleur via un connecteur de la carte de contrôle permet de signaler au microcontrôleur d'effectuer la calibration du zéro.
Quelques caractéristiques techniques :
Horloge processeur : Horloge interne RC ~= 8 MHz
Temps de réponse de la mesure affichée : ~= 2s
Fréquence de rafraîchissement de l'afficheur : 250 Hz
Fréquence de rafraîchissement de la valeur affichée : 10Hz
Fréquence sortie piezzo : ~= 500-2000Hz suivant la valeur mesurée
Fréquence échantillonnage : 100 Hz
Facteur de suréchantillonage : x 128
Plage de mesure : ~= 0-3000 mOhm
Résolution de mesure sans suréchantillonage : ~= 5 m Ohm
Résolution de mesure avec suréchantillonage : < 1 m Ohm
Résolution d'affichage : 1 m OhmCes caractéristiques seront complétées par notamment des mesures de stabilité thermique dans la section de tests du système entier.
Mise à jour du 16/06/2022 :V : Le code du microcontrôleurVoici le code principal de l'atmega. Réalisé dans l'IDE Arduino. Une carte Arduino est utilisée comme programmateur et connectée à l'atmega pour y inscrire le programme compilé, mais je suppose que n'importe quel programmateur compatible fera l'affaire.
//Code Milliohmmètre
//Yohann MORANDY 2021
//Licence Attribution - Partage dans les Mêmes Conditions 4.0 International (by-sa)
//https://creativecommons.org/licenses/by-sa/4.0/deed.fr
#include "afficheur.h"
#include "CAN_surechantillonneur.h"
afficheur affichage(4,250); //nombre de sections, fréquence de rafraîchissement
#define TENSION_REFERENCE_CAN 4990.0 //mV
#define SENSIBILITE_SYSTEME 0.9036 //mV/mOhm
#define TENSION_MAXIMALE 3400 //mV
#define RETARD_DEMARRAGE 60000 //ms, temps d'attente pour stabilisation thermique au demarrage
unsigned long tempsDemarrage = 0;
bool chargeConnectee = 0;
// CAN_surechantillonneur(byte broche, unsigned int resolution = 1024, float tensionReference = 5000.0, int echantillons = 16, unsigned int frequenceEchantillonnage = 100);
CAN_surechantillonneur CAN(A0,1024,TENSION_REFERENCE_CAN,128,100);
//assignation des broches
#define BROCHE_PIEZZO 9
#define BROCHE_BOUTON 4
float decalageZero = 0.0;
#define BROCHE_AFFICHAGE_T1 3
#define BROCHE_AFFICHAGE_T2 2
#define BROCHE_AFFICHAGE_T3 1
#define BROCHE_AFFICHAGE_T4 0
#define BROCHE_AFFICHAGE_D1 5
#define BROCHE_AFFICHAGE_D2 6
#define BROCHE_AFFICHAGE_D3 7
#define BROCHE_AFFICHAGE_D4 8
#define BROCHE_AFFICHAGE_D5 10
#define BROCHE_AFFICHAGE_D6 11
#define BROCHE_AFFICHAGE_D7 12
#define BROCHE_AFFICHAGE_D8 13
unsigned long dernierTemps = 0;
unsigned long periode = 100; //ms, periode de m.a.j. de l'affichage
void setup() {
//configuration de l'afficheur
affichage.brochesDiodes[0] = BROCHE_AFFICHAGE_D3;
affichage.brochesDiodes[1] = BROCHE_AFFICHAGE_D4;
affichage.brochesDiodes[2] = BROCHE_AFFICHAGE_D7;
affichage.brochesDiodes[3] = BROCHE_AFFICHAGE_D6;
affichage.brochesDiodes[4] = BROCHE_AFFICHAGE_D5;
affichage.brochesDiodes[5] = BROCHE_AFFICHAGE_D2;
affichage.brochesDiodes[6] = BROCHE_AFFICHAGE_D1;
affichage.brochesDiodes[7] = BROCHE_AFFICHAGE_D8; //changement numerotation sequencielle broches -> numerotation segments ABCDEFG
affichage.brochesTransistors[0] = BROCHE_AFFICHAGE_T1;
affichage.brochesTransistors[1] = BROCHE_AFFICHAGE_T2;
affichage.brochesTransistors[2] = BROCHE_AFFICHAGE_T3;
affichage.brochesTransistors[3] = BROCHE_AFFICHAGE_T4;
//configuration des broches
affichage.init();
pinMode(BROCHE_PIEZZO,OUTPUT);
pinMode(BROCHE_BOUTON,INPUT_PULLUP);
tempsDemarrage = millis();
}
void loop() {
if(millis()-dernierTemps > periode) //effectuer le contenu de la boucle tous les periode ms
{
dernierTemps = millis();
float valeurCAN = CAN.lireValeur();
if(digitalRead(BROCHE_BOUTON) == 0) decalageZero = valeurCAN; //calibration zero
if(valeurCAN < TENSION_MAXIMALE) //charge detectee
{
float valeurAAfficher = abs(valeurCAN-decalageZero)/SENSIBILITE_SYSTEME; //permet soit de court-circuiter pour calibrer puis de mesurer, soit de calibrer avec la charge puis de court-circuiter pour mesurer
affichage.afficherNombreEntier(valeurAAfficher);
tone(BROCHE_PIEZZO,20000.0/(10.0+valeurAAfficher*0.05)); //sortie son piezzo
chargeConnectee = 1;
}
else //pas de charge detectee
{
noTone(BROCHE_PIEZZO); //pas la peine de me casser les oreilles inutilement
affichage.afficherChaine("----");
chargeConnectee = 0;
}
if(millis()-tempsDemarrage < RETARD_DEMARRAGE) //retard au demarrage pour attendre que le systeme soit thermiquement stable, affichage du temps d'attente
{
String chaineAttenteS = (String("0000")+String(RETARD_DEMARRAGE-millis()-tempsDemarrage) );
char* chaineAttente = chaineAttenteS.c_str();
int longueurChaineAttente = chaineAttenteS.length();
char chaineAttenteAffichage[4];
chaineAttenteAffichage[0] = 'A';
chaineAttenteAffichage[1] = 'T';
chaineAttenteAffichage[2] = chaineAttente[longueurChaineAttente-5];
chaineAttenteAffichage[3] = chaineAttente[longueurChaineAttente-4];
affichage.afficherChaine( chaineAttenteAffichage );
}
}
affichage.maj();
CAN.maj();
}
Et voici les prototypes des fonctions permettant de gérer l'afficheur. Je mettrais les fichiers .cpp à disposition en téléchargement séparément, mais je pense le .h suffit à comprendre le fonctionnement global :
//Code afficheur Milliohmmètre
//Yohann MORANDY 2021
//Licence Attribution - Partage dans les Mêmes Conditions 4.0 International (by-sa)
//https://creativecommons.org/licenses/by-sa/4.0/deed.fr
#ifndef afficheur_inclus
#define afficheur_inclus
#include "Arduino.h"
class afficheur
{
public:
byte nombreSections; //maximum 8
byte compteurSections;
byte chiffres[8];
byte virgules;
byte brochesDiodes[8];
byte brochesTransistors[8];
unsigned long int periodeRafraichissement; //en μs, rafraichit une section tous les periodeRafraichissement
unsigned long int tempsDernierRafraichissement;
const byte tableDesCaracteres[18] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71,0b01000000,0b01110000};
void init();
void afficherNombreEntier(unsigned int nombreAAfficher);
void afficherNombreDecimal(float nombreAAfficher);
void afficherChaine(char chaineAAfficher[8]);
bool maj();
afficheur(byte sections, unsigned long int frequenceRafraichissement = 200);
};
#endif
La fonction init() effectue simplement la mise en mode sortie des broches auxquelles sont connectées les DELs de l'afficheur.
La fonction maj() est à exécuter à chaque tour de la boucle principale (présente sous la forme affichage.maj() dans le code principal) et se charge complètement de la gestion de l'afficheur de façon non bloquante.
Ainsi les fonctions afficherNombreEntier(unsigned int), afficherNombreDecimal(float) et afficherChaine(char chaineAAfficher[8]) peuvent être utilisées à n'importe quel endroit du code sans en bloquer l'exécution et sans avoir à se soucier de la gestion bas niveau des DELs, de la synchronisation des segments...etc puisque tout est géré dans maj().
Une autre bibliothèque est mise en place pour la gestion du suréchantillonage du convertisseur A/N :
//Code convertisseur A/N avec surechantillonnage
//Yohann MORANDY 2021
//Licence Attribution - Partage dans les Mêmes Conditions 4.0 International (by-sa)
//https://creativecommons.org/licenses/by-sa/4.0/deed.fr
#ifndef CAN_surechantillonneur_inclus
#define CAN_surechantillonneur_inclus
#include "Arduino.h"
class CAN_surechantillonneur
{
public:
byte brocheEntree;
int nombreEchantillons; //max 256
unsigned int compteurEchantillons;
unsigned int *tableEchantillons;
float mvParPalier;
unsigned long int periodeEchantillonnage; //en μs
unsigned long int tempsDernierEchantillon;
bool maj(); //mesure la tension et met a jour tableEchantillons
float lireValeur(); //fait la moyenne des echantillons et retourne une valeur en mv
CAN_surechantillonneur(byte broche, unsigned int resolution = 1024, float tensionReference = 5000.0, int echantillons = 16, unsigned int frequenceEchantillonnage = 100);
~CAN_surechantillonneur();
};
#endif
Là encore la fonction maj() s'occupe d'échantillonner au bon moment et d'enregistrer les valeurs en mémoire.
La fonction lireValeur() peut alors être exécutée à n'importe quel endroit du code pour obtenir une mesure en mV suréchantillonnée. Dans le cas de ce projet, les mesures sont sur suréchantillonnées 128 fois, la fréquence d'échantillonnage étant de 100 Hz, cela donne un temps caractéristique de réponse d'un peu plus d'une seconde à l'appareil, ce que je trouve parfaitement satisfaisant pour mon utilisation, tout en augmentant considérablement sa résolution effective.
L'exécution de lireValeur() est quasi instantanée (quelques cycles processeur) puisqu'elle n'effectue que des opérations mathématiques, et ne bloque pas l'exécution pour effectuer 128 mesures, celles-ci étant effectuées au bon moment et en avance par maj().
Cette notion de bocage est importante car si effectuer une mesure bloquait le processeur pendant plus d'une seconde, il serait impossible de gérer simultanément l'afficheur qui demande plusieurs centaines d'interactions par secondes de façon continue.
À suivre!
Yohann
Code source du projet :
https://moutonceleste.fr/s/KCMqiitt5iGAkGr/download/code_miliohmmetre.7zhttps://forum.bidouilleur.ca/index.php?action=dlattach;topic=1039.0;attach=3693Yohann MORANDY 2021
Licence Attribution - Partage dans les Mêmes Conditions 4.0 International (by-sa)
https://creativecommons.org/licenses/by-sa/4.0/deed.fr
