Programmer un Arduino avec un Raspberry Pi via SSH

Il est très intéressant de coupler un Arduino avec un Raspberry Pi. L’arduino permet de faire interface avec différents systèmes (capteur, module, driver …). Il peut également faire office de périphérique entièrement programmable. Le Raspberry peut alors s’occuper de la partie applicative avancée d’un projet (interface, connectivité, programme avancé …).
Dans cette configuration, il est nécessaire de pouvoir programmer l’Arduino directement depuis le Raspberry Pi.

Dans cet article nous allons voir comment utiliser l’outil PlatformIO Core en ligne de commande. Un des plus gros avantage de cette solution est la compatibilité avec de nombreuses cartes à microcontrôleur embarqué (AVR, STM32, ESP …).
Documentation de PlatformIO Core
Si vous utilisez déjà PlatformIO avec VScode, vous ne serez pas désorienté. La principale différence se situe au niveau de l’éditeur et de la gestion des fichiers sources. En effet dans notre cas nous allons travailler de manière déportée. Nous allons voir comment procéder avec un Raspberry Pi sans interface graphique avec un accès en SSH (Indispensable lors de l’utilisation de Raspberry Pi zero par exemple). Il faudra utiliser un éditeur sur terminal ou utiliser un éditeur sur un autre ordinateur.

Logo Raspberry Pi
Logo PlatformIO
Logo Arduino

Prérequis

La suite de cet article suppose d’avoir un Raspberry Pi opérationnel en SSH et accessible via Ethernet/Wifi. Python3 et pip doivent être installés sur le Raspberry. Un Arduino fonctionnel est connecté à un port USB du Raspberry.
L’ordinateur de contrôle doit posséder un client SSH (Windows : MobaXterm, PuttY … / Linux : commande ssh / OSX : commande ssh)
Il est préférable d’avoir des connaissances sur l’utilisation de linux en ligne de commande, sur la programmation Arduino et sur l’utilisation de PlatformIO.

Installation de PlatformIO Core sur Raspberry Pi

Avant toute chose, il faut se connecter au Raspberry PI via SSH :

ssh monlogin@addressIpRaspberry

Python3 et pip doivent être installés. Sinon entrer la commande suivante :

sudo apt-get install python3 python3-pip

Installation de PlatformIO Core sur le Raspberry PI :

sudo python3 -m pip install -U platformio

Création d’un projet PlatformIO

PlatformIO contient une base de donné avec des configurations pour beaucoup de cartes embarquées. Les chaînes d’outils et les scripts de compilation/téléchargement sont installés de façon transparente. Ainsi, il est possible de générer automatiquement des projets pré-configurés en spécifiant le nom de la carte.

Tout d’abord il faut créer un répertoire pour le projet du programme de l’Arduino.

mkdir ~/ArduinoProject && cd ~/ArduinoProject

Initialisation du projet platformIO :

platformio init -b uno

Remplacer uno par le nom de la carte utilisé. La commande « platformio boards » renvoi la liste des cartes supportées par PlatformIO

Code source Arduino

Le fichier source principal par défaut est le suivant : src/main.cpp

Il existe de nombreuses façon pour éditer le code source du programme Arduino.

Solution possibles :

– Edition des fichiers sources directement sur le Raspberry Pi via SSH à l’aide d’un éditeur terminal (vim, nano …)

nano src/main.cpp

– Edition des fichiers sources sur un autre ordinateur et copie des fichier via une commande « scp »

scp main.cpp monlogin@addressIpRaspberry:ArduinoProject/src

– Utilisation d’un gestionnaire de version (svn, git …)

Cette solution est la plus propre et moderne. Elle permet une meilleure gestion de l’évolution du code et du travail en équipe.

Exemple de code pour Arduino :

#include "Arduino.h"

#define BUILT_LED   13

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

void loop() 
{
    Serial.println("hello");
    digitalWrite(BUILT_LED,LOW);
    delay(500);
    digitalWrite(BUILT_LED,HIGH);
    delay(500);
}

