lundi 29 juillet 2019

ESP 32: Utilisation des broches tactiles

L'ESP32 comporte 10 broches tactiles, c'est à dire des entrées qui peuvent détecter si on les touche du doigt. Cette fonctionnalité peut servir, par exemple, à remplacer des boutons poussoirs par des surfaces conductrices. Voyons comment les utiliser.

(Dans le présent tuto, nous programmons l'ESP32 au moyen de l'IDE Arduino. Si vous n'avez jamais programmé l'ESP32 avec l'IDE Arduino, vous pouvez vous référer à ce précédent billet).

Identification des broches tactiles

Les broches qui peuvent être utilisées pour détecter un contact avec le doigt sont:

GPIO 0 (si disponible), GPIO 2, GPIO 4, GPIO 12, GPIO 13, GPIO 14, GPIO 15, GPIO 27, GPIO 32 et GPIO 33.

Le schéma ci-dessous montre la position des broches tactiles sur la carte de développement que j'utilise. Sur cette carte, GPIO 0 n'est pas accessible, car elle est utilisée pour autre chose, ce qui laisse la possibilité d'utiliser jusqu'à 9 broches tactiles.

Notez les deux façons possibles d'identifier les broches dans un sketch: pour lire l'état de la broche GPIO 32, par exemple, on pourra écrire touchRead(32) ou touchRead(T9), avec le même résultat.



Fabrication d'un pavé tactile

On pourrait se contenter de toucher directement les broches de la carte de développement ESP32 mais, pour une meilleure ergonomie, j'ai fabriqué un pavé tactile rudimentaire comportant 3 "boutons", chaque bouton étant constitué d'un petit carré découpé dans une feuille d'aluminium et relié par un fil conducteur à une broche tactile.




Pour mes tests, j'ai branché le bouton de gauche (bouton A) à la broche GPIO 13, le bouton du centre (bouton B) à la broche GPIO 12, et le bouton de droite (bouton C) à la broche GPIO 14.

Premier sketch: affichage des valeurs brutes

Côté programmation, rien de plus facile: la fonction touchRead() retourne un entier qui n'a pas la même valeur selon qu'on touche la broche ou non. Il s'agit de passer le numéro de la broche en argument: touchRead(13) pour lire la broche GPIO 13, etc. Puisque GPIO 13 est la broche tactile numéro 4, on obtiendra le même résultat avec touchRead(T4).

Voici donc un sketch qui affiche dans le moniteur série la valeur retournée par touchRead() pour chacun de nos 3 "boutons":


Lorsqu'on ne touche aucun des carrés conducteurs, touchRead() retourne une valeur située entre 70 et 80 (la valeur exacte peut dépendre de la taille du carré d'aluminium).


Lorsqu'on touche du doigt un carré d'aluminium, la valeur retournée par touchRead() diminue pour atteindre une valeur inférieure à 20. Dans la capture ci-dessous, j'avais le doigt sur le bouton A:


Deuxième sketch: interprétation des valeurs mesurées

