L’Internet des Objets

L’Internet des Objets

2.1 Le matériel STM

Page précédente Page suivante

La société STMicroelectronics produit des microcontroleurs et des capteurs numériques. Ceux-ci peuvent être intégrés dans des cartes. Les cartes que nous utilisons sont principalement :

Nucleo

des cartes permettant de tester un microcontrôleur ;

Discovery

des cartes comportant un microcontrôleur et des capteurs ;

X-Nucleo

des cartes filles hébergeant principalement des capteurs ou actionneurs ;

D’autres objets existent développées par ST ou d’autres fabricants, comme les cartes MicroPython, les cartes LoRa de Seeedstudio…Nous présentons ici les cartes que nous avons manipulées :

Nucleo

les cartes Nucleo

Nucleo WB55

la carte Nucleo avec capacité BLE et d’autres protocoles similaires ;

USB WB55

le processeur WB55 est disponible en carte Nucleo et en carte USB ;

Seeedstudio WL55

une carte LoRa programmable en commandes AT ;

2.1.1 Nucleo WB55

Les WB55 sont disponibles sous forme de kit combinant les deux cartes, comme dans la figure 2.1. L’une est une carte Nucleo avec les connecteurs compatibles Arduino, l’autre est une clef au format USB A.

(image)

Fig. 2.1 : Le kit WB 55.

La carte WB55 (voir la figure  ??) est une carte Nucleo offrant des possibilités de communications Bluetooth, OpenThread et Zigbee. Pour le moment seul le protocole BLE est utilisable avec l’IDE Arduino ou MicroPython.

(image)

Fig. 2.2 : La carte Nucleo WB55.

Cette carte peut être programmée avec l’interface Arduino ou micropython, voir 6.4, pour la communication BLE. L’entreprise propose une interface de programmation (dérivée d’Eclipse) permettant un contrôle fin des composants internes mais difficile à prendre en mail.

La carte comporte :

  • • 2.4 GHz RF transceiver supporting Bluetooth® specification v5.0 and IEEE 802.15.4-2011 PHY and MAC

  • • Three user LEDs

  • • Three user buttons and one reset button

  • • Board connector : USB user with Micro-B

  • • Connecteurs : Arduino™ Uno V3, ST morpho

  • • On-board socket for CR2032 battery

Le support de la pile impose de modifier physiquement la carte en modifiant l’alimentation par coupure et soudure. Les boutons sont difficilement accessibles si une carte fille est ajoutée.

La documentation est disponible sur https://www.st.com/resource/en/user_manual/dm00517423-bluetooth-low-energy-and-802154-nucleo-pack-based-on-stm32wb-series-microcontrollers-stmicroelectronics.pdf

Nous l’avons utilisée avec le shield IKS01A3, présenté au chapitre 18, le shield GNSS ou le shield Grove. Nous la programmons principalement en micropython (voir 6.2.3). Les shields sont difficilement empilables pour des raisons mécaniques.

2.1.1.1 Composant radio

Le firmware du composant Radio peut aussi être modifié. La procédure impose d’utiliser les outils de ST, le firmware est disponible à l’adresse :

https://github.com/STMicroelectronics/STM32CubeWB/blob/master/Projects/STM32WB_Copro_Wireless_Binaries/STM32WB5x/

Les librairies Micropython spécifiques aux STM32 fournissent quelques commandes utiles (avec deux exemples issus de deux cartes différentes) :

statut du composant radio

stm.rfcore_status() Returns the status of the second CPU as an integer (the first word of device info table). 

>>> stm.rfcore_status()
2839959225
>>> stm.rfcore_status()
0
version du firmware radio

stm.rfcore_fw_version(id)

Get the version of the firmware running on the second CPU.

0

Pass in 0 for id to get the FUS version, and

1

to get the WS version. 

>>> stm.rfcore_fw_version(0)
(1, 2, 0, 0, 0)
>>> stm.rfcore_fw_version(1)
(1, 16, 0, 0, 4)
>>> stm.rfcore_fw_version(0)
(0, 0, 0, 0, 0)
>>> stm.rfcore_fw_version(1)
(1, 0, 0, 4, 3)

la version du fus est fournie par le paramètre 0. En 2024, c’est 1.2.0.0. Nous voyons donc que le premier est à jour, mais pas le second. 

