Arduino IDE : Utiliser un Raspberry Pi comme programmateur externe

Cet article traite de la configuration nécessaire pour utiliser un Raspberry Pi en tant que programmateur SPI de microcontrôleurs tels que l'ATtiny85. Le flash sera effectué uniquement depuis l'IDE Arduino sans ligne de commande ou script à activer manuellement.

La plupart des montages font appel à un Arduino ou à un programmateur dédié, cependant cette alternative peut être intéressante pour éviter d'investir dans plus de matériel. Les tutoriels font par ailleurs appel à des étapes manuelles lors de la compilation ou du flash.

Sommaire

Configuration du Raspberry Pi

Installer Avrdude & Wiring Pi

Avrdude est le logiciel qui gère la configuration des microcontrôleurs et l'envoi du code compilé dans leur mémoire. WiringPi est une librairie et un utilitaire pour configurer/consulter l'état des broches d'un Raspberry Pi.

$ apt install avrdude wiringpi

Activer l'interface SPI (Serial Peripheral Interface)

Dans une console, entrez la commande sudo raspi-config, dans l'interface qui s'ouvre allez dans Advanced Options puis activez Enable SPI device.

Vous pouvez aussi modifier le fichier /boot/config.txt en vérifiant que la ligne suivante est bien présente :

dtparam=spi=on

Le redémarrage n'est pas forcément nécessaire, pour charger le module noyau manuellement et vérifier son chargement, faites :

# Chargement
$ sudo modprobe spidev

# Les modules suivant devraient apparaître...
$ lsmod | grep spi_
spi_bcm2708
spi_bcm2835

Les périphériques suivants doivent être disponibles :

/dev/spidev0.0
/dev/spidev0.1

Branchement du microcontrôleur

On utilisera les pins de l'interface spidev0.0 du Raspberry, quelques pins d'alimentation proches ainsi qu'un pin de reset pour l'ATtiny.

La table de description des pins d'un Raspberry Pi est donnée ci-dessous mais une version interactive plus complète est disponible à cette adresse : https://pinout.xyz/.

Table des noms, modes, statuts des pins des Raspberry Pi. Source : https://pinout.xyz/.

Idem pour l'ATtiny85 qui nous intéresse ici :

Brochage du microcontrôleur AVR ATtiny85 de chez Atmel.

Voici les connexions à réaliser. (Quelques alternatives sont données pour plus de flexibilité.) :

Directives de flash

La programmation se fait via avrdude. Voici un script permettant d'automatiser tout cela avec quelques directives.

Contenu à placer dans ~/attiny_spi/Makefile :

AVRDUDEMCU=t85
AVRDUDE=/usr/bin/avrdude
HEXFILE="attiny.ino.hex"

reset:
        sudo gpio -g mode 26 out
        sudo gpio -g write 26 0

install: reset
        sudo $(AVRDUDE) -p $(AVRDUDEMCU) -P /dev/spidev0.0 -c linuxspi -b 10000 -U flash:w:$(HEXFILE)
        sudo gpio -g write 26 1

noreset: all
        sudo $(AVRDUDE) -p $(AVRDUDEMCU) -P /dev/spidev0.0 -c linuxspi -b 10000 -U flash:w:$(HEXFILE)

fuses8mhz: reset
        @#hfuse: Divide clock by 8 internally; [CKDIV8=0] disabled
        @#Brown-out Detector trigger level disabled
        @#Serial program downloading (SPI) enabled; [SPIEN=0]
        @#Self Programming enable; [SELFPRGEN=0]
        @#Startup time powerdown/reset: +4ms
        @#Preserve EEPROM memory
        sudo $(AVRDUDE) -p $(AVRDUDEMCU) -P /dev/spidev0.0 -c linuxspi -b 10000 -v -e -U lfuse:w:0xe2:m -U hfuse:w:0xd7:m -U efuse:w:0xff:m
        sudo gpio -g write 26 1

fuse16mhz: reset
        sudo $(AVRDUDE) -p $(AVRDUDEMCU) -P /dev/spidev0.0 -c linuxspi -b 10000 -v -e -U lfuse:w:0xf1:m -U hfuse:w:0xd7:m -U efuse:w:0xff:m
        sudo gpio -g write 26 1

Paramètres d'avrdude :

microcontrôleur                             -p t85
programmeur/plateforme de programmation     -c linuxspi (ou arduino, etc.)
port de programmation                       -P /dev/spidev0.0
vitesse de transfert                        -b 14400 sinon 10000 (19200 semble trop rapide)

Le GPIO26 est utilisé dans les directives. Gérer ce GPIO est nécessaire car la broche RESET de l'ATtiny doit être maintenue à l'état bas durant l'envoi du code.