Maintenant qu'on a une idée des valeurs retournées par touchRead() selon qu'on touche ou non chaque bouton, la stratégie à adopter est évidente: il s'agit d'établir une valeur seuil en-deça de laquelle nous sommes certains qu'un doigt est en contact avec le bouton. Dans le sketch ci-dessous, j'ai utilisé 30.  Ce sketch affiche chaque seconde le nom de chaque bouton pour lequel il y a contact (nous pouvons toucher plus d'un bouton à la fois, si désiré).

-----------------



Voilà! Il ne reste plus qu'à décider ce que fera votre ESP32 lorsque vous toucherez une de ses broches tactiles.

Yves Pelletier   (TwitterFacebook)

mardi 23 juillet 2019

Livre: Circuits électroniques pour les Kids


Circuits électroniques pour les kids
Øyvind Nydal Dahl
Éditions Eyrolles, 2019
Collection "Pour les kids"

Ce nouveau livre, à ne pas confondre avec "L'électronique pour les kids", du même auteur, propose aux électroniciens néophytes 10 circuits classiques :

- une simple LED qui s'allume
- un jeu d'adresse
- un interrupteur sensitif
- une alarme antivol (buzzer qui s'active à partir d'une certaine intensité lumineuse)
- une veilleuse de nuit  (LED qui s'allume quand il fait noir)
- une LED clignotante
- un feu de signalisation (deux LEDs qui clignotent en alternance)
- un éclairage de fête (plusieurs LEDs clignotantes)
- un piano numérique
- chenillard de LED

Tous ces montages sont réalisés au moyen de composants classiques: résistances, condensateurs, transistors bipolaires, LEDs, photorésistance, et trois circuits intégrés incontournables: le temporisateur NE555, le compteur décimal CD4017, et les portes inverseuses 74C14.

L'approche pédagoque m'a semblé simple et efficace. Dans les premières pages du livre, on explique comment construire sur breadboard un circuit simple qui correspond à un schéma conventionnel. Pour les autres circuits, on ne fournit que le schéma. Le lecteur est donc encouragé à comprendre comment passer de la représentation schématique à un circuit réel.

Pour la plupart des circuits, on fournit d'abord le schéma, on donne quelques recommandations sur la marche à suivre, puis on fournit une liste "d'erreurs fréquentes" à surveiller si le circuit ne fonctionne pas au premier essai. Finalement, on explique pourquoi le circuit se comporte comme il le fait: il ne s'agit donc pas de suivre une recette sans avoir la moindre idée de la théorie qui explique son fonctionnement.

Le livre cible un public jeune (à partir de 10 ans). À mon avis, ça peut tout aussi bien être utile à un adulte, peu importe son âge, qui désire faire ses tous premiers pas en électronique.

Yves Pelletier   (TwitterFacebook)

samedi 20 juillet 2019

Test de vitesse: Arduino Uno / STM32 / ESP8266 / ESP32

Aujourd'hui, j'organise une petite course afin de comparer la vitesse de quatre cartes programmables au moyen de l'IDE Arduino:
  • Arduino Uno (ATmega328P, 8 bits, 16 MHz)
  • Blue Pill (STM32F103, 32 bits, 72 MHz)
  • Wemos D1 R1 (ESP8266, 32 bits, 80 MHz)
  • ESP32 (32 bits, 240 MHz)

Pour ce faire, j'ai utilisé le sketch Arduino Speed Test, une version améliorée d'un programme initialement publié sur arduino.cc. Le fonctionnement de ce programme n'a rien de bien compliqué: il consiste à chronométrer le temps nécessaire pour effectuer une même tâche plusieurs fois de suite, et à calculer la moyenne.

Un aspect intéressant, c'est que nous obtenons une comparaison des performances lorsque les 4 cartes sont programmées de la même manière, au moyen de l'IDE Arduino. La simplicité du "langage" Arduino se fait souvent au détriment de la performance, mais cette contrainte ne devrait pas désavantager une carte par rapport aux autres.

De plus, aucune des 4 cartes ne coûte significativement plus cher que les autres: il s'agit strictement de cartes offertes à très bas prix, et faciles à trouver.

Le tableau ci-dessous présente la durée de chaque test, pour chacune des 4 cartes analysées. Plus le temps mesuré est court, plus la carte est rapide.

Signification des couleurs:

Le plus rapide Le deuxième Le troisième Le plus lent

Tous les temps sont en microsecondes:

Test Uno Blue Pill ESP8266 ESP32
1/F_CPU 0,0625 0,0139 0,0125 0,0042
nop (overload) 0,26 0,07 0,05 0,021
digitalRead 4,842 0,604 0,54 0,141
digitalWrite 4,184 0,626 1,045 0,106
pinMode 4,467 2,211 1,475 2,744
multiply byte 0,632 0,11 0,1 0,037
divide byte 5,412 0,114 0,403 0,049
add byte 0,568 0,098 0,1 0,032
multiply int 1,386 0,082 0,148 0,053
divide integer 14,272 0,096 0,437 0,054
add integer 0,883 0,082 0,135 0,053
multiply long 6,102 0,084 0,148 0,051
divide long 38,662 0,096 0,422 0,049
add long 1,764 0,083 0,135 0,053
multiply float 7,49 0,989 0,738 0,051
divide float 80,187 6,971 3,772 0,224
add float 9,417 1,236 0,683 0,049
itoa() 12,957 NA 2,582 0,699
ltoa() 12,987 NA 9,297 0,699
dtostrf() 80,687 93,321 NA 11,149
random() 92,612 1,571 0,998 0,699
y |= (1<<x) 0,568 0,069 0,11 0,045
bitSet() 0,568 0,069 0,11 0,045


Les résultats sont conformes à ce que la vitesse d'horloge de chaque microcontrôleur nous permettait de prévoir: l'Arduino Uno est le plus lent, et de loin, pour la grande majorité des tests. La STM32 Blue Pill et l'ESP8266 offrent souvent des performances assez comparables, et l'ESP32 est beaucoup plus rapide que tous les autres.

La fréquence d'horloge de l'ESP32 est 15 fois plus rapide que celle de l'Arduino Uno, mais quand vient le temps de diviser deux entiers de type "long", l'ESP32 effectue l'opération...789 fois plus rapidement que le Uno!

Contrairement à ce qu'on pourrait croire à prime abord, l'utilisation d'un ESP32 n'est pas uniquement pertinente dans les applications qui nécessitent du WiFi: on peut très bien choisir de l'utiliser purement à cause de sa vitesse.

Bien sûr, ce n'est pas une raison pour jeter votre Arduino Uno à la poubelle: pour la plupart des applications, sa "faible" vitesse d'exécution est amplement suffisante.

Yves Pelletier   (TwitterFacebook)

mardi 16 juillet 2019

Programmer l'ESP32 avec l'IDE Arduino (premiers pas)

Puisque je me suis beaucoup amusé avec l'ESP8266 au cours des derniers mois, il était inévitable que je fasse un jour ou l'autre la connaissance de son cousin, l'ESP32.

En bref, l'ESP32, c'est la même chose que l'ESP8266: un microcontrôleur 32 bits avec WiFi intégré.  Sauf que l'ESP32 est plus rapide et dispose de plus de mémoire, de Bluetooth intégré, de broches GPIO deux fois plus nombreuses, de beaucoup plus d'entrées analogiques, de deux sorties analogiques, d'un capteur à effet Hall intégré... et même s'il est un tout petit peu plus cher que l'ESP8266, l'ESP32 est quand même offert à un prix inexplicablement dérisoire.

Je me suis procuré sur eBay le module de développement photographié ci-dessus (l'annonce était intitulée "ESP-32S ESP32 NodeMCU Development Board").

Le présent billet constitue une marche à suivre pour programmer ce module au moyen de l'IDE Arduino.

Préparation de l'IDE Arduino

Si l'IDE Arduino n'est pas déjà installé sur votre ordinateur, la première étape consiste à l'installer!

Il faut ensuite ajouter des fichiers supplémentaires qui permettent d'utiliser l'IDE Arduino afin de programmer l'ESP32. Pour ce faire, on accède d'abord au dialogue de préférences de l'IDE, grâce au menu Fichier / Préférences.

Au bas du dialogue de Préférences, dans le champ intitulé "URL de gestionnaire de cartes supplémentaires", vous écrivez cette adresse:

https://dl.espressif.com/dl/package_esp32_index.json


S'il y a déjà d'autres adresses dans ce champ, vous pouvez les séparer par des virgules.
On clique évidemment sur le bouton "OK" pour enregistrer les changements.

On se dirige ensuite vers le gestionnaire de carte, en passant par le menu "Outils / Type de carte / Gestionnaire de cartes"


À l'intérieur du gestionnaire de carte, on localise "esp32 by Espressif Systems". Un clic dans cette zone fait apparaître le bouton "Installer", sur lequel nous allons évidemment cliquer.


Le message "Téléchargement des définitions de cartes" devrait s'afficher dans le bas de la fenêtre. Lorsque c'est terminé, la mention "INSTALLED" apparaît à gauche de "esp32 by Espressif Systems". Vous pouvez maintenant fermer le gestionnaire de carte.


Téléversement d'un premier sketch dans l'ESP32

Le temps est venu de brancher le module ESP32 à un port USB de l'ordinateur. Sur ma carte, une LED rouge s'allume pour indiquer qu'elle est alimentée.

Le menu "Outils / Type de carte" nous donne maintenant accès à une rubrique "ESP32 Arduino" qui comporte près d'une soixantaine de cartes ESP32 différentes! Si vous reconnaissez le nom spécifique de votre carte dans la liste, sélectionnez-le, bien sûr, mais si votre carte vous a simplement été vendue sous le nom de ESP32, le premier choix du menu, intitulé "ESP32 Dev Module", fera parfaitement l'affaire.


Si vous êtes curieux de savoir ce qu'implique le choix d'un modèle de carte plutôt qu'un autre, vous pouvez aller jeter un oeil sur le gitHub d'Arduino core for ESP32. Le fichier boards.txt décrit le contenu du menu "Outils" pour chaque carte: certaines cartes offrent plus d'options avancées que d'autres. De plus, le répertoire "variants" comporte les définitions de broches pour chaque carte.

Par exemple, la plupart des cartes définissent la constante "LED_BUILTIN", qui contient le numéro de la broche permettant de contrôler la LED intégrée à la carte. Puisque cette LED n'est pas nécessairement associée à la même broche pour toutes les cartes, notre choix générique "ESP32 Dev Module" ne définit pas cette constante.


Ensuite, c'est la routine habituelle (en supposant que vous êtes déjà familier avec la programmation d'un Arduino): on sélectionne le port série correspondant à notre carte. Dans mon cas, j'ai dû appuyer sur le bouton "BOOT" de ma carte pour que le port devienne disponible dans le menu. J'ai aussi diminué un peu la vitesse de téléversement ("Upload Speed"), car la valeur par défaut de 921600 bauds semble trop optimiste pour la qualité douteuse de mon câble USB.


L'exemple "WiFiScan" (accessible par le menu "Fichier / Exemples / WiFi / WiFiScan" est un bon moyen de vérifier le fonctionnement correct de votre module ESP32, puisqu'aucune modification à ce sketch n'est nécessaire.


Ma première tentative de téléversement a échoué, avec le message d'erreur "A fatal error occured: Failed to connect to ESP32: Timed out waiting for packet header".


Pas de panique: ce problème très fréquent indique que le dispositif qui permettrait à ma carte de se mettre en mode programmable ne fonctionne pas correctement. Le remède consiste à appuyer sur le bouton "BOOT" de la carte ESP32 au moment où le messsage "Connecting....." apparaît au bas de la fenêtre, et de maintenir ce bouton enfoncé jusqu'à ce que d'autres messages soient affichés ("Chip is ESP32D0WDQ6 (revision 1)").

Cette fois, ça fonctionne...


Le moniteur série affiche la liste des réseaux WiFi détectés.


Essai d'une broche GPIO

Le premier essai d'un microcontrôleur ne pourrait pas être complet sans le clignotement d'une LED grâce à l'exemple Blink (menu "Fichier / Exemples / 01.Basics / Blink ).

Puisque cet exemple utilise la constante "LED_BUILTIN" qui n'est pas définie pour la carte générique "ESP32 Dev Module" que j'ai sélectionnée, j'ai remplacé dans le sketch l'expression "LED_BUILTIN" par le nombre 2 puisque la LED intégrée à ma carte est branchée à la broche GPIO 2.


Résultat: la LED bleue se met à clignoter sur la carte.


J'ai ensuite branché une LED à une broche choisie au hasard  (celle portant l'identification "D21" sur la carte) et je l'ai fait clignoter avec succès en écrivant "digitalWrite(21, HIGH);" dans le sketch.



Compatibilité des sketches écrits pour l'ESP8266

Un aspect important à considérer lorsqu'on a déjà fait quelques projets impliquant l'ESP8266: nos programmes écrits pour l'ESP8266 fonctionneront-ils sans problème sur l'ESP32?

Je n'ai fait qu'un seul test, mais il s'est avéré encourageant: j'ai fait l'essai de mon sketch qui sert à lire les flux RSS, et la seule modification nécessaire a consisté à remplacer l'instruction #include "ESP8266WiFi.h" par #include "WiFi.h". Pour d'autres sketches, je ne serais pas surpris de devoir modifier quelques numéros de broches de temps à autre mais, à première vue, les modifications requises ne semblent pas très nombreuses.

Yves Pelletier   (TwitterFacebook)

samedi 13 juillet 2019

Livre: Programmer en Java pour le Raspberry Pi 3

Programmer en Java pour le Raspberry Pi 3
par Jean-Bernard Boichat
2019, Éditions Eyrolles, collection Serial Makers

Suite à la récente sortie du Raspberry Pi 4, on pourrait croire que je vous parle d'un vieux livre déjà désuet mais non: il a bel et bien été publié cette année (avec sa regrettable manie de sortir ses nouveaux modèles en prenant soin de ne pas les annoncer à l'avance, la fondation Raspberry Pi ne facilite certainement pas la tâche des éditeurs!).

