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.
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 :
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) |
 |
|
|
 |
|
|
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
- 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 |
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.