La programmation des fusibles se fait à l'aide du site http://www.engbedded.com/fusecalc. Vous pouvez aussi simplement recopier la commande donnée par l'IDE Arduino dans sa console lors de la procédure de flash/initialisation du contrôleur.

Configuration de l'IDE Arduino

Script d'envoi du sketch compilé sur le Raspberry Pi

Nous allons utiliser un script bash qui se connectera au Raspberry Pi pour envoyer et flasher le sketch compilé.

La connexion se fait en SSH ; or la console de l'IDE n'est pas interactive, c.-à-d. que vous ne pourrez pas saisir votre mot de passe (ce qui ferait d'ailleurs perdre beaucoup de temps).

Il faut donc configurer une clé SSH SANS mot de passe. Il s'agit là d'une exception de sécurité. Ne faites jamais cela pour configurer la connexion à un serveur qui abriterait des données importantes... (Voir autre article du site : Utiliser correctement un cluster de calcul).

• Générer et envoyer une clé sans mot de passe (appuyer sur entrée quand on vous en demande un) :

$ ssh-keygen -f ~/.ssh/id_dsa_rpiB+
$ ssh-copy-id -i ~/.ssh/id_dsa_rpiB+ <username>@<hostname>

• Créer le script bash (~/flash_rpi.sh) :

#!/bin/bash
echo "Install '$1'..."
scp -i ~/.ssh/id_dsa_rpiB+ "$1" pi@10.42.0.47:/home/pi/attiny_spi/attiny.ino.hex
ssh -i ~/.ssh/id_dsa_rpiB+ pi@10.42.0.47 "cd /home/pi/attiny_spi && make install"

Note : 10.42.0.47 est l'adresse IP de votre Raspberry Pi sur votre réseau local.

Ajouter une procédure de flash

Imaginons que vous utilisiez le projet ATtinyCore de SpenceKonde en tant que "système d'exploitation" de votre microcontrôleur.

L'installation est détaillée ici : Github - ATTinyCore Installation. Il s'agit essentiellement d'ajouter le lien http://drazzy.com/package_drazzy.com_index.json dans le gestionnaire de cartes de l'IDE.

Une fois installé le paquet décompressé se trouve dans le dossier suivant: ~/.arduino15/packages/ATTinyCore/hardware/avr/1.5.2/ Trois fichiers essentiels sont utilisés par le logiciel pour supporter les puces compatibles avec ATtinyCore :

• platform.txt : définitions de l'architecture CPU utilisée (compilateur, paramètres de processus de construction, outils utilisés pour le téléchargement, etc.)

• programmers.txt : définitions pour les programmeurs externes

• boards.txt : spécifie quel logiciel de programmation utiliser pour chaque puce supportée; contient des définitions pour les boards

Les fichiers platform.local.txt, boards.local.txt, s'ils sont présents, servent à écraser les paramètres spécifiés dans platform.txt et boards.txt (programmers.txt n'est a priori pas concerné). Ils sont censés être préservés en cas de mise à jour.

La documentation complète des divers fichiers est ici : https://arduino.github.io/arduino-cli/0.21/platform-specification/

Ainsi voici les 3 fichiers à créer/modifier :

• platform.local.txt

# Définition de flash_rpi en tant qu'alternative à avrdude
tools.flash_rpi.path=/home/my_name/
tools.flash_rpi.cmd.path={path}/flash_rpi.sh
tools.flash_rpi.config.path=

# Cette commande est utilisée lorsqu'on utilise un bootloader avec l'ATtiny
tools.flash_rpi.upload.params.verbose=
tools.flash_rpi.upload.params.quiet=
tools.flash_rpi.upload.pattern="{cmd.path}" "{build.path}/{build.project_name}.hex" {upload.verbose}

# Cette commande est utilisée quand on n'utilise pas de bootloader (programmation SPI uniquement)
tools.flash_rpi.program.params.verbose=
tools.flash_rpi.program.pattern="{cmd.path}" "{build.path}/{build.project_name}.hex" {upload.verbose}

• programmers.txt

raspberrypi.name=Raspberry Pi as ISP
raspberrypi.communication=
raspberrypi.protocol=
raspberrypi.program.protocol=
raspberrypi.program.tool=flash_rpi
raspberrypi.program.extra_params=

• boards.local.txt

# changement de l'outil d'upload d'avrdude à flash_rpi pour la carte :
# attinyx5.name=ATtiny25/45/85 (No bootloader)
attinyx5.upload.tool=flash_rpi

Utilisation

Un nouveau programmateur est apparu dans la liste proposée :

Le flash se fait maintenant simplement en cliquant sur le bouton "Téléverser" de l'IDE :