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


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

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   (TwitterFacebook)

samedi 23 novembre 2019

Écran couleur SPI ST7735 et Raspberry Pi

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:
  • 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 AO (ou DC/RS) de l'écran - Broche GPIO25 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 SDA/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.

J'ai suivi à la lettre la procédure d'installation proposée sur la page github de la bibliothèque:

sudo apt-get update
sudo apt-get install build-essential python-dev python-smbus python-pip python-imaging python-numpy
sudo pip install RPi.GPIO
sudo pip install Adafruit_GPIO
git clone https://github.com/cskau/Python_ST7735
cd Python_ST7735
sudo python 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 python setup.py install"


À lire aussi

Cet écran couleur ST7735 peut également être contrôlé par 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   (TwitterFacebook)

mercredi 20 novembre 2019

Raspberry Pi: présenter des mesures sous forme de graphique cartésien

Dans cet article, je vous présente comment j'ai pu présenter en temps réel, sous la forme d'un graphique cartésien, les mesures prises par un capteur branché aux broches GPIO du Rasbperry Pi.  Pour ce faire, j'ai utilisé un programme en langage Python, ainsi que la bibliothèque Matplotlib.



Installation de la bibliothèque Matplotlib

Matplotlib est une bibliothèque spécialement conçue pour représenter des données sous forme de graphique dans un programme en Python. Une façon simple de l'installer dans votre Raspberry Pi est d'écrire la commande suivante dans le terminal:

pip install matplotlib

Attention: ça risque d'être très long! Plusieurs dizaines de minutes sur mon Raspberry Pi 2.

Suite à l'installation de Matplotlib, mes scripts ont d'abord refusé de fonctionner sous prétexte que cairocffi n'était pas installé. Après un peu de recherche, j'ai fini par régler le problème en faisant:

sudo apt install libffi-dev
pip install cairoffi
sudo apt-get install python-gi-cairo