#! /bin/sh
URL=https://stm32python.gitlab.io/fr/docs/tools/cubeprog/cube_prog_firmware_ble_hci
for file in Release_Notes.html \
           stm32wb5x_BLE_HCILayer_fw.bin \
           stm32wb5x_FUS_fw_for_fus_0_5_3.bin \
           stm32wb5x_FUS_fw.bin ;
do
  wget $URL/$file -O /tmp/$file
done

Après une mise à jour, nous obtenons aujourd’hui (5 mars 2024) : 

>>> stm.rfcore_status()
2839959225
>>> stm.rfcore_fw_version(0)
(1, 2, 0, 0, 0)
>>> stm.rfcore_fw_version(1)
(1, 18, 0, 0, 3)

La page https://stm32python.gitlab.io/fr/docs/tools/cubeprog/cube_prog_firmware_ble_hci présente comment mettre à jour le composant radio à partir de l’IDE de ST.

ATTENTION : nous présentons ici un résumé, il faut d’abord utiliser la page de stm32python pour tout vérifier, en particulier les adresses.

Il faut commencer par aller sur le site ST et trouver STM32CUBEIDE pour télécharger l’archive. Ce programme n’impose pas les droits d’administrateur, ce qui est une bonne chose. Mais le logiciel demande les droits d’écriture sur le compodant USB.

Ensuite, aller sur le site https://github.com/STMicroelectronics/STM32CubeWB/blob/master/Projects/STM32WB_Copro_Wireless_Binaries/STM32WB5x/ pour récupérer les mises à jour. Il y a deux firmwares à éventuellement upgrader. Le FUS (Firmware Upĝrader Service et la pile BLE HCILayer. Il existe deux versions de la seconde, nous prendrons celle qui n’est pas étendue.

Examinons ce que nous dit MicroPython de la carte : 

stm.rfcore_status()
2839959225
stm.rfcore_fw_version(0)
(0, 5, 3, 0, 0)
stm.rfcore_fw_version(1)
(0, 0, 0, 0, 0)

Donc le FUS n’est pas à jour, il faut prendre l’upgrade pour la version 0.5.3. Le firmware radio est inexistant ou effacé. Commençons par mettre le FUS à jour : 

alias stcli=$HOME/STMicroelectronics/STM32Cube/STM32CubeProgrammer/bin/STM32_Programmer_CLI
stcli -c port=swd \
     -fwupgrade stm32wb5x_FUS_fw_for_fus_0_5_3.bin \
      0x080EC000 firstinstall=0

Puis nous effaçons le firmware radio avant d’installer la mise à jour : 

stcli -c port=swd -fwdelete
stcli -c port=swd \
        -fwupgrade    stm32wb5x_BLE_HCILayer_fw.bin \
         0x080E0000 firstinstall=1

Après installation de MicroPython, nous voyons les valeurs suivantes : 

>>> stm.rfcore_status()
0
>>> stm.rfcore_fw_version(0)
(1, 2, 0, 0, 0)
>>> stm.rfcore_fw_version(1)
(1, 18, 0, 0, 3)
>>>
2.1.2 La pitchoune WB55

Le kit WB55 vient aussi avec une petite carte WB55-USB avec un connecteur USB-A.

(image)

Fig. 2.3 : La desciption des composants du Dongle WB55.

2.1.2.1 Installation du firmware sur la pitchoune

Le sélecteur BOOTO permet de sélectionner la connection USB. Il faut le manipuler avant de brancher le dongle. La documentation fournit peu d’explications :

The USB dongle can be programmed through USB BootLoad or USB DFU. It is also possible to debug/program it with an external STLink V2 (not delivered), using the SWD interface.

En sélectionnant le switch sur 0, il apparaît comme un périphérique série(USB ACM). 

Bus 001 Device 074: ID 0483:5740 STMicroelectronics Virtual COM Port

En le commutant sur 1, nous voyons la mise en place d’un périphérique DFU (DFU in FS Mode). DFU (Device Firmware Update) permet de modifier le comportement d’un périphérique (en particulier USB) pour qu’il accepte le changement de firmware. 

Bus 001 Device 068: ID 0483:df11 STMicroelectronics STM Device in DFU Mode

Après l’installation du paquet dfu-util, nous trouvons un périphérique. Il semble qu’il ne le trouve pas à chaque fois. 