Donc, comme le titre l'indique, il s'agit d'un livre sur la programmation d'un Rasbperry Pi en langage Java.

Un aspect du livre que j'ai beaucoup apprécié, c'est qu'il accorde une grande importance aux capteurs qu'on peut brancher aux broches GPIO du Raspberry Pi:  LED,  relais, photorésistance,  capteur de mouvement infrarouge (PIR),  buzzer, capteur de température DS18B20, télémètre à ultrason HC-SR04, bouton-poussoir, caméra Raspberry Pi... bref, les mêmes joujoux que j'adore moi-même contrôler avec des scripts en Python. De plus, vous y apprendrez comment programmer un serveur web en java, interagir avec une base de donnée SQLite, envoyer automatiquement une photo par email lorsqu'un mouvement est détecté par un détecteur infrarouge PIR...

Tout ça est clairement expliqué, les schémas Fritzing sont en couleur et, bien entendu, de nombreux exemples de programmes sont fournis.

La démarche préconisée par l'auteur consiste à d'abord tester le fonctionnement correct des capteurs grâce à un script en python, puis ensuite d'écrire un programme plus "professionnel" en Java dans l'environnement de programmation Eclipse (sur un ordinateur autre que le Raspberry Pi, roulant sous Windows 10).

Puisque je ne suis pas du tout familier avec Java, tout ça m'a semblé inutilement compliqué: moi, à partir du moment où ça fonctionne correctement avec un script en Python, je suis pleinement satisfait et je m'arrête là! Mais si vous connaissez déjà un peu Java (ou si vous êtes moins paresseux que moi), ce livre pourrait vous intéresser sérieusement.