Compilation et Téléversement

Pour lancer une compilation, il faut se placer dans le répertoire du projet PlatformIO et entrer la commande :

platformio run

Lors de la première compilation pour un type de carte, platformIO va télécharger et installer toutes les librairies nécessaires. Cela peut prendre un certain temps suivant la connexion et le type de Raspberry Pi.

Pour lancer une compilation du code et un téléversement dans l’Arduino :

platformio run -t upload

Moniteur série

Pour utiliser le moniteur série, il faut ajouter la ligne « monitor_speed = 115200 » dans le fichier platform.ini du projet.

Exemple pour un Arduino Uno avec une communication série à 115200 Bauds :

; PlatformIO Project Configuration File
;
;   Build options: build flags, source filter
;   Upload options: custom upload port, speed and extra flags
;   Library options: dependencies, extra library storages
;   Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html

[env:uno]
platform = atmelavr
board = uno
framework = arduino

monitor_speed = 115200

Le moniteur série se lance avec la commande suivante :

platformio device monitor

Pour lancer la compilation, le téléversement et le moniteur série :

platformio run -t upload && platformio device monitor

Résultat obtenu sur le terminal du Raspberry Pi avec le code d’exemple pour Arduino :

pi@raspberrypi:ArduinoProject $ platformio run -t upload && platformio device monitor
Processing uno (platform: atmelavr; board: uno; framework: arduino)
------------------------------------------------------------------------------------------------------------------------------------
Verbose mode can be enabled via `-v, --verbose` option
CONFIGURATION: https://docs.platformio.org/page/boards/atmelavr/uno.html
PLATFORM: Atmel AVR 2.2.0 > Arduino Uno
HARDWARE: ATMEGA328P 16MHz, 2KB RAM, 31.50KB Flash
DEBUG: Current (simavr) On-board (simavr)
PACKAGES:
 - framework-arduino-avr 5.0.0
 - tool-avrdude 1.60300.200527 (6.3.0)
 - toolchain-atmelavr 1.50400.190710 (5.4.0)
LDF: Library Dependency Finder -> http://bit.ly/configure-pio-ldf
LDF Modes: Finder ~ chain, Compatibility ~ soft
Found 5 compatible libraries
Scanning dependencies...
No dependencies
Building in release mode
Checking size .pio/build/uno/firmware.elf
Advanced Memory Usage is available via "PlatformIO Home > Project Inspect"
RAM:   [=         ]   9.5% (used 194 bytes from 2048 bytes)
Flash: [=         ]   6.1% (used 1970 bytes from 32256 bytes)
Configuring upload protocol...
AVAILABLE: arduino
CURRENT: upload_protocol = arduino
Looking for upload port...

Auto-detected: /dev/ttyACM0
Uploading .pio/build/uno/firmware.hex

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: reading input file ".pio/build/uno/firmware.hex"
avrdude: writing flash (1970 bytes):

Writing | ################################################## | 100% 0.33s

avrdude: 1970 bytes of flash written
avrdude: verifying flash memory against .pio/build/uno/firmware.hex:
avrdude: load data flash data from input file .pio/build/uno/firmware.hex:
avrdude: input file .pio/build/uno/firmware.hex contains 1970 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.30s

avrdude: verifying ...
avrdude: 1970 bytes of flash verified

avrdude: safemode: Fuses OK (E:00, H:00, L:00)

avrdude done.  Thank you.

=================================================== [SUCCESS] Took 17.34 seconds ===================================================
--- Available filters and text transformations: colorize, debug, default, direct, hexlify, log2file, nocontrol, printable, send_on_enter, time
--- More details at http://bit.ly/pio-monitor-filters
--- Miniterm on /dev/ttyACM0  115200,8,N,1 ---
--- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
hello
hello
hello
hello
hello

--- exit ---

Conclusion

Vous pouvez maintenant programmer un Arduino avec un Raspberry Pi à distance avec un terminal en SSH.
Vous pouvez consulter la documentation de PlatformIO pour découvrir les usages plus avancés.