(je ne sais pas si chacune de ces manoeuvres est nécessaire, tout ce que je peux dire c'est qu'après avoir fait tout ça, ça s'est mis à fonctionner correctement).

Un exemple de script (données calculées)

Voici un script qui fait apparaître un graphique qui se met à jour à toutes les 500 ms. Pour que tout le monde puisse en faire l'essai sans autre matériel qu'un Rasbperry Pi, les données qui s'affichent sur le graphique sont issues d'un calcul plutôt que d'une mesure effectuée par un capteur.

-
-

La variable temps_pause contient le nombre de millisecondes entre chaque mise à jour du graphique. Vous pouvez évidemment modifier cette valeur selon vos besoins (si ce temps est trop court pour la vitesse de votre Raspberry Pi, le graphique restera vide).

Les données à mettre en graphique s'accumulent dans les variables valeurs_x et valeurs_y.

Grâce à la fonction FuncAnimation de matplotlib, la routine animate s'exécute automatiquement, à intervalle régulier.

Le programme s'interrompt lorsque vous fermez la fenêtre du graphique.



Un deuxième exemple de script (données mesurées)

Pour afficher dans le graphique les données mesurées par un capteur, il s'agit de remplacer le calcul de la ligne 30 par une procédure qui ajoute à la variable valeurs_y la mesure issue du capteur. Évidemment, la syntaxe exacte dépend du capteur que vous utilisez.

Voici par exemple un script qui met en graphique les valeurs mesurées par un module PCF8591 (il s'agit en fait de la tension contrôlée par le potentiomètre intégré au module).

-
-

En tournant lentement le potentiomètre, j'ai obtenu ce graphique:


À lire aussi

Vous trouverez sur cette page la liste de tous les articles du blog portant sur le Raspberry Pi, et sur celle-ci les articles portant sur l'utilisation des microcontrôleurs dans un contexte scientifique.

Yves Pelletier   (TwitterFacebook)


samedi 16 novembre 2019

Écran couleur SPI ST7735 et carte STM32

Je vous présente aujourd'hui un petit tuto sur l'art de piloter un écran couleur SPI ST7735 (128 X 160 pixels) au moyen d'une carte STM32 (Nucleo ou Blue Pill, par exemple) que nous programmerons au moyen de l'IDE Arduino.


(Si vous n'avez pas l'habitude de programmer une carte STM32 avec l'IDE Arduino, il pourrait être utile de consulter ce précédent billet qui explique comment ajouter les cartes STM32 grâce au gestionnaire de cartes.)

Installation des bibliothèques GFX et ST7735 d'Adafruit

Si ce n'est pas déjà fait, il faut installer les plus récentes version de la bibliothèque Adafruit GFX et de la bibliothèque Adafruit ST7735. Le plus simple est de passer par le gestionnaire de bibliothèque.




Connecteurs de l'écran

Mon écran ST7735 comporte 16 connecteurs, mais seulement 9 d'entre eux sont utiles pour faire apparaître une image sur l'écran.

4 connecteurs servent à l'utilisation du lecteur de carte SD, au verso de l'écran (je n'utilise pas ce lecteur dans le présent article), et 3 connecteurs  identifiés par la mention NC ne sont pas connectés à quoi que ce soit.






Connexions à la carte Nucleo

Pour utiliser l'écran avec mon Nucleo F030R8, j'ai utilisé les connexions suivantes:
  • Broche GND de l'écran - Broche GND du Nucleo
  • Broche VCC de l'écran - Broche 5 V du Nucleo
  • Broche RESET de l'écran - Broche PA9/D8 du Nucleo
  • Broche AO de l'écran - Broche PA10/D2 du Nucleo
  • Broche SDA de l'écran - Broche PA7/D11 du Nucleo
  • Broche SCL de l'écran - Broche PA5/D13 du Nucleo
  • Broche CS de l'écran - Broche PA8/D7 du Nucleo
  • Broche LED+ de l'écran - Broche 3V3 du Nucleo
  • Broche LED- de l'écran - Broche GND du Nucleo



Connexions à la Blue Pill (STM32F103C8T6)

Pour utiliser l'écran avec ma Blue Pill, j'ai utilisé ces connexions:
  • Broche GND de l'écran - Broche G de la Blue Pill
  • Broche VCC de l'écran - 5 V *
  • Broche RESET de l'écran - Broche A9 de la Blue Pill
  • Broche AO de l'écran - Broche A10 de la Blue Pill
  • Broche SDA de l'écran - Broche A7 de la Blue Pill
  • Broche SCL de l'écran - Broche A5 de la Blue Pill
  • Broche CS de l'écran - Broche A8 de la Blue Pill
  • Broche LED+ de l'écran - Broche 3.3 de la Blue Pill
  • Broche LED- de l'écran - Broche G de la Blue Pill
* Dans les faits, puisque ma Blue Pill était alimentée en 3,3 V, j'ai branché cette broche de l'écran à une sortie 5 V de mon programmateur ST-Link. Notez aussi que certains modèles d'écrans nécessitent une alimentation de 3,3 V, et qu'il est possible de retirer un pont de soudure pour que le modèle 5 V devienne un modèle 3,3 V.

Exemple de sketch

Voici, pour finir, un sketch qui montre les principales possibilités de la bibliothèque GFX: affichage de texte, dessin de différentes formes géométriques, affichage d'une image bitmap, etc.


----
---

À lire aussi

Si vous préférez, il est possible de contrôler cet écran avec un Arduino , un ESP32 ou un ESP8266.

Vous trouverez sur cette page une liste de projets réalisés avec des cartes STM32 (programmées avec l'IDE Arduino ou avec mbed), comme par exemple le contrôle d'un écran OLED SH1106 ou d'un afficheur LCD 2 X 16.

Yves Pelletier   (TwitterFacebook)

dimanche 10 novembre 2019

Communication nRF24L01 avec cartes STM32

Les modules nRF24L01 sont des émetteurs/récepteurs qui permettent la communication radio entre deux microcontrôleurs sur la bande 2,4 GHz. Je vous propose aujourd'hui quelques informations pour utiliser ces modules avec une carte STM32 programmée avec l'IDE Arduino (j'ai fait des tests avec une carte Nucleo et une Blue Pill).

Un truc intéressant, c'est qu'en plus de permettre une communication sans fil entre deux cartes STM32, une paire de modules nRF24L01 peuvent facilement être utilisée pour établir une connexion entre une carte STM32 et une carte Arduino, un ESP32, un ESP8266, un Raspberry Pi, etc.

Il existe sur le marché deux modèles de modules nRF24L01: un modèle vert comportant 10 broches, et un modèle noir comportant 8 broches. On peut se les procurer pour un prix qui tourne autour d'un euro par module. Il existe aussi un modèle plus puissant, vendu avec une antenne amovible, mais je n'ai pas eu l'occasion d'en faire l'essai.
Comme vous pouvez peut-être le deviner en lisant le nom des broches sur les images ci-dessus, chaque module communique avec le microcontrôleur auquel il est branché grâce au protocole SPI.

Pour les deux modèles, ça peut être une bonne idée d'ajouter un condensateur de 10 µF entre entre GND et VCC afin de stabiliser l'alimentation.

Préparation de l'IDE Arduino: installation des cartes STM32 et de la bibliothèque RF24-STM

Afin de programmer une carte STM32 avec l'IDE Arduino, il faut d'abord avoir installé le "STM32 core" au moyen du gestionnaire de cartes (instructions ici).

De plus, j'ai installé la bibliothèque RF24-STM; il s'agit d'une version de la bibliothèque RF24 de TMRh20 qui a été modifiée par Jaret Burkett pour la rendre compatible avec les cartes STM32. (J'avais d'abord tenté d'utiliser la version conventionnelle de la bibliothèque RF24 par TMRh20 mais  les messages reçus étaient remplacés par une suite de points d'interrogations dans le moniteur série).

Connexion du nRF24L01 à une carte Nucleo
  • broche VCC du module nRF24L01 - Broche 3.3 V de la carte Nucleo
  • broche CE du module nRF24L01 - Broche D7 de la carte Nucleo*
  • broche CSN du module nRF24L01 - Broche D6 de la carte Nucleo*
  • broche SCK du module nRF24L01 - Broche SCK/D13 de la carte Nucleo
  • broche MOSI du module nRF24L01 - Broche MOSI/D11 de la carte Nucleo
  • broche MISO du module nRF24L01 - Broche MISO/D12 de la carte Nucleo
  • broche IRQ du module nRF24L01 - pas branchée
  • broche GND du module nRF24L01 - Broche GND de la carte Nucleo
* Ces deux broches peuvent être remplacées par d'autres puisqu'on les définit au début du sketch. 





Connexion du nRF24L01 à une Blue Pill
  • broche VCC du module nRF24L01 - Broche 3.3 de la Blue Pill
  • broche CE du module nRF24L01 - Broche A8 de la Blue Pill*
  • broche CSN du module nRF24L01 - Broche B10 de la Blue Pill*
  • broche SCK du module nRF24L01 - Broche A5 de la Blue Pill
  • broche MOSI du module nRF24L01 - Broche A7 de la Blue Pill
  • broche MISO du module nRF24L01 - Broche A6 de la Blue Pill
  • broche IRQ du module nRF24L01 - pas branchée
  • broche GND du module nRF24L01 - Broche G de la Blue Pill


Sketches de démonstration

La bibliothèque RF24-STM est accompagnée d'une dizaine d'exemples qui vous aideront à découvrir les nombreuses possibilités du module nRF24L01.

Je vous présente ci-dessous un sketch pour l'émission d'un message (un nombre croissant est émis chaque seconde), et un autre pour la réception d'un message (le message reçu est affiché dans le moniteur série).  Leur simplicité constitue un avantage lorsqu'on désire vérifier que la communication fonctionne correctement.

Ces programmes sont parfaitement compatibles avec ceux que j'avais déjà publiés pour la communication nRF24L01 impliquant une carte Arduino ou un Raspberry Pi. Vous pouvez donc, par exemple, émettre un message avec un Arduino Uno et le capter avec une carte Nucleo.



Sketch pour l'émission d'un message

-
-

Sketch pour la réception d'un message

-
-

À lire aussi

Au risque de me répéter: vous trouverez sur ce blog d'autres tutos qui vous guideront dans l'utilisation d'un module nRF24L01 avec un Arduino, 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.

Pour une communication unidirectionnelle, une paire émetteur/récepteur 433 MHz peut constituer une alternative intéressante.

D'autre part, vous trouverez sur cette page une liste d'articles impliquant les cartes STM32 (programmées avec l'IDE Arduino ou avec mbed).

Yves Pelletier   (TwitterFacebook)

dimanche 3 novembre 2019

Écran OLED SH1106 I2C et STM32

Le projet d'aujourd'hui consiste à afficher du texte et des images sur un petit écran OLED SH1106 i2c de 128 X 64 pixels. L'écran sera piloté par une carte STM32 (Blue Pill ou Nucleo, par exemple), programmée au moyen de l'IDE Arduino.


Afin de pouvoir programmer une carte STM32 avec l'IDE Arduino, ces cartes doivent préalablement avoir été installées dans l'IDE au moyen de son gestionnaire de cartes. Si ce n'est pas déjà fait, vous pouvez vous référer à ce précédent article.

Installation de la bibliothèque u8g2

Il faut aussi que la bibliothèque u8g2 soit installée. Cette bibliothèque est compatible avec de nombreuses cartes de développement, et avec pratiquement tous les modèles d'écrans monochromes. Le gestionnaire de bibliothèques de l'IDE constitue la façon la plus simple de l'installer.

Connexion de l'écran OLED à une carte STM32 Nucleo

Puisqu'il s'agit d'un périphérique I2C, 4 fils sont suffisants pour brancher l'écran à votre carte de développement.

Sur une carte Nucleo, les connexions sont assez évidentes:
  • GND de l'écran OLED - GND de la carte Nucleo
  • VCC de l'écran OLED - 3V3 de la carte Nucleo
  • SCL de l'écran OLED - SCL de la carte STM32
  • SDA de l'écran OLED - SDA de la carte STM32


Connexions à une Blue Pill

Si vous utilisez une Blue Pill, il faut savoir que les broches B6 et B7 sont consacrées à la communication I2C, car ce n'est pas indiqué sur la carte.
  • GND de l'écran OLED - G de la carte STM32
  • VCC de l'écran OLED - 3V3 de la carte STM32
  • SCL de l'écran OLED - broche B6 de la carte STM32
  • SDA de l'écran OLED - broche B7 de la carte STM32

N.B.: j'ai essayé sans succès de piloter l'écran OLED avec mon STM32F030 Demo Board V1.1, mais la bibliothèque u9g2 semble trop gourmande pour ses 16 kb de mémoire flash.

Sketch de démonstration

Voici un sketch qui écrit et dessine sur l'écran. Il s'agit en fait du sketch que j'avais écrit il y a quelques mois pour contrôler l'écran OLED avec un ESP32. Aucune modification n'a été nécessaire pour le faire fonctionner avec un STM32, et vous pouvez donc consulter ce précédent article pour plus d'explications.

-

-

À lire aussi

Vous serez peut-être intéressés par ces autres tutoriels qui montrent comment utiliser ce même écran OLED SH1106 avec un Raspberry Pi, un Arduino, un ESP32 ou un ESP8266.

D'autres types d'écrans peuvent être pilotés par une carte STM32: écran couleur ST7735, afficheur 2 X 16, etc.

De plus, vous trouverez ici la liste de tous les projets impliquant les cartes STM32 (programmées avec l'IDE Arduino ou avec mbed).

Yves Pelletier   (TwitterFacebook)

vendredi 1 novembre 2019

Programmation d'une carte STM32 avec l'IDE Arduino

Maintenant que le "STM32Duino Core" de Roger Clarke a été remplacé par "l'official STM32 Core" mis au point par STMicroelectronics, il semble approprié de rédiger cette nouvelle introduction à la programmation d'une carte STM32 au moyen de l'IDE Arduino.

Une excellent nouvelle, en ce qui me concerne, c'est que le nombre de cartes supportées est beaucoup plus imposant qu'il ne l'était auparavant. En plus de la Blue Pill (STM32F103C8T6), je pourrai dorénavant programmer ma carte Nucleo F030R8 ainsi que mon STM32F030 Demo Board V1.1 en utilisant l'IDE Arduino.

Dans cet article, je vais programmer chacune de ces 3 cartes grâce à l'IDE Arduino, en utilisant un programmateur ST-Link ou un convertisseur USB série.



Installation des cartes STM32 au moyen du gestionnaire de cartes

Tout d'abord, on choisit "Préférences" dans le menu "Fichier".


Dans le bas du dialogue "Préférences", il faut ajouter l'adresse suivante à l'intérieur du champ "URL de gestionnaire de cartes supplémentaires":

https://github.com/stm32duino/BoardManagerFiles/raw/master/STM32/package_stm_index.json

(si ce champ contient déjà d'autres adresses, vous pouvez les séparer par des virgules).



Nous accédons ensuite au gestionnaire de carte (Menu Outils - Type de carte - Gestionnaire de carte).


"STM32 Cores by STMicroelectronics" devrait maintenant être disponible dans le gestionnaire de cartes. Il ne reste plus qu'à cliquer sur le bouton "Installer" et à patienter quelques minutes.



Installation de STM32 Cube Programmer

Si vous devez programmer votre carte avec un programmateur STLink ou un convertisseur USB/Série, il faudra aussi installer le logiciel STM32 Cube Programmer, disponible sur le site ST.com (ce n'est pas nécessaire si vous programmez une carte Nucleo).

Le seul irritant, c'est que ST exige qu'on s'identifie avant de nous laisser télécharger le logiciel. J'ai dû attendre une bonne dizaine de minutes avant de recevoir l'indispensable email de validation.

Pour le reste, le logiciel vient avec un installateur, c'est simple et rapide.


Programmation de ma carte Nucleo F030R8

La seule carte Nucleo que je possède est un modèle bas de gamme que je programmais strictement sur mbed, puisqu'elle n'était pas supporté par le STM32 Duino core de Roger Clarke.

Pour sélectionner cette carte, je commence par choisir la catégorie "Nucleo-64" (menu "Outils - Type de carte - Nucleo-64").


Je peux ensuite sélectionner la bonne carte à l'intérieur de cette catégorie (menu "Outils - Board part number -Nucleo F030R8").


Finalement, réglage de la méthode de téléversement (menu "Outils - Upload Method - Mass Storage").


Il ne reste plus qu'à brancher la carte Nucleo a un port USB, sélectionner le port, et téléverser l'exemple Blink: tout fonctionne à la perfection.

Programmation de la carte STM32F103C8T6 (Blue Pill)


Essayons maintenant la Blue Pill. J'ai sélectionné la catégorie "Generic STM32F1 series" dans "Outil - Type de carte".


J'ai ensuite choisi "BluePillF102C8 (128k)" dans le menu "Outils - Board part number".


Il faut ensuite préciser la méthode de téléchargement (menu "Outils - Upload method"). Si vous programmez votre Blue Pill avec un programmateur STLink, il faut choisir "STM32CubeProgrammer (SWD)". Si vous utilisez un convertisseur USB-Série, vous choisissez plutôt "STM32CubeProgrammer (Serial)".



4 fils sont utilisés pour brancher la carte Blue Pill à l'adaptateur USB-Série:
  • GND de l'adaptateur USB/Série --- GND de la Blue Pill
  • RXD de l'adaptateur USB/Série --- PA9 de la Blue Pill
  • TXD de l'adaptateur USB/Série --- PA10 de la Blue Pill
  • 3V3 de l'adaptateur USB/Série --- 3.3V de la Blue Pill


La carte Blue Pill comporte deux jumpers. Le jumper "Boot0" (celui qui est le plus éloigné du bouton reset) doit être placé en position "1" pour que le téléversement du sketch réussisse en mode série.


Toujours en téléversement série, avant de cliquer sur le bouton "Téléverser", vous devez appuyez sur le bouton "reset" de la carte Blue Pill (mon doigt est trop gros pour atteindre le bouton: je suis obligé d'utiliser un crayon).


Si vous utilisez un programmateur STLink V2, vous le branchez aux 4 connecteurs situés à l'extrémité de la carte.





Avec STLink, il n'est pas nécessaire d'appuyer sur le bouton reset avant le téléchargement, et la position du jumper "Boot0" n'a pas d'importance.

Ici encore, le téléversement de l'exemple Blink vous permettra de confirmer que tout fonctionne correctement.


Programmation de la carte STM32F030 Demo Board V1.1

Il y a quelques années, je m'étais procuré cette carte à cause de son prix ridiculement bas (de l'ordre de 1 euro!), mais je n'avais encore jamais eu l'occasion de la programmer.



Pour ce modèle, je sélectionne la catégorie "Generic STM32F0 series" dans le menu "Outil - Type de carte".



J'ai ensuite choisi "STM32F030F4 Demo board" dans le menu "Outils - Board part number".


Il faut ensuite préciser la méthode de téléchargement (menu "Outils - Upload method". Si vous programmez la carte un programmateur STLink, il faut choisir "STM32CubeProgrammer (SWD)". Si vous utilisez un convertisseur USB-Série, vous choisissez plutôt "STM32CubeProgrammer (Serial)".


À une extrémité de la carte, 4 broches permettent la programmation avec un convertisseur USB-Série, et 4 autres broches sont disponibles pour la programmation avec STLink. Le rôle de chaque connecteur est assez clairement indiqué sur la carte.


Pour la programmation avec un convertisseur USB-série:
  • Broche 3V3 de la carte STM32 - Broche 3V3 du convertisseur USB-série
  • Broche GND de la carte STM32 - Broche GND du convertisseur USB-série
  • Broche TXD de la carte STM32 - Broche RXD du convertisseur USB-série
  • Broche RXD de la carte STM32 - Broche TXD du convertisseur USB-série

Pour la programmation avec un dongle ST-Link:
  • Broche 3V3 de la carte STM32 - Broche 3,3 V du ST-Link
  • Broche DIO de la carte STM32 - Broche SWDIO du ST-Link
  • Broche CLK de la carte STM32 - Broche SWCLK du ST-Link
  • Broche GND de la carte STM32 - Broche GND du ST-Link
Lorsqu'on programme avec le convertisseur USB-série, il faut appuyer sur le bouton "reset" avant le téléchargement. Le jumper BOOT0 doit être placé à 3,3 V lors du téléversement du programme, et à GND lors de son exécution.

Bilan

Pour l'instant, mes tests se sont limités à faire clignoter la LED de la carte, communiquer avec le moniteur série, etc. Reste à voir si la majorité des bibliothèques Arduino sont compatibles avec les cartes STM32 (c'est souvent là que ça coince un peu). Je devrai aussi vérifier si tous les sketches que j'ai écrits pour la Blue Pill sous l'ancien core demeurent fonctionnels, sans modifications, sur le nouveau core.

Je suis assez optimiste.

À lire également

Vous trouverez sur cette page tous les articles concernant les cartes STM32, qu'elles soient programmées avec l'IDE Arduino ou avec mbed.

Yves Pelletier   (TwitterFacebook)