Extrait du livre en format pdf.

Yves Pelletier   (TwitterFacebook)

mercredi 10 juillet 2019

Et pendant ce temps, dans un blog près de chez vous...(5)



Encore une fois, un petit tour d'horizons de publications récentes par d'autres blogueurs francophones...

RitonDuino:

iTechnoFrance:

MCHobby:

ProjetsDIY:

IDEHack:
Bonne lecture!

Yves Pelletier   (TwitterFacebook)

jeudi 4 juillet 2019

Mesurer une résistance avec un Raspberry Pi...sans ADC

Dans le présent billet, nous allons mesurer la résistance d'un potentiomètre, d'une photorésistance ou d'une thermistance grâce à un Raspberry Pi, en chronométrant le temps de charge d'un condensateur.

Un convertisseur analogique/numérique? Pas besoin!

Lorsqu'on désire lire la valeur d'une résistance avec un Arduino, par exemple, la méthode classique consiste à insérer la résistance inconnue dans un diviseur de tension, puis mesurer le potentiel au moyen d'une entrée analogique (l'entrée analogique étant équipée d'un convertisseur analogique-numérique, ou ADC pour analog-digital converter).

Le Raspberry Pi, toutefois, ne comporte pas d'ADC. Pour mesurer une résistance de cette façon, il faut ajouter un module ADC externe au Raspberry Pi (voir à ce sujet mes billets sur le MCP3008 ou le PCF8591).

