En guise de bilan annuel, je me suis amusé à compiler, parmi les 76 (!) billets publiés dans ce blog en 2019, ceux qui ont reçu le plus grand nombre de visites.
Notez que la méthodologie employée favorise nettement les billets publiés en début d'année, qui ont profité de plusieurs mois pour accumuler des visites... Néanmoins, je constate que je suis toujours aussi nul pour prévoir lesquels de mes articles attireront l'attention du plus grand nombre de lecteurs!
1) Module RFID-RC522 et ESP8266 / ESP32
(2 février, 1174 visites)
Le projet complet consiste à afficher dans une page web la liste des 10 plus récentes détections d'un tag RFID, mais certaines informations devraient vous être utiles pour n'importe quel autre projet impliquant un module RFID-RC522 branché à un ESP8266 ou à un ESP32. La première version de cet article ne concernait que l'ESP8266; pendant l'été, je l'ai mis à jour pour que ça fonctionne aussi avec l'ESP32.
2) Kit: fréquencemètre et testeur de quartz
(4 janvier, 1049 visites)
Compte tenu de son prix très bas, les possibilités de cet appareil de mesure facile à assembler sont plutôt intéressantes.
3) Programmer l'ESP32 avec l'IDE Arduino
(16 juillet, 897 visites)
L'ESP32 a certainement été le sujet principal de mes billets publiés pendant l'été. Ce premier billet montre surtout comment ajouter les cartes ESP32 aux menus de l'IDE Arduino grâce au gestionnaire de cartes.
4) Afficheur LCD 2 X 16 et cartes STM32
(2 janvier, 824 visites)
Le tout premier billet de l'année 2019 concernait l'utilisation d'un classique LCD affichant 2 lignes de 16 caractères avec la carte STM32 Blue Pill (programmée avec l'IDE Arduino). Presqu'un an plus tard, je viens tout juste de terminer la mise à jour de cet article, afin d'inclure d'autres modèles de cartes STM32 (la Nucleo, entre autres).
5) Microscope USB
(5 juin,752 visites)
Malgré son bas prix, ce microscope très facile à utiliser m'a permis d'obtenir rapidement des images assez impressionnantes. Son support, difficile à ajuster avec précision, est son principal inconvénient.
6) Utilisation du moteur pas à pas d'un lecteur de CD (Arduino)
(8 juin, 746 visites)
Dans le passé, j'avais déjà publié plusieurs articles concernant l'utilisation d'un moteur pas à pas, mais celui-ci s'intéresse de façon spécifique à la réutilisation du mécanisme responsable de positionner le laser d'un lecteur de CD/CD-ROM/DVD. On obtient un mécanisme qui permet un déplacement linéaire très précis, mais limité à environ 4 cm.
7) Écran OLED SH1106 I2C et Arduino
(26 janvier, 728 visites)
En utilisant une bibliothèque appropriée, ce n'est pas trop difficile d'écrire et de dessiner sur ce petit écran monochrome. Un peu plus tard dans l'année, j'ai aussi appris à l'utiliser avec les cartes STM32, ESP8266 et ESP32, ainsi qu'avec le Raspberry Pi.
8) Écran couleur KMR-1.8 SPI (ST7735) et Arduino
(10 février, 557 visites)
Encore mieux que l'écran OLED mentionné plus haut: ce petit écran qui affiche des images en couleur d'excellente qualité. Ce premier test a fait au moyen d'une carte Arduino Uno, mais j'ai nettement préféré mes essais subséquents effectués au moyen de cartes plus puissantes et fonctionnant à un niveau logique plus approprié (STM32, ESP8266 et ESP32, Raspberry Pi).
9) Mesure d'une tension analogique avec une carte STM32
(10 mars, 553 visites)
Écrit à l'origine pour la carte Blue Bill, cet article a ensuite été mis à jour pour utiliser le nouveau STM32 Core dans l'IDE Arduino, avec un choix de cartes plus diversifié. Vous y apprendrez entre autres choses comment régler l'ADC à sa pleine résolution de 12 bits.
10) Synthèse sonore avec Mozzi et Arduino (1)
(7 avril, 552 visites)
Mozzi est une bibliothèque spécialement conçue pour générer des sons avec votre Arduino: nous pouvons contrôler la fréquence, le volume, le timbre, l'enveloppe, et même faire de l'échantillonnage (sampling). J'ai fait tous mes tests avec un Arduino Uno, mais je soupçonne qu'une carte plus rapide permettrait plus de possibilités: à essayer en 2020, peut-être...
On se reparle en 2020, si par hasard je trouve quelque chose d'autre à raconter. 😃
Yves Pelletier (Twitter, Facebook)
vendredi 27 décembre 2019
mardi 17 décembre 2019
Mon beau sapin, roi des forêts, que j'aime tes transistors!
Voici une petite décoration qu'on peut s'amuser à fabriquer soi-même: un mini sapin de Noël en carton, décoré par 16 LEDs clignotantes.
Circuit
Ne cherchez pas d'Arduino dans ce projet: le circuit est constitué de 2 transistors PNP, 2 condensateurs de 47 µF, 16 LEDs et 12 résistances.
Q1 et Q2 sont des transistors PNP. J'ai utilisé deux transistors 2N3906, mais n'importe quelle paire de transistors PNP à usage général devrait faire l'affaire.
La fréquence de clignotement des LEDs peut être modifiée en changeant les condensateurs C1 et C2, ou les résistances R1 et R2. Avec des condensateurs de 33 µF, par exemple, le clignotement sera plus rapide.
La valeur de la résistance de protection de chaque LED a été déterminée par expérimentation, afin que la luminosité des LEDs soit à peu près uniforme d'une couleur à l'autre. Sur le schéma, les LEDs L1, L12, L15 et L16 sont bleues, L3, L4, L13, L14 sont rouges, L5, L6, L11, L12 sont vertes et L7, L8, L9, L10 sont jaunes.
Le nombre de LEDs peut être diminué, ou augmenté (à la condition de ne pas dépasser le courant maximal que peuvent supporter vos transistors).
J'ai conçu le circuit pour une alimentation de 5 V, mais ça tolère très bien 9 V (ça ne fonctionne plus très bien en bas de 4 V).
Les 8 LEDs de gauche sont toutes allumées en même temps pendant que les 8 autres LEDs sont éteintes, et vice versa.
Tests sur breadboard
Un test du circuit sur breadboard vous permettra de modifier des résistances si certaines LEDs sont trop ou pas assez lumineuses, si la fréquence de clignotement ne vous convient pas, etc.
Fabrication de l'arbre
Je ne m'éterniserai pas sur le découpage d'une forme d'arbre dans un morceau de carton...
Ensuite, on perce des trous pour y insérer nos LEDs, et on construit le circuit à l'arrière de l'arbre, qui se transforme rapidement en un entremêlement de spaghetti, que vous pourrez ensuite choisir de dissimuler, ou pas...
À lire aussi
D'autre projets pour Noël: une boîte cadeau lumineuse, animée et musicale ainsi qu'un répertoire de mélodies de Noël à jouer par l'Arduino.
Yves Pelletier (Twitter, Facebook)
Ne cherchez pas d'Arduino dans ce projet: le circuit est constitué de 2 transistors PNP, 2 condensateurs de 47 µF, 16 LEDs et 12 résistances.
(vous pouvez cliquer sur le schéma du circuit pour l'agrandir)
Q1 et Q2 sont des transistors PNP. J'ai utilisé deux transistors 2N3906, mais n'importe quelle paire de transistors PNP à usage général devrait faire l'affaire.
La fréquence de clignotement des LEDs peut être modifiée en changeant les condensateurs C1 et C2, ou les résistances R1 et R2. Avec des condensateurs de 33 µF, par exemple, le clignotement sera plus rapide.
La valeur de la résistance de protection de chaque LED a été déterminée par expérimentation, afin que la luminosité des LEDs soit à peu près uniforme d'une couleur à l'autre. Sur le schéma, les LEDs L1, L12, L15 et L16 sont bleues, L3, L4, L13, L14 sont rouges, L5, L6, L11, L12 sont vertes et L7, L8, L9, L10 sont jaunes.
Le nombre de LEDs peut être diminué, ou augmenté (à la condition de ne pas dépasser le courant maximal que peuvent supporter vos transistors).
J'ai conçu le circuit pour une alimentation de 5 V, mais ça tolère très bien 9 V (ça ne fonctionne plus très bien en bas de 4 V).
Les 8 LEDs de gauche sont toutes allumées en même temps pendant que les 8 autres LEDs sont éteintes, et vice versa.
Tests sur breadboard
Un test du circuit sur breadboard vous permettra de modifier des résistances si certaines LEDs sont trop ou pas assez lumineuses, si la fréquence de clignotement ne vous convient pas, etc.
Fabrication de l'arbre
Je ne m'éterniserai pas sur le découpage d'une forme d'arbre dans un morceau de carton...
Ensuite, on perce des trous pour y insérer nos LEDs, et on construit le circuit à l'arrière de l'arbre, qui se transforme rapidement en un entremêlement de spaghetti, que vous pourrez ensuite choisir de dissimuler, ou pas...
À lire aussi
D'autre projets pour Noël: une boîte cadeau lumineuse, animée et musicale ainsi qu'un répertoire de mélodies de Noël à jouer par l'Arduino.
Yves Pelletier (Twitter, Facebook)
mercredi 11 décembre 2019
Graphique en temps réel des mesures prises par un Arduino
Cet article a été mis à jour le 7 juillet 2022 (compatibilité Python 3).
Notre objectif consiste à présenter à l'écran d'un ordinateur, sous la forme d'un graphique cartésien qui se met à jour en temps réel, les mesures prises par un capteur branché à une carte Arduino, elle-même branchée à un des ports USB de l'ordinateur. Pour ce faire, nous utiliserons un script en langage Python ainsi que les bibliothèques matplotlib et pyserial.
Circuit
Pour mes tests, j'ai utilisé en guise de capteur un simple potentiomètre contrôlant la tension à l'entrée A0 d'un Arduino Uno. Il va sans dire qu'en modifiant légèrement le sketch, vous pouvez remplacer ce potentiomètre par n'importe quel type de capteur.
Sketch de l'Arduino
Comme vous pouvez le constater ci-dessous, le sketch versé dans l'Arduino est plutôt bref. Il se limite à attendre la réception d'un message UART en provenance de l'ordinateur. Chaque fois que l'Arduino reçoit le caractère 'e", il envoie à l'ordinateur un message constitué de la mesure de l'entrée analogique A0 et de l'instant où cette mesure à été prise. Ce temps est remis à zéro lors de la réception du caractère 'i'.
-
-
Installation des bibliothèques matplotlib et pyserial
Le script en Python qui sera exécuté sur l'ordinateur aura besoin de la bibliothèque pyserial, qui gère la communication série, et de la bibliothèque matplotlib, qui se spécialise dans la présentation de données sous forme de graphique.
On peut les installer avec pip:
pip install pyserial
pip install matplotlib
Vous trouverez quelques informations supplémentaires concernant l'utilisation de ces bibliothèques dans ces récents billets, qui sont les précurseurs du présent article: Communiquer en Python avec un Arduino (pyserial) et Rasbperry Pi, présenter les mesures sous forme de graphique cartésien (matplotlib).
Script en Python pour l'ordinateur
Le script fait d'abord un scan des ports série actifs: s'il n'en trouve qu'un seul, il établit la connexion avec ce port. S'il en trouve plusieurs, il demande à l'utilisateur de choisir le port série souhaité. L'utilisateur doit également choisir à quelle fréquence les mesures seront prises (dans mon cas, le maximum était d'environ 1000 mesures par seconde; au-delà, le graphique ne se trace pas).
Le script envoie ensuite le message 'i' à l'Arduino afin de remettre son chronomètre à zéro, et lui envoie régulièrement le signal 'e' pour lui demander une nouvelle mesure, qui est ajoutée au graphique.
-
-
Résultat
Voici un exemple de graphique tracé pendant que je tourne lentement le bouton du potentiomètre.
À lire aussi
Puisque je m'intéresse beaucoup à l'utilisation de l'Arduino comme instrument de mesure scientifique, d'autres façons d'arriver à des résultats similaires ont été explorés dans le passé: graphique cartésien sur Android (avec MIT App Inventor 2), graphique cartésien sur écran OLED SH1106 ou sur LCD Nokia 5110, envoi des données à un tableur (Excel ou Libre Office Calc), utilisation d'une carte Leonardo pour écrire les données dans un tableur, utilisation du service en ligne Carriots, enregistrement des données sur une carte SD, etc.
Personnellement, j'aime bien la solution abordée dans le présent article: il est facile de modifier le script Python selon nos besoins.
Yves Pelletier (Twitter, Facebook)
Circuit
Pour mes tests, j'ai utilisé en guise de capteur un simple potentiomètre contrôlant la tension à l'entrée A0 d'un Arduino Uno. Il va sans dire qu'en modifiant légèrement le sketch, vous pouvez remplacer ce potentiomètre par n'importe quel type de capteur.
Sketch de l'Arduino
Comme vous pouvez le constater ci-dessous, le sketch versé dans l'Arduino est plutôt bref. Il se limite à attendre la réception d'un message UART en provenance de l'ordinateur. Chaque fois que l'Arduino reçoit le caractère 'e", il envoie à l'ordinateur un message constitué de la mesure de l'entrée analogique A0 et de l'instant où cette mesure à été prise. Ce temps est remis à zéro lors de la réception du caractère 'i'.
-
-
Installation des bibliothèques matplotlib et pyserial
Le script en Python qui sera exécuté sur l'ordinateur aura besoin de la bibliothèque pyserial, qui gère la communication série, et de la bibliothèque matplotlib, qui se spécialise dans la présentation de données sous forme de graphique.
On peut les installer avec pip:
pip install pyserial
pip install matplotlib
Vous trouverez quelques informations supplémentaires concernant l'utilisation de ces bibliothèques dans ces récents billets, qui sont les précurseurs du présent article: Communiquer en Python avec un Arduino (pyserial) et Rasbperry Pi, présenter les mesures sous forme de graphique cartésien (matplotlib).
Script en Python pour l'ordinateur
Le script fait d'abord un scan des ports série actifs: s'il n'en trouve qu'un seul, il établit la connexion avec ce port. S'il en trouve plusieurs, il demande à l'utilisateur de choisir le port série souhaité. L'utilisateur doit également choisir à quelle fréquence les mesures seront prises (dans mon cas, le maximum était d'environ 1000 mesures par seconde; au-delà, le graphique ne se trace pas).
Le script envoie ensuite le message 'i' à l'Arduino afin de remettre son chronomètre à zéro, et lui envoie régulièrement le signal 'e' pour lui demander une nouvelle mesure, qui est ajoutée au graphique.
-
-
Résultat
Voici un exemple de graphique tracé pendant que je tourne lentement le bouton du potentiomètre.
À lire aussi
Puisque je m'intéresse beaucoup à l'utilisation de l'Arduino comme instrument de mesure scientifique, d'autres façons d'arriver à des résultats similaires ont été explorés dans le passé: graphique cartésien sur Android (avec MIT App Inventor 2), graphique cartésien sur écran OLED SH1106 ou sur LCD Nokia 5110, envoi des données à un tableur (Excel ou Libre Office Calc), utilisation d'une carte Leonardo pour écrire les données dans un tableur, utilisation du service en ligne Carriots, enregistrement des données sur une carte SD, etc.
Personnellement, j'aime bien la solution abordée dans le présent article: il est facile de modifier le script Python selon nos besoins.
Yves Pelletier (Twitter, Facebook)
mercredi 4 décembre 2019
Communication nRF24L01 avec cartes ESP32 et ESP8266
Voyons aujourd'hui comment utiliser un émetteur-récepteur nRF24L01 avec un ESP32 ou un ESP8266. Les modules nRF24L01 permettent d'établir une communication radio entre deux microcontrôleurs à une fréquence de 2,4 GHz.
Préparation de l'IDE Arduino
Puisque l'ESP sera programmé avec l'IDE Arduino, les cartes appropriées doivent avoir été installées dans l'IDE au moyen du gestionnaire de cartes (voir les instructions détaillées pour l'ESP8266 et pour l'ESP32).
La bibliothèque RF24 mise au point par TMRh20 doit également être installée (ça peut se faire par l'entremise du gestionnaire de bibliothèques). Il s'agit de la même bibliothèque qu'on utilise pour une carte Arduino conventionnelle (Uno, etc.).
Connecteurs du module nRF24L01
La figure ci-contre pourrait se révéler utile pour identifier les connecteurs du module nRF24L01.
Certains modèles, généralement verts, comportent 10 broches alors que d'autres, généralement noirs, en comportent 8.
La répartition des broches sur deux rangées ne permettent pas l'insertion du module sur une breadboard.
Connexions du nRF24L01 à l'ESP32
J'ai branché le module nRF24L01 à ma carte ESP32 de la façon suivante:
Connexions du nRF24L01 à l'ESP8266
J'ai branché le module nRF24L01 à ma carte Wemos D1 Mini de la façon suivante:
Sketch #1: émission d'un message
Voici un sketch minimaliste pour l'émission d'un message (il s'agit du même sketch déjà publié pour l'utilisation d'un nRF24L01 avec un Arduino, seule la numérotation des broches est différente).
-
-
Sketch #2: réception d'un message
Voici un deuxième sketch minimaliste qui rapporte dans le moniteur série tous les messages reçus par le nRF24L01.
-
-
Sketch #3: réception d'un message et publication dans une page web
Ce troisième exemple utilise également les possibilités WiFi de l'ESP32 ou de l'ESP8266: les messages reçus par le nRF24L01 sont publiés dans une page web. On peut ainsi concevoir un réseau de microcontrôleurs qui transmettraient les mesures de leurs capteurs à un ESP32 ou un ESP8266 qui se chargerait de transmettre les données par WiFi (les données peuvent être émises par une carte Arduino ou par un carte STM32, par exemple).
-
-
L'adresse IP de l'ESP32 ou de l'ESP8266 s'affiche dans le moniteur série au démarrage du programme.
Vous trouverez sur ce blogs d'autres tutos qui vous guideront dans l'utilisation d'un module nRF24L01 avec un Arduino, un STM32, un Raspberry Pi, un MSP430 Launchpad.
Dans le passé, j'ai aussi utilisé le nRF24L01 pour fabriquer un véhicule téléguidé et un système MIDI sans fil.
Finalement vous trouverez sur cette page une liste de tous les articles impliquant l'ESP32 et l'ESP8266.
Yves Pelletier (Twitter, Facebook)
Préparation de l'IDE Arduino
Puisque l'ESP sera programmé avec l'IDE Arduino, les cartes appropriées doivent avoir été installées dans l'IDE au moyen du gestionnaire de cartes (voir les instructions détaillées pour l'ESP8266 et pour l'ESP32).
La bibliothèque RF24 mise au point par TMRh20 doit également être installée (ça peut se faire par l'entremise du gestionnaire de bibliothèques). Il s'agit de la même bibliothèque qu'on utilise pour une carte Arduino conventionnelle (Uno, etc.).
Connecteurs du module nRF24L01
La figure ci-contre pourrait se révéler utile pour identifier les connecteurs du module nRF24L01.
Certains modèles, généralement verts, comportent 10 broches alors que d'autres, généralement noirs, en comportent 8.
La répartition des broches sur deux rangées ne permettent pas l'insertion du module sur une breadboard.
Connexions du nRF24L01 à l'ESP32
J'ai branché le module nRF24L01 à ma carte ESP32 de la façon suivante:
- GND du nRF24L01 - GND de l'ESP32
- VCC du nRF24L01 - 3V3 de l'ESP32
- CE du nRF24L01 - D4 de l'ESP32
- CSN du nRF24L01 - D5 de l'ESP32
- SCK du nRF24L01 - D18 de l'ESP32
- MOSI du nRF24L01 - D23 de l'ESP32
- MISO du nRF24L01 - D19 de l'ESP32
- IRQ du nRF24L01 - Pas branché
Connexions du nRF24L01 à l'ESP8266
J'ai branché le module nRF24L01 à ma carte Wemos D1 Mini de la façon suivante:
- GND du nRF24L01 - GND de l'ESP8266
- VCC du nRF24L01 - 3V3 de l'ESP8266
- CE du nRF24L01 - GPIO4 (D2) de l'ESP8266
- CSN du nRF24L01 - GPIO5 (D1) de l'ESP8266
- SCK du nRF24L01 - GPIO14 (D5) de l'ESP8266
- MOSI du nRF24L01 - GPIO13 (D7) de l'ESP8266
- MISO du nRF24L01 - GPIO12 (D6) de l'ESP8266
- IRQ du nRF24L01 - Pas branché
Sketch #1: émission d'un message
Voici un sketch minimaliste pour l'émission d'un message (il s'agit du même sketch déjà publié pour l'utilisation d'un nRF24L01 avec un Arduino, seule la numérotation des broches est différente).
-
-
Sketch #2: réception d'un message
Voici un deuxième sketch minimaliste qui rapporte dans le moniteur série tous les messages reçus par le nRF24L01.
-
-
Sketch #3: réception d'un message et publication dans une page web
Ce troisième exemple utilise également les possibilités WiFi de l'ESP32 ou de l'ESP8266: les messages reçus par le nRF24L01 sont publiés dans une page web. On peut ainsi concevoir un réseau de microcontrôleurs qui transmettraient les mesures de leurs capteurs à un ESP32 ou un ESP8266 qui se chargerait de transmettre les données par WiFi (les données peuvent être émises par une carte Arduino ou par un carte STM32, par exemple).
-
-
L'adresse IP de l'ESP32 ou de l'ESP8266 s'affiche dans le moniteur série au démarrage du programme.
En recopiant cette adresse dans un navigateur web, on atteint une page web qui indique le message le plus récent reçu par le module nRF24L01.
À lire également
Dans le passé, j'ai aussi utilisé le nRF24L01 pour fabriquer un véhicule téléguidé et un système MIDI sans fil.
Finalement vous trouverez sur cette page une liste de tous les articles impliquant l'ESP32 et l'ESP8266.
Yves Pelletier (Twitter, Facebook)
dimanche 1 décembre 2019
Analyse d'une communication SPI
Développé par Motorola dans les années 1980, SPI (acronyme de Serial Peripheral Interface) est un protocole de communication série conçu pour permettre à un microcontrôleur (le "maître") de communiquer à haute vitesse avec un ou plusieurs périphériques (les "esclaves").
Une communication SPI implique 4 lignes de transmissions: MOSI, MISO, SCLK et CS.
1) MOSI (Master Out, Slave In) est utilisée pour la transmission de données du microcontrôleur vers le périphérique. Elle est contrôlée par le microcontrôleur maître.
2) MISO (Master In, Slave Out) est utilisée pour la transmission de données du périphérique vers le microcontrôleur. C'est la seule des quatre lignes qui est contrôlée par le périphérique esclave.
3) SCLK (Serial Clock) transmet un signal d'horloge généré par le microcontrôleur maître. Il sert à synchroniser l'esclave avec le maître. Contrairement à la communication UART, la communication SPI est donc une communication synchrone.
4) CS ou SS (Chip Select ou Slave Select) est utilisée pour activer un esclave. Contrairement à MOSI, MISO et SCLK, qui sont partagées par tous les périphériques esclaves branchés au microcontrôleur maître, chaque périphérique esclave doit avoir sa propre ligne CS. La ligne CS d'un périphérique doit être mise au niveau logique BAS pour que ce périphérique tienne compte des messages envoyés par le maître sur la ligne MOSI. De cette façon, le maître communique avec un esclave à la fois.
C'est une communication full duplex, ce qui signifie que des données circulent du maître à l'esclave et de l'esclave au maître au même moment.
Sur un Arduino Uno, MOSI est la broche 11, MISO est la broche 12 et SCLK est la broche 13. On utilise souvent la broche 10 pour CS, mais ce n'est évidemment pas obligatoire puisque plusieurs lignes CS différentes seront nécessaire en présence de plusieurs périphériques esclaves.
Des exemples de périphériques qui communiquent en SPI
Voici quelques exemples de périphériques qui communiquent en SPI avec un Arduino: lecteur de cartes SD, module de communicaton radio nRF24L01, module RFID-RC522. lecteur de fichiers mp3 VS1053, écran couleur ST7735, afficheur TM1638, potentiomètre numérique MCP41100, etc.
Observation d'une transaction SPI
Pour observer une communication SPI au moyen d'un analyseur logique, j'ai branché un convertisseur analogique-numérique (ADC) MCP3008 à un Arduino Uno. Ce circuit intégré comporte 8 entrées analogiques dont l'état est transmis de façon numérique par une communication SPI.
J'ai branché le MCP3008 à l'Arduino de la façon suivante:
- Broche 5 du MCP3008: potentiomètre permettant de faire varier la tension entre 0 et 5 V.
- Broches 9 et 14 du MCP3008: GND de l'Arduino
- Broches 15 et 16 du MCP3008: 5 V de l'Arduino
- Broche 10 du MCP3008: broche 10 de l'Arduino et canal 0 de l'analyseur logique
- Broche 11 du MCP3008: broche 11 de l'Arduino et canal 3 de l'analyseur logique
- Broche 12 du MCP3008: broche 12 de l'Arduino et canal 2 de l'analyseur logique
- Broche 13 du MCP3008: broche 13 de l'Arduino et canal 1 de l'analyseur logique
L'ajout d'un analyseur logique m'a permis de visualiser la communication SPI avec le logiciel Pulseview.
Le sketch que j'ai utilisé est présenté plus loin dans cet article: il consiste à établir une connexion avec le MCP3008 et de lui demander la valeur mesurée sur son canal 4.
Puisque le MCP3008 est un ADC à 10 bits, les valeurs obtenues peuvent varier entre 0 et 1023. Le potentiomètre a d'abord été réglé de façon à produire une valeur de 562:
Voici une transaction SPI au cours de laquelle l'Arduino demande la valeur du canal 4, ainsi que la réponse du MCP3008 (vous pouvez agrandir l'image en cliquant dessus). Remarquez que la ligne CS, qui était initialement l'état logique HAUT, se met temporairement à l'état logique BAS pendant toute la durée de la transaction.
Dans le cas du MPC3008, cette transaction nécessite l'échange de 3 octets. L'horloge (SCLK) a donc accompli trois séries consécutives de 8 oscillations. L'état logique des lignes MOSI et MISO est lu à chaque front ascendant de l'horloge.
Analysons chacun des 3 octets d'une façon plus détaillée:
Le premier octet est le message d'initialisation envoyé par le microcontrôleur au périphérique (sur la ligne MOSI, donc): il s'agit du nombre binaire "00000001". Pendant cette phase, l'état de la ligne MISO n'a aucune importance. Cet octet est émis à la ligne 41 du sketch (voir plus bas). Sur le diagramme ci-dessous, j'ai ajouté des gros points noirs pour indiquer à quel moment ces valeurs sont lues, pendant le front ascendant du signal d'horloge:
Dans le deuxième octet, le microcontrôleur indique au périphérique l'adresse de l'entrée analogique dont il désire lire la valeur. Selon la fiche technique du MCP3008, pour lire le canal numéro 4, il faut que les 4 premiers bits sur la ligne MOSI soient "1100"; la valeur des 4 derniers bits n'a aucune importance (on envoie généralement 0); ce signal est généré à la ligne 49 du sketch :
Sur la ligne MISO, le périphérique utilise les deux derniers bits de ce deuxième octet pour transmettre les deux premiers bits de sa réponse (qui en comportera ultimement 10). Ici, ces deux bits sont 1 et 0:
Finalement, les 8 derniers bits de la réponse du périphérique sont communiqués dans le troisième octet, sur la ligne MISO. Pour ce troisième octet, l'état de la ligne MOSI n'a aucune importance. Ici, le signal reçu est 00110010.
En mettant bout à bout les deux derniers bits du deuxième octet (10) et les 8 bits du troisième octet (00110010), nous obtenons le nombre binaire 1000110010, ou 562 en décimal: c'est bien à cette valeur que le potentiomètre avait été réglé.
Voici une transaction lorsque le potentiomètre est à la position minimale (0); les dix derniers bits retournés sur la ligne MISO sont 0000000000:
...et une autre lorsque le potentiomètre est à la position maximale (1023); les dix derniers bits retournés sur la ligne MISO sont 1111111111:
Le sketch utilisé
Sur Arduino, la communication SPI est gérée par la bibliothèque du même nom, qui est fournie par défaut avec l'IDE Arduino.
À la ligne 35 du sketch ci-dessous, on initie une transaction SPI en spécifiant 3 paramètres:la fréquence, le boutisme et le mode SPI (dans ce cas: 2 MHz, le bit de poids fort en premier, et le mode SPI 0):
SPI.beginTransaction (SPISettings(2000000, MSBFIRST, SPI_MODE0));
Un Arduino Uno peut sans problème établir une communication SPI à une fréquence de 4 MHz, mais il faut également tenir compte de la fréquence maximale que peut supporter le périphérique. Des fils conducteurs trop longs peuvent aussi nous obliger à diminuer la fréquence. Il existe 4 modes de communication SPI. Le plus fréquemment utilisé est le mode 0, dans lequel l'horloge est au niveau logique BAS quand elle est inactive, et la lecture des données s'effectue pendant le front montant de l'horloge.
SPI.transfer() permet simultanément l'envoi d'un octet du maître vers l'esclave sur la ligne MOSI et la réception d'un octet de l'esclave vers le maître sur la ligne MISO:
octet_recu = SPI.transfer(octet_envoyé);
À la ligne 41, on envoie le premier des 3 octets (00000001). Puisque la réponse de l'ADC est sans importance à cette étape, on ne se donne pas la peine de la stocker dans une variable.
SPI.transfer (0b00000001);
Le deuxième octet est envoyé à la ligne 45. C'est la commande qui indique qu'on désire lire le canal numéro 4. Cette fois, la réponse est stockée dans la variable octet_recu_1, puisque les deux derniers bits de la réponse constituent une information utile.
octet_recu_1 = SPI.transfer(0b11000000);
À la ligne 49, on envoie un troisième octet qui n'est qu'une suite de zéros, puisque ce message sera ignoré par le MCP3008. C'est strictement le message reçu qui nous intéresse: nous le stockons dans la variable octet_recu_2:
octet_recu_2 = SPI.transfer(0b00000000);
La ligne 59 consiste à mettre, dans une même variable, les deux derniers bits de la variable octet_recu_1, suivis des 8 bits de la variable octet_recu_2. Si la syntaxe vous donne du fil à retordre, relisez l'article sur les opérations bit à bit!
resultat = (octet_recu_1 & 0b00000011)<< 8 | octet_recu_2;
-
-
À lire aussi
Deux autres types de communication série ont également été abordés analyse d'une communication UART et analyse d'une communication I2C.
Le MCP3008 n'en est pas à sa première apparition dans ce blog: je l'avais utilisé afin d'ajouter des entrées analogiques au Raspberry Pi ainsi qu'à l'ESP8266.
Yves Pelletier (Twitter, Facebook)
mercredi 27 novembre 2019
pyserial: communiquer en python avec un Arduino
Aujourd'hui, nous allons programmer un script en Python qui communiquera avec une carte Arduino branchée à un port USB de l'ordinateur.
Ce programme sera utile, par exemple, pour consulter à partir de l'ordinateur des mesures prises par des capteurs branchés à l'Arduino, pour contrôler à partir de l'ordinateur un bras robotisé branché à l'Arduino, etc.
Bien entendu, tout ça peut se faire à partir du moniteur série de l'IDE Arduino, mais l'écriture de notre propre programme nous offrira la flexibilité nécessaire pour mieux répondre à nos besoins spécifiques.
Avant d'aller plus loin, j'aimerais attirer votre attention sur la série d'articles que j'ai rédigée sur l'utilisation de pyFirmata: on y atteint le même objectif d'une façon différente. Firmata est un protocole de communication entre un ordinateur hôte et un microcontrôleur. À mon avis, l'utilisation de Firmata est particulièrement appropriée si vous êtes très à l'aise avec la programmation en Python, mais moins à l'aise avec la programmation d'un Arduino: vous pouvez télécharger dans l'Arduino un sketch générique déjà tout fait, et concentrer tous vos efforts du côté du script en Python qui s'exécutera sur l'ordinateur.
La méthode que nous allons employer aujourd'hui (sans Firmata) suppose que vous maîtrisez à la fois le Python (côté ordinateur) et le C (côté Arduino).
Installation de pyserial
Côté ordinateur, nous aurons besoin de la bibliothèque pyserial qui, comme son nom l'indique, permet d'établir une communication série dans un programme en Python. Pour ce faire, j'ai utilisé pip:
pip install pyserial
L'image ci-dessous montre l'exécution du programme: 2 cartes Arduino étaient simultanément branchées à l'ordinateur, une sur le port ttyUSB1 et l'autre sur le port ttyACM5. J'ai choisi la deuxième carte, avec une vitesse de transmission de 9600 bauds, et les données en provenance de la carte choisie ont commencé à s'afficher.
Essayons maintenant une communication de l'ordinateur hôte vers l'Arduino. Le script en Python enverra à l'Arduino le nombre de clignotements que devra effectuer sa LED intégrée.
Voici d'abord le sketch de l'Arduino: sur réception d'un message UART, il vérifie s'il s'agit d'un nombre situé 1 et 9 et, si c'est le cas, il fait clignoter sa LED. Notez que le message reçu est codé en ASCII, d'où la soustraction du nombre 48 (puisque le code ASCII du chiffre zéro est 48).
-
-
Du côté de l'ordinateur, le script en Python envoie, par l'instruction write(), le nombre choisi par l'utilisateur. Tout le début du script est similaire à celui de l'exemple 1: on effectue d'abord un scan des ports série actifs, et on demande à l'utilisateur de faire son choix.
-
-
L'image ci-dessous montre l'exécution du programme alors qu'un seul Arduino était connecté à l'ordinateur (dans le port ttyACM2). La LED intégrée à la carte Arduino se met à clignoter chaque fois que je choisis un nombre entre 1 et 9.
Yves Pelletier (Twitter, Facebook)
Ce programme sera utile, par exemple, pour consulter à partir de l'ordinateur des mesures prises par des capteurs branchés à l'Arduino, pour contrôler à partir de l'ordinateur un bras robotisé branché à l'Arduino, etc.
Bien entendu, tout ça peut se faire à partir du moniteur série de l'IDE Arduino, mais l'écriture de notre propre programme nous offrira la flexibilité nécessaire pour mieux répondre à nos besoins spécifiques.
Avant d'aller plus loin, j'aimerais attirer votre attention sur la série d'articles que j'ai rédigée sur l'utilisation de pyFirmata: on y atteint le même objectif d'une façon différente. Firmata est un protocole de communication entre un ordinateur hôte et un microcontrôleur. À mon avis, l'utilisation de Firmata est particulièrement appropriée si vous êtes très à l'aise avec la programmation en Python, mais moins à l'aise avec la programmation d'un Arduino: vous pouvez télécharger dans l'Arduino un sketch générique déjà tout fait, et concentrer tous vos efforts du côté du script en Python qui s'exécutera sur l'ordinateur.
La méthode que nous allons employer aujourd'hui (sans Firmata) suppose que vous maîtrisez à la fois le Python (côté ordinateur) et le C (côté Arduino).
Installation de pyserial
Côté ordinateur, nous aurons besoin de la bibliothèque pyserial qui, comme son nom l'indique, permet d'établir une communication série dans un programme en Python. Pour ce faire, j'ai utilisé pip:
pip install pyserial
Exemple 1: Communication de l'Arduino vers l'ordinateur
Dans ce premier exemple, l'Arduino va envoyer un message à chaque demi seconde. Le script en Python affichera chaque message reçu.
Commençons par le sketch à télécharger dans l'Arduino. Rien de bien compliqué ici: après avoir activé la communication série et choisi la vitesse de transmission au début du programme (Serial.begin(9600)), chaque émission d'un message s'accomplit grâce à un Serial.println().
-
-
Du côté ordinateur, la réception des messages s'accomplit au moyen de l'instruction readline(). Mais auparavant, en plus d'avoir défini la vitesse de transmission (baud rate), il faut indiquer quel port série est utilisé par l'Arduino.
La plupart des tutos proposent d'écrire le nom du port série directement dans le programme, comme par exemple, sur Linux:
serial.Serial('/dev/ttyACM0', 9600, timeout=.1)
... ou sur Windows:
serial.Serial('COM4', 9600, timeout=.1)
Cette approche me semble assez peu pratique, surtout qu'une même carte Arduino peut se voir attribuer des ports différents d'une utilisation à l'autre. Pour cette raison, mon script est un tout petit peu plus compliqué, car il effectue un scan des ports série actifs et demande à l'utilisateur de choisir celui qu'il désire. Il demande aussi à l'utilisateur de choisir la vitesse de transmission.
-
-
L'image ci-dessous montre l'exécution du programme: 2 cartes Arduino étaient simultanément branchées à l'ordinateur, une sur le port ttyUSB1 et l'autre sur le port ttyACM5. J'ai choisi la deuxième carte, avec une vitesse de transmission de 9600 bauds, et les données en provenance de la carte choisie ont commencé à s'afficher.
Exemple 2: Communication de l'ordinateur vers l'Arduino
Voici d'abord le sketch de l'Arduino: sur réception d'un message UART, il vérifie s'il s'agit d'un nombre situé 1 et 9 et, si c'est le cas, il fait clignoter sa LED. Notez que le message reçu est codé en ASCII, d'où la soustraction du nombre 48 (puisque le code ASCII du chiffre zéro est 48).
-
-
Du côté de l'ordinateur, le script en Python envoie, par l'instruction write(), le nombre choisi par l'utilisateur. Tout le début du script est similaire à celui de l'exemple 1: on effectue d'abord un scan des ports série actifs, et on demande à l'utilisateur de faire son choix.
-
-
L'image ci-dessous montre l'exécution du programme alors qu'un seul Arduino était connecté à l'ordinateur (dans le port ttyACM2). La LED intégrée à la carte Arduino se met à clignoter chaque fois que je choisis un nombre entre 1 et 9.
Yves Pelletier (Twitter, Facebook)
samedi 23 novembre 2019
Écran couleur SPI ST7735 et Raspberry Pi
Cet article a été mis à jour le 30 décembre 2020 (compatibilité Python 3).
Le répertoire Python_ST7735 comporte un dossier "Examples". Le script "image.py" qui s'y trouve constitue une façon simple et rapide de vérifier le fonctionnement correct de l'écran (ça affiche à l'écran l'image contenue dans le fichier "cat.jpeg").
Vous pouvez facilement modifier ce script afin d'afficher une image de votre choix.
Le script "shapes.py", toutefois, n'est pas tout à fait au point: il a visiblement été conçu pour un écran ayant une résolution différente, et on ne voit à l'écran qu'une partie de l'image construite.
Exemple de script en python
Puisque la bibliothèque utilise la Python Imaging Library (PIL), c'est assez facile de trouver de la documentation pour apprendre à construire des images pouvant être affichées à l'écran.
Les coordonnées sont définies selon l'orientation en mode portrait; la bibliothèque ne semble pas comporter une façon simple de définir une orientation en mode paysage.
Dans le script ci-dessous, j'affiche quelques formes géométriques, puis j'écris l'adresse IP du Raspberry Pi (utile pour travailler en mode "headless") ainsi que la date et l'heure.
-
-
Inversion du bleu et du rouge!
Sur certains modèles d'écran ST7735, les couleurs seront incorrectes: ce qui devrait être rouge apparaît en bleu, et ce qui devrait être bleu apparaît en rouge! (C'est un écran "bgr" plutôt que "rgb"). Si vous constatez ce phénomène sur votre écran, la solution consiste à modifier la bibliothèque Python_ST7735:
À lire aussi
Cet écran couleur ST7735 peut également être contrôlé par un Raspberry Pi Pico , un Arduino, un STM32, un ESP8266 ou un ESP32.
Parmi les nombreux articles de ce blog portant sur le Raspberry Pi, certains décrivent l'utilisation d'autres modèles d'afficheurs: écran OLED SH1106, écran Nokia 5110, afficheur LCD 16 X 2...
Yves Pelletier (Twitter, Facebook)
Je vous explique aujourd'hui comment j'ai procédé pour contrôler un petit écran couleur SPI ST7735 ("KMR-1.8 SPI") de 128 * 160 pixels, branché à un Raspberry Pi, grâce à un script en Python.
Connexions
Il existe plusieurs modèles d'écrans couleurs basés sur le contrôleur ST7735, et le nom des broches peut varier d'un modèle à l'autre. Le modèle que j'ai utilisé comporte 16 connecteurs (mais 9 d'entre eux suffisent à faire fonctionner l'écran).
J'ai branché l'écran à mon Raspberry Pi 2 de la façon suivante:
Activation de SPI
Si ce n'est pas déjà fait, il est important d'activer le protocole SPI sur votre Raspberry Pi. Pour ce faire, on ouvre "Configuration du Raspberry Pi" dans le menu "Préférences" de Raspbian.
Dans l'onglet, on coche "Activé" sur la ligne "SPI".
Installation de la bibliothèque
J'ai utilisée la bibliothèque Python ST7735, adaptée par Clement Skau à partir d'une bibliothèque qu'Adafruit avait conçue pour un autre modèle d'écran.
Pour installer la bibliothèque, les lignes de commande suivantes ne sont probablement pas nécessaires si vous utilisez une version récente de Raspberry Pi OS (dans mon cas, tout était déjà installé). Mais ça ne coûte rien de vérifier:
Connexions
Il existe plusieurs modèles d'écrans couleurs basés sur le contrôleur ST7735, et le nom des broches peut varier d'un modèle à l'autre. Le modèle que j'ai utilisé comporte 16 connecteurs (mais 9 d'entre eux suffisent à faire fonctionner l'écran).
J'ai branché l'écran à mon Raspberry Pi 2 de la façon suivante:
- Broche GND de l'écran - Une des broches GND du Raspberry Pi
- Broche VCC de l'écran - Une des broches 5V du Raspberry Pi
- Broches NC de l'écran - Pas branchées
- Broche RESET de l'écran - Broche GPIO25 du Raspberry Pi
- Broche AO (ou DC/RS) de l'écran - Broche GPIO24 du Raspberry Pi
- Broche SDA de l'écran - Broche GPIO10 du Raspberry Pi
- Broche SCL de l'écran - Broche GPIO11 du Raspberry Pi
- Broche CS de l'écran - Broche GPIO8 du Raspberry Pi
- Broches SCK/MISO/MOSI/SD_CS de l'écran - Pas branchées (pour carte SD)
- Broche LED+ de l'écran - Une des broches 3,3 V du Raspberry Pi
- Broche LED- de l'écran - Une des broches GND du Raspberry Pi
Activation de SPI
Si ce n'est pas déjà fait, il est important d'activer le protocole SPI sur votre Raspberry Pi. Pour ce faire, on ouvre "Configuration du Raspberry Pi" dans le menu "Préférences" de Raspbian.
Dans l'onglet, on coche "Activé" sur la ligne "SPI".
Installation de la bibliothèque
J'ai utilisée la bibliothèque Python ST7735, adaptée par Clement Skau à partir d'une bibliothèque qu'Adafruit avait conçue pour un autre modèle d'écran.
Pour installer la bibliothèque, les lignes de commande suivantes ne sont probablement pas nécessaires si vous utilisez une version récente de Raspberry Pi OS (dans mon cas, tout était déjà installé). Mais ça ne coûte rien de vérifier:
sudo apt-get update
sudo apt-get install build-essential python3-dev python3-smbus python3-pip python3-pil python3-numpy
sudo pip3 install RPi.GPIO
Les 4 lignes suivantes, par contre, sont essentielles:
sudo pip3 install Adafruit_GPIO
git clone https://github.com/cskau/Python_ST7735
cd Python_ST7735
sudo python3 setup.py install
Le répertoire Python_ST7735 comporte un dossier "Examples". Le script "image.py" qui s'y trouve constitue une façon simple et rapide de vérifier le fonctionnement correct de l'écran (ça affiche à l'écran l'image contenue dans le fichier "cat.jpeg").
Vous pouvez facilement modifier ce script afin d'afficher une image de votre choix.
Le script "shapes.py", toutefois, n'est pas tout à fait au point: il a visiblement été conçu pour un écran ayant une résolution différente, et on ne voit à l'écran qu'une partie de l'image construite.
Exemple de script en python
Puisque la bibliothèque utilise la Python Imaging Library (PIL), c'est assez facile de trouver de la documentation pour apprendre à construire des images pouvant être affichées à l'écran.
Les coordonnées sont définies selon l'orientation en mode portrait; la bibliothèque ne semble pas comporter une façon simple de définir une orientation en mode paysage.
Dans le script ci-dessous, j'affiche quelques formes géométriques, puis j'écris l'adresse IP du Raspberry Pi (utile pour travailler en mode "headless") ainsi que la date et l'heure.
-
-
Inversion du bleu et du rouge!
Sur certains modèles d'écran ST7735, les couleurs seront incorrectes: ce qui devrait être rouge apparaît en bleu, et ce qui devrait être bleu apparaît en rouge! (C'est un écran "bgr" plutôt que "rgb"). Si vous constatez ce phénomène sur votre écran, la solution consiste à modifier la bibliothèque Python_ST7735:
- Ouvrez le fichier /Python_ST7735/ST7735/ST7735.py avec un éditeur de texte.
- À la ligne 241, remplacez self.data(0xC8) par self.data(0xC0) .
- Retournez dans le répertoire Python_ST7735 et tapez à nouveau la commande "sudo python3 setup.py install"
À lire aussi
Cet écran couleur ST7735 peut également être contrôlé par un Raspberry Pi Pico , un Arduino, un STM32, un ESP8266 ou un ESP32.
Parmi les nombreux articles de ce blog portant sur le Raspberry Pi, certains décrivent l'utilisation d'autres modèles d'afficheurs: écran OLED SH1106, écran Nokia 5110, afficheur LCD 16 X 2...
Yves Pelletier (Twitter, Facebook)
Inscription à :
Articles (Atom)