Atelier

Avant de commencer

Chemin 1 : PlatformIO + VS Code (recommandé)

PlatformIO regroupe la chaîne d'outils ARM, Zephyr et un système de compilation dans une seule extension VS Code. C'est le chemin le plus court vers un firmware qui clignote.

1. Installer Visual Studio Code.
2. Installer l'extension PlatformIO IDE.
3. Créer un projet micro:bit V2 avec le framework Zephyr.
4. Compiler, flasher, ouvrir le moniteur série.

1. Installer VS Code

$ sudo dpkg -i code_*.deb

$ brew install --cask visual-studio-code

> winget install Microsoft.VisualStudioCode

2. Installer l'extension PlatformIO IDE

1. Ouvrir VS Code.
2. Cliquer sur l'icône Extensions dans la barre latérale (ou Ctrl+Shift+X).
3. Chercher PlatformIO IDE, cliquer Install.
4. Attendre la fin de l'initialisation (3 à 5 minutes la première fois). Redémarrer VS Code si demandé.

Une icône en forme de tête d'alien apparaît dans la barre latérale. C'est ton point d'entrée PlatformIO.

3. Créer un projet micro:bit V2 + Zephyr

1. Icône alien → PIO Home → Open.
2. + New Project.
3. Nom du projet : oktalos-blink.
4. Carte : BBC micro:bit V2.
5. Framework : Zephyr.
6. Finish. Patiente, le téléchargement de Zephyr prend quelques minutes.

Édite platformio.ini pour forcer Zephyr 4.x (évite le bug distutils Python 3.12+) :

 [env:bbc_microbit_v2]
platform = nordicnrf52
board = bbc_microbit_v2
framework = zephyr
platform_packages = platformio/framework-zephyr @ ~3.40201.0
monitor_speed = 115200

4. Premier flash blink

Remplace src/main.c par :

 #include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>

#define ROW1 DT_ALIAS(led0)
static const struct gpio_dt_spec led =
    GPIO_DT_SPEC_GET(ROW1, gpios);

int main(void) {
    gpio_pin_configure_dt(&led, GPIO_OUTPUT_ACTIVE);
    while (1) {
        gpio_pin_toggle_dt(&led);
        k_msleep(500);
    }
    return 0;
}

Branche le micro:bit en USB. Puis, dans la barre du bas de VS Code :

• ✓ = compiler (build).
• → = compiler puis flasher (upload).
• 🔌 = ouvrir le moniteur série.

Clique sur →. La LED jaune du micro:bit clignote pendant le flash, puis la matrice 5×5 s'anime. Bravo, tu viens de compiler ton premier firmware Zephyr.

5. Moniteur série

Ajoute printk("hello\n"); dans ta boucle, recompile, puis ouvre le moniteur série (icône prise électrique). Vérifie que le baudrate est bien à 115200. Si rien ne s'affiche, vois la résolution de problèmes.

Chemin 2 : west natif

west est l'outil officiel de gestion des projets Zephyr. Plus d'étapes qu'avec PlatformIO, mais tu obtiens un environnement de référence, identique à celui de la doc Zephyr.

1. Prérequis système

$ sudo apt update
sudo apt install --no-install-recommends \
    git cmake ninja-build gperf ccache \
    dfu-util device-tree-compiler wget \
    python3-dev python3-pip python3-setuptools \
    python3-tk python3-wheel xz-utils file \
    make gcc gcc-multilib g++-multilib libsdl2-dev

$ brew install cmake ninja gperf python3 ccache \
    dtc libmagic wget openocd

> wsl

2. Installer west

$ pip3 install --user west

Ajoute ~/.local/bin au PATH si ce n'est pas déjà fait :

$ echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

3. Initialiser un workspace Zephyr

$ mkdir ~/zephyrproject && cd ~/zephyrproject
west init
west update
west zephyr-export
pip3 install --user -r zephyr/scripts/requirements.txt

west update télécharge Zephyr et tous ses modules. Compte 10 à 20 minutes la première fois.