La méthode que nous explorons aujourd'hui ne nécessite pas l'utilisation d'un ADC externe.

Le circuit

Le circuit schématisé ci-dessous est présenté dans le livre Raspberry Pi Cookbook, par Simon Monk. En plus de la résistance qu'on désire mesurer au moyen du Raspberry Pi (ici: un potentiomètre de 10 kΩ), le circuit est constitué de deux résistances de 1 kΩ et d'un condensateur de 220 nF.


Comme l'indique le schéma, une des 3 broches du potentiomètre n'est pas branchée au circuit. 

Vous pouvez très bien remplacer le potentiomètre par un autre capteur résistif comme, par exemple, une photorésistance ou une thermistance. Il pourrait être approprié de modifier la capacité du condensateur si votre résistance variable prend des valeurs qui ne sont pas de l'ordre du kΩ.

Principe de fonctionnement

Les entrées du Raspberry Pi sont numériques, ce qui signifie qu'on mesure un niveau logique BAS lorsque la tension est nulle, et un niveau logique HAUT si la tension est de 3,3 V. Mais qu'arrive-t-il si la tension varie de façon à passer progressivement de 0 à 3,3 V? Le niveau logique, initialement BAS, deviendra HAUT à un certain moment pendant l'augmentation de la tension. Le seuil entre BAS et HAUT est d'environ 1,2 V sur le Raspberry Pi que j'ai utilisé, mais ça peut varier d'un Raspberry Pi à l'autre.

