STM32 et ARDUINO

STM32 et ARDUINO

 

J'avais récemment fait l'acquisition de quelques cartes STM32 dites "BLUE PILL" dans le but de les utiliser avec les librairies STM32DUINO.

1. Présentation

Les cartes "BLUE PILL" sont équipées d'un processeur STM32F103C8T6 :

• Large gamme de tension d'utilisation de 2V à 3.6V
• 64Ko de mémoire flash
• 20Ko de SRAM
• Unité de calcul CRC, ID unique 96 bits
• Deux convertisseurs A/N 1µs 12 bits (jusqu'à 10 voies)
• Contrôleur DMA 7 voies, 3 timers à usage général et 1 timer de contrôle avancé
• 37 ports E/S rapides dont 15 PWM
• Interfaces de débogage fil série (SWD) et JTAG
• Interfaces : deux SPI, deux I2C, trois USART, une USB et une CAN

La carte "BLUE PILL" vous permet d'exploiter 32 ports sur les 37 disponibles.

Souvent ces cartes sont équipées de 128K de mémoire FLASH.

Comme vous pouvez le constater, rien à voir avec l'ATMEGA 328 équipant les ARDUINO UNO, NANO ou MINI.

2. Pourquoi ARDUINO

Concernant le développement STM32 en général, on peut objecter que l'on peut développer avec d'autres librairies :

• les librairies ST STM32Cube. Trop bas niveau, demande beaucoup de travail
• MBED qui vous offrira un ensemble de librairies permettant de gérer des afficheurs, des modules de communication et des composants divers

Dans ce cas, on utilise un compilateur GCC ou ARM et l'utilisation d'un ST-LINK ou JLINK permet en plus du chargement en FLASH ... de profiter du DEBUGGER, gdb ou autre. Les IDE KEIL, PlatformIO ou à base d'ECLIPSE permettent de travailler bien plus confortablement qu'avec l'IDE ARDUINO.

Une présentation est faite ici : https://riton-duino.blogspot.com/2019/03/stm32-environnements-de-developpement.html

Mais dans ce cas, on ne bénéficie pas de toutes les bibliothèques ARDUINO et c'est franchement dommage.

Normalement, certaines librairies ARDUINO devraient fonctionner avec ces environnements, par contre il faudra les intégrer vous-même à vos projets, et gérer les dépendances (certaines librairies ont besoin d'autres librairies). L'opération ne sera pas aussi facile qu'avec l'IDE ARDUINO et STM32DUINO.

L'intérêt de cette manip est de bénéficier de la puissance de feu extraordinaire des STM32 en développant des applications comme sur un ARDUINO, avec le capital fantastique des librairies ARDUINO.

3. Bootloader

Le STM32 possède déjà un bootloader (hard-coded), celui de ST MICROELECTRONICS. Celui-ci est même capable de charger une application par I2C et SPI !!!

Nous allons donc nous passer du bootloader ARDUINO, totalement inutile.

Certains développeurs se passent fort bien du bootloader sur leurs cartes ARDUINO. Ils chargent leur application avec un boîtier AVRISP ou USBasp, etc. Cela permet d'économiser l'espace occupé par le bootloader.

4. Installation

Comme dit au début de ce document, le but est de développer du logiciel en utilisant les librairies ARDUINO. Nous allons donc commencer par installer les librairies logicielles spécifiques à ce processeur.

Il faut d'abord télécharger cette archive, et la décompresser dans le répertoire hardware de votre répertoire d'installation ARDUINO.

Ensuite ouvrez le menu Outils -> Type de carte -> Gestionnaire de carte. Installer le paquet "Arduino SAM Boards (32-bits ARM Cortex-M3)".

Ce paquet supporte l'ARDUINO DUE.

Il y a plus simple :

Il suffit d'ajouter l'URL https://raw.githubusercontent.com/stm32duino/BoardManagerFiles/master/STM32/package_stm_index.json  aux gestionnaires de cartes supplémentaires : voir Fichier / Préférences.

Dans sa dernière version 2.1.0 l'URL change :

https://github.com/stm32duino/BoardManagerFiles/raw/master/package_stmicroelectronics_index.json

Une autre URL existe (je n'ai pas testé)

http://dan.drown.org/stm32duino/package_STM32duino_index.json

5. Câblage

Pour pouvoir charger un logiciel dans la carte et disposer du Moniteur série de l'IDE ARDUINO nous allons utiliser un convertisseur USB / série. Choisissez un modèle compatible 3.3V. La photo suivante représente un convertisseur supportant le 5V et le 3.3V.

Seules 4 pins seront utilisées :

Provenance de la photo : www.hackster.io

6. Premier sketch

Pour tester le premier sketch "blink", nous allons utiliser LED_BUILTIN (PC13) pour faire clignotter la LED de la carte.

Nous allons écrire un petit logiciel "blink".

#define LED LED_BUILTIN

void setup() { 
  pinMode(LED, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  digitalWrite(LED, HIGH);
  delay(1000);
  digitalWrite(LED, LOW);
  delay(1000);
  Serial.println("OK");
}

Comme vous pouvez le constater, rien ne distingue ce premier sketch d'un sketch ARDUINO classique.

7. Chargement

7.1 Avec le bootloader intégré

7.1.1. Version 2.1.0

STM32DUINO évolue sans cesse, et les outils ST MICROELECTRONICS aussi.

23/04/2022 : dans la version 2.1.0, l'utilitaire ST-FLASH a été remplacé par STM32CubeProgrammer. Cette méthode de chargement par la ligne série ne fonctionne plus, en tous cas je n'ai pas réussi à l'utiliser.

Lire le paragraphe suivant : 7.2. Avec ST-LINK

7.1.2. Anciennes versions

Dans le menu Outils choisissez votre type de carte et la méthode de chargement :
Type de carte : Generic STM32F103C
Variant : STM32F103C8 (20k RAM, 64K Flash)
Upload method : serial
Port : le port série correspondant à votre convertisseur

Remarque : avec la version STM32DUINO 1.5.0, la BLUE PILL se trouve ici :

Type de carte : Generic STM32F1 series
Board part Number : Blue Pill F103C8

Placez le cavalier boot0 sur 1 et appuyez sur le bouton RESET. Cliquer sur téléverser. Il doit se produire ceci :

stm32flash Arduino_STM32_0.9

http://github.com/rogerclarkmelbourne/arduino_stm32

Using Parser : Raw BINARY
Interface serial_posix: 230400 8E1
Version      : 0x22
Option 1     : 0x00
Option 2     : 0x00
Device ID    : 0x0410 (Medium-density)
- RAM        : 20KiB  (512b reserved by bootloader)
- Flash      : 128KiB (sector size: 4x1024)
- Option RAM : 16b
- System RAM : 2KiB
Write to memory
Erasing memory

Wrote address 0x08000100 (3.30%) 
Wrote address 0x08000200 (6.61%) 
Wrote address 0x08000300 (9.91%) 
Wrote address 0x08000400 (13.22%) 
Wrote address 0x08000500 (16.52%) 
Wrote address 0x08000600 (19.82%) 
Wrote address 0x08000700 (23.13%) 
Wrote address 0x08000800 (26.43%) 
Wrote address 0x08000900 (29.74%) 
Wrote address 0x08000a00 (33.04%) 
Wrote address 0x08000b00 (36.34%) 
Wrote address 0x08000c00 (39.65%) 
Wrote address 0x08000d00 (42.95%) 
Wrote address 0x08000e00 (46.26%) 
Wrote address 0x08000f00 (49.56%) 
Wrote address 0x08001000 (52.87%) 
Wrote address 0x08001100 (56.17%) 
Wrote address 0x08001200 (59.47%) 
Wrote address 0x08001300 (62.78%) 
Wrote address 0x08001400 (66.08%) 
Wrote address 0x08001500 (69.39%) 
Wrote address 0x08001600 (72.69%) 
Wrote address 0x08001700 (75.99%) 
Wrote address 0x08001800 (79.30%) 
Wrote address 0x08001900 (82.60%) 
Wrote address 0x08001a00 (85.91%) 
Wrote address 0x08001b00 (89.21%) 
Wrote address 0x08001c00 (92.51%) 
Wrote address 0x08001d00 (95.82%) 
Wrote address 0x08001e00 (99.12%) 
Wrote address 0x08001e44 (100.00%) Done.

Starting execution at address 0x08000000... done. 

LA LED CLIGNOTE.

Le terminal fonctionne aussi.

Un petit détail : pendant le chargement le device ID est affiché, ainsi que les tailles mémoire. Souvent ces cartes sont équipées de 128K de FLASH. Bonne surprise.

7.2. Avec ST-LINK

Si l'on dispose d'un boîtier ST-LINK on peut aussi l'utiliser.

Voir ici pour l'installation : https://riton-duino.blogspot.com/2019/03/stm32-boitier-st-link.html

7.2.1. Version 2.1.0

Comme dit plus haut, STM32DUINO évolue sans cesse, et les outils ST MICROELECTRONICS aussi.

23/04/2022 : dans la version 2.1.0, l'utilitaire ST-FLASH a été remplacé par STM32CubeProgrammer.

Il n'est plus nécessaire de passer par la ligne de commande pour charger le code dans la carte, comme auparavant.

Il suffit de choisir STM32CubeProgrammer (SWD) dans le menu Outils / Upload Method, et ensuite de cliquer sur le bouton "Téléverser". Il y a du progrès.

Voici ce qui se passe lors du chargement :

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

                        STM32CubeProgrammer v2.10.0
      -------------------------------------------------------------------

ST-LINK SN  : 52FF6F065177525451252087
ST-LINK FW  : V2J29S7
Board       : --
Voltage     : 3,26V
SWD freq    : 4000 KHz
Connect mode: Under Reset
Reset mode  : Hardware reset
Device ID   : 0x410
Revision ID : Rev X
Device name : STM32F101/F102/F103 Medium-density
Flash size  : 64 KBytes
Device type : MCU
Device CPU  : Cortex-M3
BL Version  : --

Memory Programming ...
Opening and parsing file: sketch_apr22a.ino.bin
  File          : sketch_apr22a.ino.bin
  Size          : 12,53 KB 
  Address       : 0x08000000 

Erasing memory corresponding to segment 0:
Erasing internal memory sectors [0 12]
Download in Progress:

File download complete
Time elapsed during download operation: 00:00:00.837

RUNNING Program ... 
  Address:      : 0x8000000
Application is running, Please Hold on...
Start operation achieved successfully

7.2.2. Anciennes versions

Le chargement se fait avec l'utilitaire st-flash.
Cet utilitaire se trouve ici :

Si la machine est en 64bits :
.arduino15/packages/STM32/tools/STM32Tools/1.2.1/tools/linux64/stlink/st-flash
Si la machine est en 32bits :
./.arduino15/packages/STM32/tools/STM32Tools/1.2.1/tools/linux/stlink/st-flash

Sinon, le nécessaire se trouve dans le répertoire .arduino15 de votre répertoire personnel. Vous pouvez soit modifier votre variable d'environnement PATH pour y ajouter le répertoire où se trouve st-flash, soit copier st-flash dans /usr/local/bin (pour une machine LINUX, pour une machine Windows vous trouverez bien un répertoire approprié).

Méthode :
Récupérez cette ligne à la fin de la compilation dans l'IDE ARDUINO :

"/home/riton/.arduino15/packages/STM32/tools/arm-none-eabi-gcc/6-2017-q2-update/bin/arm-none-eabi-objcopy" -O binary  "/tmp/arduino_build_579822/Blink.ino.elf" "/tmp/arduino_build_579822/Blink.ino.bin"

Ensuite entrer la commande suivante dans un terminal :

st-flash write /tmp/arduino_build_579822/Blink.ino.bin 0x8000000

st-flash s'exécute :

2019-03-29T18:54:09 INFO src/stlink-common.c: Loading device parameters....
2019-03-29T18:54:09 INFO src/stlink-common.c: Device connected is: F1 Medium-density device, id 0x20036410
2019-03-29T18:54:09 INFO src/stlink-common.c: SRAM size: 0x5000 bytes (20 KiB), Flash: 0x10000 bytes (64 KiB) in pages of 1024 bytes
2019-03-29T18:54:09 INFO src/stlink-common.c: Attempting to write 12844 (0x322c) bytes to stm32 address: 134217728 (0x8000000)
Flash page at addr: 0x08003000 erased
2019-03-29T18:54:09 INFO src/stlink-common.c: Finished erasing 13 pages of 1024 (0x400) bytes
2019-03-29T18:54:09 INFO src/stlink-common.c: Starting Flash write for VL/F0/F3 core id
2019-03-29T18:54:09 INFO src/stlink-common.c: Successfully loaded flash loader in sram
 12/12 pages written
2019-03-29T18:54:10 INFO src/stlink-common.c: Starting verification of write complete
2019-03-29T18:54:10 INFO src/stlink-common.c: Flash written and verified! jolly good!
riton@alpha:/mnt/sdc1/riton$

LA LED CLIGNOTE AUSSI.

Quel est l'intérêt du boîtier ST-LINK puisque le chargement peut se faire depuis l'IDE ARDUINO en un seul clic ?

Effectivement le chargement est plus facile avec l'IDE. Mais l'IDE ne permettra pas de déboguer, alors qu'avec le boîtier ST-LINK c'est possible, tout en conservant le chargement par l'IDE.

Les explications ICI : https://riton-duino.blogspot.com/2019/03/stm32-duino-deboguer.html

Il est très probable que sous LINUX vous ayez à créer un petit fichier pour autoriser l'accès au device ST-LINK.

Si vous lancez st-flash et que vous voyez ceci :

2019-03-29T19:12:31 WARN usb.c: Couldn't find any ST-Link/V2 devices

Créez un fichier /etc/udev/rules.d/49-stlinkv2.1.rules :

# stm32 nucleo boards, with onboard st/linkv2-1
# ie, STM32F0, STM32F4.
# STM32VL has st/linkv1, which is quite different

SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="374b", \
    MODE:="0666", \
    SYMLINK+="stlinkv2-1_%n"

SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="3748", \
    MODE:="0666", \
    SYMLINK+="stlinkv2_%n"

# If you share your linux system with other users, or just don't like the
# idea of write permission for everybody, you can replace MODE:="0666" with
# OWNER:="yourusername" to create the device owned by you, or with
# GROUP:="somegroupname" and mange access using standard unix groups.

Ce fichier permet à l'utilisateur non root d'accéder au device, qu'il soit un ST-LINK ST MicroElectronics ou un ST-LINK chinois.

8. Quelques explications supplémentaires

Pendant le développement de l'application il est possible de laisser le cavalier BOOT0 sur 1 et téléverser / exécuter dans la foulée.

Avec BOOT0 sur 1, le STM32 démarre son propre bootloader. Il attend les caractères sur sa ligne série, écrit ce qui arrive en FLASH et lance l'application.

Par contre pour la version finale, il faudra remettre le cavalier sur 0. Dans ce cas, le STM32 démarre directement l'application.

9. Le pinout de la carte

10. Cartes

Outre la "BLUE PILL", il existe une grande variété de cartes exploitables :

STM32F030F4 (Cortex M0)

Maple Mini (STM32F103CBT6)

La Black VET6 (STM32F407VET6)

Dernièrement les membres du projet STM32DUINO ont ajouté de nombreuses cartes d'évaluation ST MicroElectronics :

Cartes ST NUCLEO32

Cartes ST NUCLEO64

Cartes ST NUCLEO144

Carte ST DISCOVERY

Certaines cartes comme la NUCLEO F429ZI possèdent un port USB host, et un port Ethernet. Certaines DISCOVERY sont équipées d'un écran TFT :

Un conseil : achetez vos cartes sur Farnell Particuliers, Mouser ou RS. Une NUCLEO32 L031K6 vous coûtera moins de 10€ HT. Sur AliExpress la même carte vous coûtera 16€ TTC.

On trouve la description de ces cartes ici :

https://www.st.com/en/evaluation-tools/stm32-nucleo-boards.html?querycriteria=productId=LN1847

https://www.st.com/b/en/evaluation-tools/stm32-discovery-kits.html

10.1.  Les cartes génériques

10.1.1. La STM32F030 demo board

Cette carte est équipée d'un petit Cortex M0 STM32F030F4P6 :

• 32 bits
• 48 MHz
• 16K de Flash
• 4K de RAM
• 6 UARTs
• 2 I2C
• 2 SPI
• 1 ADC 12bits
• RTC
• low power :
• 2μA Standby mode
• 5μA Stop mode
• 2μA Stop mode + RTC

Le connecteur USB semble servir uniquement d'alimentation.


10.1.2. La Blue Pill

Cette carte est équipée d'un processeur STM32F103C8T6 :

• 72 MHz
• 128Ko de Flash
• 20Ko de RAM
• 2 ADC 12bits
• 3 UARTs
• 2 SPI
• 2 I2C

10.1.3. La Maple Mini

Cette carte est équipée d'un STM32F103CBT6 :

• 72 MHz
• 128K de Flash
• 20K de RAM
• 3 UARTs
• 2 I2C
• 2 SPI
• 2 ADC 12bits
• RTC

10.1.4. La Black VET6

Cette carte est équipée d'un STM32F407VET6 :

• 168 MHz
• 1M de Flash
• 196K de RAM
• interface LCD 8080/6800 
• 4 UARTs
• 3 I2C
• 3 SPI
• 2 CAN
• 3 ADC 12bits
• 3 DAC 12bits
• SDIO
• RTC

Cette carte est également équipée de :

• slot pour un NRF24L01
• slot µSD
• 3 boutons + reset
• 2 LEDs
• mini USB
• 2 oscillateurs 8MHz et 32.768Hz
• support de pile pour RTC
• flash 16M SPI W25Q16

Une carte de gros calibre pour de grosses applications.

10.2.  Les cartes NUCLEO

Il s'agit de cartes d'évaluation produites par ST MicroElectronics.
La documentation se trouve ici :
https://www.st.com/content/ccc/resource/technical/document/user_manual/98/2e/fa/4b/e0/82/43/b7/DM00105823.pdf/files/DM00105823.pdf/jcr:content/translations/en.DM00105823.pdf

10.2.1. Alimentation

Ces cartes possèdent différents modes d'alimentation :

• USB
• VIN (7V-12V)
• E5V (5V)
• +3.3V

Voir 6.3 Power supply and power selection

10.2.2. Le port USB

Ces cartes possèdent une particularité. Le port USB a trois fonctions :

• port de chargement ST-LINK
• support de masse USB
• debugger

Sur un STM32 la fonction de chargement et debug ST-LINK est normalement assurée par un boîtier de communication USB tel celui-ci :

ST-LING V2 ST MicroElectronics

ST-LINK V2 Clone chinois

Sur les cartes NUCLEO, le ST-LINK est intégré à la carte. Et il est détachable sur les NUCLEO64 et NUCLEO144.

Le support de masse USB n'est pas un support de stockage classique. C'est en fait un espace virtuel qui se comporte comme une clé USB, sur lequel il est possible de déposer le programme exécutable pour qu'il soit chargé en FLASH.

Sur les cartes NUCLEO toutes ces fonctions sont assurées par un STM32F103 situé sur la partie détachable de la carte :

10.2.3. Choisir le type de carte dans l'IDE ARDUINO

L'équipe STM32DUINO a poussé très loin l'intégration de ce matériel. Le menu Outils de l'IDE ARDUINO propose tout d'abord un choix de famille de carte :

• Nucleo-144
• Nucleo-64
• Nucleo-32
• Discovery
• Generic STM32F0 Series
• Generic STM32F1 Series
• Generic STM32F4 Series
• etc. 

Le menu Outils permet ensuite de choisir le modèle de carte. Pour une BLUE PILL il faut choisir :

• Type de carte : Generic STM32F1 series
• Board part Number : Blue Pill F103C8

Ensuite il y a pas mal d'options en fonction du type de carte :

• le chargement par le support de masse et ST-LINK sont accessibles
• il est possible de customiser la librairie C
• NewLib nano
• NewLib avec printf des float
• NewLib avec scanf des float
• NewLib avec printf + scanf des float
• NewLib standard
• vitesse du port USB host
• support du port USB host (CDC, HID)

10.2.4. Les connecteur

Les cartes NUCLEO32 adoptent le format ARDUINO NANO. La majorité des pins correspondent à ceux de la NANO, en particulier D0-D13 et A0-A7.

Les pins SDA SCL sont bien sur A4 A5 comme sur un ARDUINO NANO :

Sur les NUCLEO64, il y a deux types de connecteurs :

• deux connecteurs MORPHO 38 points
• 4 connecteurs correspondant à ceux de l'ARDUINO UNO

Si l'utilisation des connecteurs ARDUINO ne pose pas de problème particulier, il n'en va pas de même pour les connecteurs MORPHO.
Tout dépendra du modèle de carte choisi. Comme on le voit sur les deux images ci-dessus il y a de petites différences.

De plus certaines pin sont configurables par des résistances 0Ω situées à l'arrière de la carte.
Par exemple :

• enlever le cavalier SB21 permet de déconnecter la LED sur D13.
• le cavalier SB64 relie VREF/PB1 du STM32 à la pin PBI de la carte
• le cavalier SB65 permet de relier cette même pin au 3.3V analogique AVDD
• etc.

La consultation de la documentation de la carte est indispensable :

NUCLEO32 : https://www.st.com/content/ccc/resource/technical/document/user_manual/e3/0e/88/05/e8/74/43/a0/DM00231744.pdf/files/DM00231744.pdf/jcr:content/translations/en.DM00231744.pdf

Les schémas de la carte sont en figure 9 à 11.

NUCLEO64 : https://www.st.com/content/ccc/resource/technical/document/user_manual/98/2e/fa/4b/e0/82/43/b7/DM00105823.pdf/files/DM00105823.pdf/jcr:content/translations/en.DM00105823.pdf

Les schémas de la carte sont en figure 27 à 30.

NUCLEO144 : https://www.st.com/content/ccc/resource/technical/document/user_manual/group0/26/49/90/2e/33/0d/4a/da/DM00244518/files/DM00244518.pdf/jcr:content/translations/en.DM00244518.pdf

Les schémas de la carte sont en figure 15 à 20.

Si sur les schémas il est facile de voir la correspondance entre chaque pin des connecteurs MORPHO et les pins du STM32.

Par contre dans le code on utilise un N° de port. Quelle va être la correspondance ?

  digitalWrite(port, HIGH);

Par exemple, pour allumer la LED de la carte :

  digitalWrite(13, HIGH);
// OU
  digitalWrite(LED_BUILTIN, HIGH);

Mais on peut aussi utiliser le N° de port STM32 :

  digitalWrite(PB3, HIGH);

Mais cette écriture n'est valable que pour les cartes dont la LED est connectée sur PB3, ici une L031K6, donc préférez la première.

Pour ce qui concerne les pins des connecteurs MORPHO, dans la repository STM32DUINO, il est facile de s'y retrouver :

https://github.com/stm32duino/Arduino_Core_STM32/tree/master/variants

Dans ce répertoire, cliquer sur le lien de votre carte.

Dans le fichier variants.h on trouve toutes les définitions des GPIOs de la carte choisie.

Par exemple pour faire clignoter les 3 LEDs d'une F429ZI :

#define LED_GREEN LED_BUILTIN

#define LED_BLUE PB7

#define LED_RED PB14

#define LED_BUILTIN PB0

10.2.5.  Quelque cartes courantes

10.2.5.1. La NUCLEO L031K6

C'est une carte NUCLEO32 équipée d'un STM32L31K6 :
Elle est plus performante qu'une NANO :

• 32 bits
• 32 MHz
• 32K de Flash
• 8K de RAM
• 1K d'EEPROM
• 2 UARTs
• 1 ADC 12bits
• RTC
• low power :
• 0.23 μA Standby mode (2 wakeup pins)
• 0.35 μA Stop mode (16 wakeup lines)
• 0.6 μA Stop mode + RTC + 8 KB RAM retention

Cette carte a le format d'une ARDUINO NANO, mais comme vous le voyez, elle est beaucoup plus performante.

10.2.5.2.  La NUCLEO L053R8

C'est une carte NUCLEO64 équipée d'un STM32L053R8 :

• 32MHz
• 64K de Flash 
• 8K de RAM
• 2K d'EEPROM
• driver LCD 8×28 segments 
• support 24 touches capacitive
• 3 UARTs
• 1 ADC 12bits
• 1 DAC 12bits
• 2 I2C
• 4 SPI
• RTC 

Cette carte a le format d'une ARDUINO UNO. Je vous laisse apprécier les différences.

10.2.5.3.  La NUCLEO L476RG

C'est une carte NUCLEO64 équipée d'un STM32L476RG :

• 80MHz
• 1M de Flash 
• 128K de RAM
• driver LCD 8×40 ou 4x44 segments
• support 24 touches capacitive
• 6 UARTs
• 3 ADC 12bits
• 2 DAC 12bits
• 3 I2C
• 3 SPI
• RTC 

Cette carte a le format d'une ARDUINO UNO. Je vous laisse apprécier les différences.

10.2.5.4.  La NUCLEO F401RE

C'est une carte NUCLEO64 équipée d'un STM32F401RE :

• 84MHz
• 512K de Flash 
• 96K de RAM
• 3 UARTs
• 1 ADC 12bits
• 3 I2C
• 4 SPI
• 1 SDIO
• 2 CAN
• RTC 

Cette carte a également le format d'une ARDUINO UNO.

10.2.5.5.  La NUCLEO F429ZI

C'est une carte NUCLEO144 équipée d'un STM32F429ZI :

• 180MHz
• 2M de Flash
• 256K de RAM
• 4K de SRAM
• USB OTG
• Ethernet
• interface LCD 8080/6800 
• 4 UARTs
• 2 ADC 12bits
• 2 DAC 12bits
• 3 I2C
• 6 SPI
• 1 SAI
• 2 CAN
• RTC
• 3 LEDs utilisateur 

Cette carte n'a plus rien à voir avec les cartes précédentes, elle ne possède pas les connecteurs correspondants à ceux d'une UNO.

10.2.5.6. La DISCOVERY F469I

C'est une carte DISCOVERY équipée d'un STM32F469NI

• 180MHz
• 2M de Flash
• 384K de RAM
• 4K de SRAM 
• 4Mx32bit SDRAM
• 128Mbit Quad-SPI NOR Flash
• USB OTG
• écran TFT 4" 800x480 capacitif
• 4 UARTs
• 3 I2C
• 6 SPI
• 1 SAI
• 2 CAN
• RTC
• support µSD
• 4 LEDs utilisateur 
• JACK audio
• connecteurs au format ARDUINO UNO

Cette carte n'est pas encore supportée par STM32DUINO, mais elle l'est par PlatformIO en mode MBED et STM32Cube.

11. Tests effectués

11.1. Les ports série

Les ports série sont instanciés en fonction de leur numéro hardware. Sur les cartes précédentes il s'agit de Serial2, sauf la F429ZI : Serial3.

Ensuite la librairie redéfinit Serial :

#define Serial Serial2

Les ports supplémentaires ne semblent pas instanciés, mais il est facile de remédier à cela. Il suffit d'instancier un HardwareSerial dans le code de l'application.

Par exemple pour une F401RE :
- USART1_TX est sur PA9
- USART1_RX est sur PA10

#define LED LED_BUILTIN

HardwareSerial Serial1(USART1); 
void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(115200);
  Serial1.begin(115200);
}

void loop() {
  digitalWrite(LED, HIGH);
  delay(1000);
  digitalWrite(LED, LOW);
  delay(1000);
  Serial.println("OK");
  Serial1.println("OK");
}

Il suffit ensuite de brancher un convertisseur USB / série sur PA9 et PA10 pour que cela fonctionne.

11.2. L'ADC

L'ADC du STM32 a une résulution de 12bits. La tension de référene par défaut est de 3.3V. Afin d'obtenir un résultat de mesure correct il faut écrire ceci :

#define VREF      3.3
// pont diviseur 100KΩ / 10KΩ
#define DIVIDER   0.09

void setup()
{
  Serial.begin(115200);
  pinMode(A0, INPUT_ANALOG);
  analogReadResolution(12);
}

void loop()
{
  uint16_t valA0 = analogRead(A0);
  Serial.print("analogRead: ");
  Serial.println(valA0);
  float voltage = (float)valA0 * VREF / 4096 / DIVIDER;
  Serial.print("Voltage: ");
  Serial.print(voltage);
  Serial.println(" V");
  delay(1000);
}

Cet exemple mesure une tension de 5V à travers un pont diviseur de 100KΩ / 10KΩ.
La vitesse d’échantillonnage est supérieure à celle d'un ARDUINO mais reste faible : 18000 SPS sur une F401RE.

Le problème :
La fonction adc_read_value() de la librairie STM32DUINO initialize l'ADC et le canal à chaque appel, ce qui provoque une perte de temps considérable.

Il est préférable d'initialiser l'ADC dans la fonction setup() une bonne fois pour toutes, et de faire uniquement la lecture en cas de besoin. On obtient ainsi plus de 26000 SPS :

https://bitbucket.org/henri_bachetti/stm32duino-samples/src/f4ce90e5178f68423e827b45d455dd0b04afd53e/adc/f401re-polling

Il est possible également de faire la lecture par interruption ou par DMA.
 

11.3. L'affichage

11.3.1. Le PCF8574

J'ai essayé de connecter sur une carte L031K6 un afficheur LCD 2x16 caractères avec un module I2C PCF8574.

J'ai utilisé la librairie suivante : https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library.git

La mise en œuvre de l'exemple HelloWorld se déroule parfaitement bien.

11.3.1. Le MAX7219

J'ai réalisé un petit projet personnel sur une BLUE PILL : MAX7219 sur STM32.
Ce projet comprend :

• un afficheur 8 x 7 segments MAX7219
• un module I2C RTC DS3231

Le MAX7219 est un composant utilisant un protocole à deux fils :

•  un fil horloge
• un fil pour les données

Il ne s'agit donc pas d'I2C ou de SPI.

Ce projet a débuté sur un ARDUINO NANO et je l'ai porté ensuite avec une grande facilité sur la BLUE PILL. Il fonctionne depuis le 25 novembre :

11.3.2. Le ST7735

L'utilisation d'un TFT 1.8" SPI ST7735 est aussi facile que sur un ARDUINO.  L'écran est celui-ci : https://fr.aliexpress.com/item/1-8-1-8-pouce-TFT-LCD-Module-D-affichage-ST7735S
J'utilis en général la librairie suivante : https://github.com/adafruit/Adafruit-ST7735-Library

La mise en œuvre de l'exemple graphicstest ne pose aucun problème.

Le câblage est le celui indiqué dans le code :

• VCC sur 5V
• GND sur GND
• CLK sur D13
• SDA (MOSI) sur D12
• CS sur D10
• RS (sur A0
• RST sur A1

11.3.3. Le ILI9341

L'écran est celui-ci : https://fr.aliexpress.com/item/2-8-240x320-SPI-TFT-LCD-Port-S-rie-Module-Adaptateur-PCB-Micro-SD-ILI9341-5/32899132892.html?spm=a2g0s.9042311.0.0.27426c37X0SmM6
Mauvaise surprise la librairie UTFT  n'accepte pas ces processeurs ARM. Mais il reste celle-ci : https://github.com/adafruit/Adafruit_ILI9341

Ici aussi la mise en œuvre de l'exemple graphicstest ne pose aucun problème.

Le câblage est le celui indiqué dans le code :

• VCC : 5V ou 3.3V
• GND
• CS : pin D10
• RST : pin D8
• DC : pin D9
• MOSI : pin D11
• SCK : pin D13
• LED : 5V ou 3.3V
• MISO : pin D12

11.4. Divers

11.4.1. Circuit RTC

Comme dit plus haut, un module I2C RTC DS3231 fonctionne sans problème avec la même librairie qu'un ARDUINO.

11.4.2. Le bus One Wire

Un capteur de température du type DS3231 ne peut pas fonctionner car la librairie OneWire ARDUINO n'est pas adaptée.
Recherches en cours ...

11.4.3. Déboguer une application STM32

Ici un article sur le sujet : https://riton-duino.blogspot.com/2019/03/stm32-duino-deboguer.html

12. Liens utiles

Le forum STM32DUINO.Le lien sur la carte BLUE PILL.
La datasheet du processeur.

Le schéma de la carte.

Environnements : https://riton-duino.blogspot.com/2019/03/stm32-environnements-de-developpement.html
ST-LINK : https://riton-duino.blogspot.com/2019/03/stm32-boitier-st-link.html
Déboguer : https://riton-duino.blogspot.com/2019/03/stm32-duino-deboguer.html

13. Conclusion

Les cartes STM32 sont de mieux en mieux supportées par STM32DUINO. Les progrès réalisés ces derniers mois en particulier sur le support des cartes ST MicroElectronics NUCLEO et DISCOVERY sont énormes.


Cordialement
Henri

14. Mises à jour

25/11/2018 : ajout lien sur "MAX7219 sur STM32".
                       ajout paragraphe 9. Pinout de la carte.
22/03/2019 : 10. Les cartes
                       11. Tests effctués
                       11.1. Les ports série
25/03/2019 : 11.2. L'ADC
27/03/2019 : 11.3. L'affichage
28/03/2019 : 11.4. Divers
                       11.4.3. Déboguer une application STM32
30/03/2019 : 10.1.1. La STM32F030 demo board
                       10.1.2. La Blue Pill
                       10.1.3. La Maple Mini
                       10.1.4. La Black VET6
                       12. Liens utiles
29/08/2019 : 4. Installation
23/04/2022 : version STM32DUINO 2.1.0