=> dfu-util -l
...
Found DFU: [0483:df11] ver=0200, devnum=107, cfg=1, intf=0, path="1-1.4.1", alt=2, name="@OTP Memory   /0x1FFF7000/01*1024 e", serial="205B3766594D"
Found DFU: [0483:df11] ver=0200, devnum=107, cfg=1, intf=0, path="1-1.4.1", alt=1, name="@Option Bytes   /0x1FFF8000/01*128 e", serial="205B3766594D"
Found DFU: [0483:df11] ver=0200, devnum=107, cfg=1, intf=0, path="1-1.4.1", alt=0, name="@Internal Flash   /0x08000000/256*04Kg", serial="205B3766594D"

Nous voyons trois périphériques DFU. Le dernier (numéro 0) indique que c’est la flash qui commence à l’adresse indiquée.

La compilation de micropython pour le dongle (USBDONGLE_WB55) a produit un fichier firmware.dfu que nous allons flasher. 

=> dfu-util -a 0 -D /tmp/firmware.dfu
dfu-util 0.9

Copyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.
Copyright 2010-2016 Tormod Volden and Stefan Schmidt
This program is Free Software and has ABSOLUTELY NO WARRANTY
Please report bugs to http://sourceforge.net/p/dfu-util/tickets/

Match vendor ID from file: 0483
Match product ID from file: df11
Opening DFU capable USB device...
ID 0483:df11
Run-time device DFU version 011a
Claiming USB DFU Interface...
Setting Alternate Setting #0 ...
Determining device status: state = dfuIDLE, status = 0
dfuIDLE, continuing
DFU mode device DFU version 011a
Device returned transfer size 1024
DfuSe interface name: "Internal Flash   "
file contains 1 DFU images
parsing DFU image 1
image for alternate setting 0, (1 elements, total size = 215720)
parsing element 1, address = 0x08000000, size = 215712
Download        [=========================] 100%       215712 bytes
Download done.
done parsing DfuSe file

il devient alors un Pyboard. 

Bus 001 Device 031: ID f055:9800 MicroPython Pyboard Virtual Comm Port in FS Mode
2.1.2.2 Description de la WB55-USB

La figure 2.4 présente les connecteurs d’extensions de la carte. La carte est livrée sans les broches soudées, ce qui peut poser quelques soucis pour ceux qui ne savent pas souder.

(image)

Fig. 2.4 : Les connecteurs de la WB55 USB

La clef dispose de fonctionnalités classiques :

  • • GPIO classique (probablement numérique) ;

  • • Convertisseurs analogique — numérique :

  • • UART (liaison série) ;

  • • Bus I2C ;

  • • Bus SPI ;

  • • Une broche WKUP (Wakeup ?) ;

  • • Une fonctionnalité de débug.

.
CN2 CN1
10 PA1 ADC SPI1_MOSI PA7 10
9 GND SPI1_MISO PA6 9
8 PA8 ADC SPI1_SCK PA5 8
7 PA9/PB7 PWM?/GPIO SPI1_NSS PB2 7
6 PB6 GPIO +3,3V 6
5 PA3 LPUART1_RX db: SWO PB3 5
4 PA2 LPUART1_TX db: SWCLK PA14 4
3 PA0 WKUP1 db: SWDIO PA13 3
2 PB9 I2C1_SDA RESET NRST 2
1 PB8 I2C1_SCL GND 1

Tab. 2.1 : Liste des connecteurs de la WB55 USB.

2.1.2.3 La carte NUCLEO-L476RG

Nous présentons ici un autre exemple de carte NUCLEO. Cette carte a un format différent de la carte WB55, elle est présentée dans la figure 2.5. La documentation est https://www.st.com/en/evaluation-tools/nucleo-l476rg.html

Cette carte dispose de plusieurs fonctionnalités qui manquent à la WB55, en particulier six connecteurs séries.

(image)

Fig. 2.5 : 

2.1.3 La carte STM32H723G

La carte STM32H723G dispose de capacité Ethernet et d’une prise RJ45. Sa https://www.st.com/resource/en/user_manual/um2407-stm32h7-nucleo144-boards-mb1364-stmicroelectronics.pdf

(image)

Fig. 2.6 : Carte STM32 Nucleo-144 STM32H723ZG MCU.