4. Installer le Zephyr SDK (ARM)

Le SDK contient le compilateur croisé ARM. Sur la page des versions du SDK Zephyr, récupère la 0.16.x ou plus récente. Sur Linux x86_64 :

$ cd ~
wget https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.17.0/zephyr-sdk-0.17.0_linux-x86_64.tar.xz
tar xvf zephyr-sdk-0.17.0_linux-x86_64.tar.xz
cd zephyr-sdk-0.17.0
./setup.sh -t arm-zephyr-eabi -h -c

L'option -h installe les règles udev (autorisation USB sur Linux). -c enregistre le SDK pour CMake.

5. Compiler blinky pour micro:bit V2

$ cd ~/zephyrproject/zephyr
west build -p always -b bbc_microbit_v2 samples/basic/blinky

-p always nettoie avant chaque compilation (utile en phase d'apprentissage). Le firmware est généré dans build/zephyr/zephyr.hex.

6. Flasher

$ west flash

Ou en glisser-déposer : copie build/zephyr/zephyr.hex sur le lecteur MICROBIT. C'est aussi la méthode à utiliser sous WSL2 (le micro:bit apparaît dans l'explorateur Windows).

Chemin 3 : Docker

Une image Docker pré-construite contient toute la chaîne d'outils. Tu n'installes rien sur ta machine, et tu obtiens un environnement reproductible, identique sur Linux, macOS et Windows.

1. Installer Docker

$ sudo usermod -aG docker $USER
# Se deconnecter / reconnecter pour appliquer

2. Récupérer l'image oktal-builder

$ docker pull registry.gitlab.com/yoseli-org/oktal-builder:latest

L'image embarque PlatformIO, le SDK Zephyr ARM, et toutes les dépendances. Taille : environ 2 Go.

3. Compiler ton projet

Place-toi dans le dossier de ton projet PlatformIO (celui qui contient platformio.ini), puis :

$ docker run --rm \
    -v $(pwd):/workspace \
    -w /workspace \
    registry.gitlab.com/yoseli-org/oktal-builder:latest \
    pio run

Le .hex est généré dans .pio/build/bbc_microbit_v2/firmware.hex, directement accessible depuis ton système hôte grâce au volume monté.

4. Flasher depuis l'hôte

Le flash USB depuis un conteneur Docker est compliqué (passage de périphériques USB). On fait au plus simple : glisser-déposer le fichier firmware.hex sur le lecteur MICROBIT qui apparaît dans ton explorateur de fichiers. Universel, fonctionne sur les trois OS.

$ docker run --rm \
    --device=/dev/ttyACM0 \
    --device-cgroup-rule='c 189:* rmw' \
    -v /dev/bus/usb:/dev/bus/usb \
    -v $(pwd):/workspace -w /workspace \
    registry.gitlab.com/yoseli-org/oktal-builder:latest \
    pio run -t upload

Dépôts GitLab

Les sources du livre, des firmwares et des solutions sont publiques sur GitLab. Clone le projet, propose une amélioration : il est ouvert.

Résolution de problèmes

Dix soucis classiques rencontrés en chemin. Clique sur une ligne pour dérouler la solution.

 could not open port /dev/ttyACM0: [Errno 13] Permission denied

$ sudo usermod -aG dialout $USER
# IMPORTANT : se deconnecter / reconnecter ensuite

$ sudo tee /etc/udev/rules.d/99-microbit.rules << 'EOF'
SUBSYSTEM=="usb", ATTRS{idVendor}=="0d28", \
ATTRS{idProduct}=="0204", MODE="0666"
EOF

sudo udevadm control --reload-rules
sudo udevadm trigger

$ echo 'export PATH="$HOME/.platformio/penv/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

 platform_packages = platformio/framework-zephyr @ ~3.40201.0

$ pip install setuptools

Problème pas listé ? Consulte la doc PlatformIO, la doc Zephyr, ou le forum PlatformIO.