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 versionsLe 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