La carte est munie de deux connecteurs USB. Le connecteur lié au ST-LINK est à l’opposé du connecteur RJ45. C’est lui qui, par défaut, alimente la carte. L’autre est celui qui sera utilisé par MicroPython. Le port ST-LINK fournit une console et un périphérique de mémoire de masse. L’autre fournit la version MicroPython de la console, la mémoire de masse fournit l’accès au système de fichiers MicroPython. La figure 2.7 présente les deux connecteurs branchés simultanément.

(image)

Fig. 2.7 : Double branchement USB pour la H723ZG-2USB

Cette carte dispose de plusieurs UART qui sont disponibles en MicroPython : 

// UART config
#define MICROPY_HW_UART2_TX             (pin_D5)
#define MICROPY_HW_UART2_RX             (pin_D6)
#define MICROPY_HW_UART2_RTS            (pin_D4)
#define MICROPY_HW_UART2_CTS            (pin_D3)
#define MICROPY_HW_UART3_TX             (pin_D8)
#define MICROPY_HW_UART3_RX             (pin_D9)
#define MICROPY_HW_UART5_TX             (pin_B6)
#define MICROPY_HW_UART5_RX             (pin_B12)
#define MICROPY_HW_UART6_TX             (pin_C6)
#define MICROPY_HW_UART6_RX             (pin_C7)
#define MICROPY_HW_UART7_TX             (pin_F7)
#define MICROPY_HW_UART7_RX             (pin_F6)
#define MICROPY_HW_UART8_TX             (pin_E1)
#define MICROPY_HW_UART8_RX             (pin_E0)

#define MICROPY_HW_UART_REPL            PYB_UART_3
#define MICROPY_HW_UART_REPL_BAUD       115200

Les connecteurs sont présentés dans la figure 2.8

(image)

Fig. 2.8 : Les broches de la Nucleo H723.

L’UART 3 est utilisé par la console (simultanée entre ST-Link et python). Nous pouvons utiliser l’UART 2. La documentation indique que les broches utilisées sont :

  • • PD6 / D52, fil jaune communication depuis LoRa ;

  • • PD5 / D53 fil blanc pour l’inverse.

L’alimentation doit être branchée sur le 5V et il ne faut pas oublier la masse.

Le support Ethernet est assez simple en MicroPython. 

import network

nic = network.LAN()
nic.active(1)
if not nic.isconnected():
    nic.connect()
    print("Waiting for connection...")
    while not nic.isconnected():
        time.sleep(1)
print(nic.ifconfig())
print(nic.ipconfig("addr4"))

Dans ce mode, la carte prend ses paramètres IP en DHCP. Il faut donc attendre un peu avant d’utiliser le réseau. Ce serait bien de trouver comment vérifier que la connexion est établie.

La carte dispose de deux connecteurs USB. Il semble qu’il soit possible de les utiliser simultanément. Dans la photo de la figure 2.7. Sur cette photo, le connecteur USB à droite est labellisé USB PWR, il fournit donc l’alimentation et le port ST-Link. Le connecteur de gauche, labellisé USB User permet de fournir un accès mass storage au système de fichier MicroPython.

2.1.4 Jouez avec les UART

Les cartes NUCLEO disposent d’un module ST-LINK qui sert à la programmer et offre également un canal de communication série avec l’ordinateur auquel elle est connectée. Pour assurer ses missions de programmeur de firmware et de liaison pour le débogage, le ST-LINK est animé par un microcontrôleur STM32L0 programmé avec son propre firmware.

Ce module fournit du côté USB une émulation de port Modem (/dev/ttyACM0) et une mémoire de masse. Sur l’interface interne, ce module est connecté à une des UART du microcontroleur principal de la carte NUCLEO. La figure 2.9 présente les connecteurs de chaque UART.

(image)

Fig. 2.9 : Les ports série du L475RG.

Le premier port utilisé est celui affecté au ST-LINK. Celui-ci est routé vers l’UART 2. Cet UART est utilisé par le connecteur Arduino et peut rentrer en conflit avec certains shields, comme le shield Grove ou le shield GNSS. Pour utiliser ces broches, il faut donc les couper la liaison avec le ST-LINK.

Pour débuguer la communication, il faudra mettre en place un montage temporaire. Nous allons lier

Page précédente Page suivante

Page précédente Page suivante