Au départ, le condensateur n'est pas chargé, et le potentiel mesuré par l'entrée GPIO 23 du Raspberry Pi est donc nulle. On règle la sortie GPIO 18 au niveau logique HAUT, ce qui a pour effet d'amourcer la charge du condensateur. Plus la résistance du potentiomètre est élevée, plus le condensateur prend du temps à se charger.  À un certain point pendant la charge du condensateur, la tension mesurée par l'entrée GPIO 23 atteint la valeur à partir de laquelle le niveau logique est HAUT. Il s'agit de chronométrer le temps nécessaire pour que le niveau logique de l'entrée GPIO 23 passe de BAS à HAUT pour obtenir une valeur proportionnelle à la résistance du potentiomètre.

Il faut ensuite décharger le condensateur en vue de la prochaine mesure. Pour ce faire, la broche GPIO 23 devient une entrée (son impédance est alors très grande) et la broche GPIO 18 devient une sortie (faible impédance) au niveau logique BAS. Le condensateur se décharge donc à travers la broche GPIO 18.

La résistance de 1 kΩ  branchée à la broche GPIO 18 évite de court-circuiter cette broche si la résistance du potentiomètre devient trop basse. La résistance de 1 kΩ branchée à la broche GPIO 23 protège cette broche en évitant que la décharge du condensateur soit trop rapide.

Script en Python

Toutes les secondes, ce script affiche le nombre de microsecondes nécessaires pour que le condensateur se charge jusqu'à provoquer le niveau logique HAUT sur la broche GPIO 23.


Résultats

En faisant tourner le potentiomètre d'une position extrême à l'autre, j'obtiens un temps de charge qui varie entre 230 microsecondes et 1140 microsecondes environ. La position du potentiomètre a donc un effet évident sur la valeur mesurée.


Lorsque je ne change pas la position du potentiomètre, les résultats sont un peu fluctuants: à une extrémité, on peut lire 230, puis 317 à la lecture suivante...


À l'autre extrémité, on peut aussi bien avoir 1130 que 1228.


Ces fluctuations peuvent s'avérer problématiques si vous avez besoin d'une valeur très précise (il faut alors prendre quelques mesures consécutives et éliminer les valeurs aberrantes). Mais dans de nombreuses applications, ça n'aura pas d'impact majeur.

Une courbe d'étalonnage

Je me suis ensuite amusé à étalonner mon dispositif, afin d'afficher à l'écran la valeur de la résistance en ohms (ce qui est rarement utile, remarquez...). Pour ce faire, j'ai remplacé le potentiomètre par une résistance de valeur connue, et j'ai noté le temps de charge affiché par mon script.

Résistance (kΩ)
Temps (µs)
1,0
230
2,2
320
3,3
436
4,7
580
5,6
680
6,8
820
8,2
965
10
1150


Le résultat est linéaire. Je peux maintenant convertir le temps de charge en résistance en faisant ce calcul:     R = 0,00955 * t - 0,957

(notez que cette équation pourrait ne pas être valable sur un autre Raspberry Pi)

Script en Python donnant la valeur en 

J'ai donc modifié mon script pour qu'il affiche la valeur de la résistance en  plutôt que le temps de charge en µs.



Conclusion

La méthode fonctionne très bien. Les avantages par rapport à l'utilisation d'un module ADC externe sont surtout d'ordre économique: un condensateur et deux résistance, ça ne coûte pratiquement rien.

Certains inconvénients pourraient s'avérer problématiques pour certaines applications:

  • Les valeurs obtenues sont un peu fluctuantes et, occasionnellement, des lectures sont carrément aberrantes.
  • Le temps de charge, pour une résistance de 10 kΩ, est de l'ordre de la milliseconde, et on laisse le condensateur se décharger pendant 5 millisecondes: c'est beaucoup plus lent que la vitesse de lecture typique d'un ADC.
  • La plage des valeurs mesurées demeure inconnue avant d'en avoir fait l'essai, contrairement aux résultats d'un ADC (qui varient de 0 à 1023, par exemple, pour un ADC à 10 bits).
  • Les résultats pourraient être très différents d'un Raspberry Pi à l'autre, puisque la tension constituant la frontière entre l'état logique BAS et l'état logique HAUT n'est pas le même pour deux exemplaires différents.

Yves Pelletier   (TwitterFacebook)

Related Posts Plugin for WordPress, Blogger...