Programmation PIC sur Linux et Raspberry Pi

(sans utiliser MPLAB® X IDE)


programmateurs PIC


Des fois j'aime bien programmer les microcontrolleurs PIC® à l'ancienne, c'est à dire en assembleur. Étant utilisateur de Linux, la difficulté venait généralement de l'absence de certains logiciels. Aujourd'hui les choses ont bougé avec notamment MPLAB X, l'IDE officiel qui est maintenant multi-plateforme. Néammoins, ce dernier est devenu monstrueusement lourd et Microchip® délaisse le language assembleur.
Sachant que le codage se fait maintenant en language C, cet article va donc volontairement à contre-courant en présentant une approche alternative qui limite l'usage des outils officiels.

Cette page, qui n'est pas exhaustive, présente comment écrire du code assembleur, faire l'assemblage (qui n'est pas une compilation) et enfin programmer la mémoire flash du microcontrôleur. Certains outils ou logiciels ne sont plus mis à jour et/ou d'autres nécéssitent un port série... Voyons quelles sont les solutions disponibles en 2022.

La bonne nouvelle c'est que la plupart des logiciels décrits sont parfaitement opérationnels sur un Raspberry Pi ; ce qui nous permettra de déployer une toolchain complète sur cette plateforme ! Aussi, les explications de cette page pourront être transposées sur Windows, moyennant quelques adaptations.

Une archive contenant les fichiers utilisés est disponible ici. Pensez à vérifier auprès des projets présentés si des mises à jour sont disponibles.


1. L'assemblage


L'idée de départ était d'utiliser en stand-alone l'assembleur officiel fourni avec MPLAB(X) : MPASM. Malheureusement Microchip® l'a abandonné et il n'est plus fourni depuis la version 5.40 de MPLAB X.

1.1 GPASM

GPASM, qui fait partie de Gputils est un assembleur pour PIC® compatible MPASM et diffusé sous licence libre. Gputils est généralement disponible dans les systèmes de paquets des distributions Linux mais la version n'est pas forcément à jour. Chez Debian et Ubuntu, la version 1.4.0 disponible est trop ancienne pour prendre en charge les modèles récents, notamment parmi ceux de la gamme Enhanced mid-range.
Cet article a été rédigé avec la version 1.5.2 de Gputils sortie début 2022. Télécharger l'archive de la dernière version ici et ensuite décompresser l'archive puis se rendre dans le dossier et exécuter les commandes suivantes :
./configure
make
sudo make install

On teste que ça fonctionne en assemblant notre premier programme :
gpasm prog_de_test.asm

Si tout s'est bien passé, un fichier prog_de_test.hex est généré, ainsi qu'un fichier prog_de_test.lst pour les plus curieux. Voila !

Remarques :
GPASM ne supporte que les microcontrôlleurs 8 bit (familles 10/12/16/18F). Le rythme de développement est devenu très lent et semble maintenu plus que par une seule personne.
Pour les µC qui ne seraient pas supportés, il faudra passer par le compilateur XC8 (XC16 pour les 16 bit, XC32 pour les 32 bit) disponibles gratuitement sur le site de Microchip®. Outre le language C, ils permettent aussi de programmer en assembleur via la commande pic-as (xc16-as pour les 16 bit, etc..).


1.2 PIC-AS

Il s'agit du nouveau et seul assembleur officiel maintenu par Microchip®. Disponible sur PC uniquement. On l'obtient en installant le compilateur C "XCn" (n à remplacer par 8/16/32 selon l'architecture du MCU utilisé).
Attention : les fichiers sources de MPASM ou GPASM ne peuvent pas être utilisés tels quels. Il faudra apporter nombre de modifications. Voir la notice de l'assembleur.

On peut l'utiliser sans MPLABX via la commande
/opt/microchip/xc8/v2.40/pic-as/bin/pic-as -mcpu=16F18855 prog_de_test.S

Le chemin d'accès à l'éxécutable pic-as est à adapter selon la version du compilateur XC et configuration. Les fichiers sources doivent avoir l'extension .S et non plus .asm.
l'option -Wa,-a permet de générer le fichier .lst
l'option -msummary=+psect affiche dans la console la carte mémoire PSECT


2. La programmation flash


2.1 Avec un PICkit 2 ou PICkit 3

2.1.1 pk2cmd (PICkit-)

Le projet PICkitminus (ou PICkit-) est intéréssant. Il s'agit d'un fork gratuit et open source des outils de programmation pour le PICkit2 (interface et ligne de commande) fournis à l'époque par Microchip sous licence libre et mis à jour afin d'ajouter le support du PICkit3 ainsi que des microcontrôlleurs plus récents. Donc malgré le fait que le PICkit2 soit abandonné depuis une douzaine d'années, on va quand-même pouvoir l'utiliser ! Aussi, la programmation est plus rapide qu'avec MplabX IPE (ipecmd). Bref, que des avantages.

L'éxécutable en ligne de commande s'appelle pk2cmd. Il autodétecte tout seul le modèle de PICkit et s'utilise de la même manière que la version originale. Les fichiers source à compiler ainsi que les binaires prêts à utiliser (au format AppImage) sont disponible sur la page d'accueil du projet. Le seul pré-requis avant de compiler c'est que le paquet libusb-dev soit installé.
Télécharger le code source (PK2CMD_SourceVxxx.zip), décompresser l'archive, se rendre dans le dossier /PK2CMD_SourceVxxx/pk2cmd/pk2cmd/ et saisir les commandes suivantes :
make linux
sudo make install
Tester si tout va bien avec la commande pk2cmd -?V
S'il est fait mention que le fichier "Device File" n'a pas été trouvé, il faut le copier manuellement dans le dossier /usr/local/bin/
sudo cp -p PK2DeviceFile.dat /usr/local/bin

Le fichier PK2DeviceFile.dat contient les scripts de programmation pour chaque modèle de PIC®. Vérifiez de temps en temps s'il n'a pas été mis à jour afin d'ajouter le support de nouveaux modèles ou apporter des corrections.

Il faudra sans doute aussi ajouter des règles udev afin de pouvoir accéder au PICkit sans être root : copier le fichier 60-pickit.rules (fourni dans le fichier zip et disponible ici) dans le dossier /etc/udev/rules.d (et ensuite redémarrer) :
sudo cp 60-pickit.rules /etc/udev/rules.d

La programmation se fait :
pk2cmd -P PIC16F18855 -W -M -F"prog_de_test.hex" -R
-P pour le modèle de PIC. Liste des modèles supportés. (sans argument on est en autodétection du modèle de PIC®. A tester avec prudence).
-W sous-entend que le PIC est alimenté par la cible. L'enlever ou remplacer par -Axx pour une alimentation via le PICkit.
-R permet de relacher le reset à la fin de la programmation

Et si tout se passe bien :

PICkit Program Report
9-5-2022, 20:29:32
Device Type: PIC16F18855
Program Succeeded.
Operation Succeeded


Remarque : ne pas brancher le programmateur sur un hub USB, sauf si ce dernier est auto-alimenté.

IMPORTANT : si le PICkit a précédemment été utilisé avec MPLAB, ce dernier a téléversé dans le programmateur un firmware spécifique qui n'est pas compatible avec les logiciels de programmation autonomes. Dans ce cas il faudra d'abord flasher le PICkit avec le micrologiciel approprié (disponible dans l'archive téléchargée). Pour le PICkit2 il est possible de le faire directement via pk2cmd :
pk2cmd -D PK2V023200.hex
Pour le PICkit3 les choses se compliquent puisqu'il faudra obligatoirement passer par le logiciel avec interface graphique disponible uniquement pour Windows...


2.1.2 Remarques sur les clones

Disponibles à prix très abordable sur de célèbres sites marchands, il faut némamoins garder à l'esprit que ce sont des clones avec ce que ça peut impliquer sur la qualité de fabrication. Dans l'hypothèse où vous vous passez complètement de MPLABX pour n'utiliser que PICkit-, je recommande de se procurer un clone de PICkit2 : sa conception plus simple le rend naturellement plus robuste et il est moins cher.

Concernant les clones de PICkit3, en démontant mes exemplaires j'ai découvert que les PolySwitch (identifiés avec les labels PTC2 et PTC3) qui protègent les broches PGD et PGC avaient été remplacés par des résistances de 0 ohm (straps)...
Parce qu'il s'agit d'un élément qui concerne la protection du programateur, je les ai remplacés par le composant d'origine dont la référence est MICROSMD005F.



2.2 Avec un Arduino

Le projet a-p-prog permet de flasher en mode basse tension un certain nombre de PIC® récents de la gamme 16/18F à l'aide d'une simple carte Arduino. Veillez à ce que dans votre code la configuration soit CONFIG LVP = ON ou __CONFIG ... _LVP_ON pour éviter de désactiver par accident le mode basse tension lors d'une programmation classique.

Récupérer le sketch pp.ino dans le sous-dossier fw et le charger sur une carte Arduino utilisant un ATmega328P, comme par exemple la carte Arduino UNO. Une fois la carte programmée, vous pouvez fermer l'IDE Arduino ; il n'y en aura plus besoin ultérieurement.

Dans le sous-dossier sw se trouve le logiciel de programmation proprement dit que nous allons compiler
gcc -Wall pp3.c -o pp3
Les 2 fichiers à conserver sont pp3 et pp3_devices.dat. Les copier dans le dossier /usr/local/bin nous permettra d'y avoir accès partout.

Câbler selon les indications de la page du projet

Arduino PIC
GND GND
+5V VDD
A3 MCLR
A1 PGD
A0 PGC


Et enfin, on flashe le PIC® comme ceci :
pp3 -c /dev/ttyACM0 -s 1700 -t 16f18855 prog_de_test.hex
où /dev/ttyACM0 représente le port de la carte Arduino. A adapter selon votre configuration.

Remarque : vous devez faire partie des groupes tty et dialout pour pouvoir utiliser la carte Arduino.
Remarque : le programme pp3 fonctionne plutôt bien sur un PC ; en revanche sur Raspberry Pi le programme finit trop souvent en erreur de segmentation. Le problème semble connu, donc à suivre si son développeur va mettre à jour.

EDIT : le repo github a été archivé fin 2022 ; il n'y aura sans doute plus d'évolution. Il existe d'autres projets assez similaires qui varient principalement en ce qui concerne les modèles supportés. Au vu des clones de PICkit disponibles à bas coût, je n'ai pas poursuivi cette voie.



2.3 Avec un programmateur série (OBSOLÈTE !)

Il faut un port série (RS-232). Le connecteur externe a disparu de nos ordinateurs depuis un bon moment mais il n'est pas rare que la carte mère dispose d'un connecteur interne (5x2 broches) et identifié avec le label COM1. Il suffit alors de se procurer un adaptateur 10-pin IDC vers prise DB-9 male (photo), ou le fabriquer.


2.3.1 Picprog

Le logiciel de programmation Picprog (open source) version 1.9.1 est disponible dans les dépôts logiciels. Malhereusement il n'est plus mis à jour depuis 2010 environ, ce qui exclut la possibilité de programmer les modèles récents. Voir ici les modèles supportés. Les modèles 16F84(A), 16F87x(A), 16F88x, 18F252, 18F2520 et bien d'autres sont supportés.

La programmation se fait comme ceci :
picprog --erase --burn --input prog_de_test.hex --pic /dev/ttyS0
où /dev/ttyS0 représente le port série. A adapter selon votre config.

Remarque: Moyennant une adaptation des niveaux de tension, peut-être qu'un fonctionnement sur Raspberry Pi serait presque envisageable, puisqu'il semble possible sous certaines configurations d'obtenir, en plus de Tx et Rx, les signaux RTS et CTS (mais pas DTR...).


2.3.2 PICPgm

Un autre logiciel disponible ici (freeware) qui supporte, entres autres, les programmateurs JDM. Dans l'archive téléchargée se trouve un script shell pour l'installation. Un build pour architecture armhf (Raspberry Pi) est également de la partie. Par-contre la dernière version date de juin 2018 (v2.9.3.1). Le developpement semble être à l'arrêt depuis cette date.
Pour programmer :
picpgm -port /dev/ttyS0 -p prog_de_test.hex

2.3.3 Pickle

Une alternative intéréssante ET open source. Un peu plus complexe que les précédents dans le sens qu'il faut compiler soi-même et éditer un fichier de configuration mais en contrepartie il propose plus de fonctionnalités. Les modèles 16F1827 et 16F18855 (Enhanced mid-range) ont directement été reconnus !
Installation :

make linux
sudo make linux-install


Pour la configuration, il faut créer un fichier nommé .pickle à la racine du dossier personnel. Le contenu varie selon la configuration et le programmateur utilisé. Voir la documentation en ligne pour les détails. Voila ma configuration pour le programmateur Velleman K8076 :

DEVICE=TTY
IFACE=/dev/ttyS0
SLEEP=1
BITRULES=0x0010


Le nom de l'éxécutable dépend de la famille de PIC et plus précisément la largeur des instructions : p14 pour la plupart des 16F, p16 pour les 18F, n14 pour les 16F récents, etc. Il suffit de saisir p12 ou p14 ou n14 ou p16 ou n16 ou p24 ou p32 suivi de select pour afficher la liste des modèles supportés par l'éxécutable. Pour programmer le 16F18855, qui est concerné par le nouvel algorithme de programmation, il faudra utiliser la commande n14 (le processus est très rapide) :
n14 program prog_de_test.hex

Pickle permet aussi de programmer sur Raspberry Pi en LVP via les broches GPIO. Je n'ai pas encore testé. A suivre !


3. L'IDE : Geany


Maintenant que l'on sait assembler et flasher (en plus d'écrire du code !) l'objectif est de pouvoir faire tout ça depuis une même interface. Geany est un éditeur de texte qui possède des fonctions basiques d'un IDE. Il est déjà installé par défaut avec Raspberry Pi OS. Nous allons le personnaliser afin de le rendre opérationnel pour la programmation des PIC®.


3.1 Thème

J'ai crée un thème qui reprend les codes couleur de MPLAB 8. Libre à chacun de le personnaliser à ses goûts ou d'utiliser un thème proposé par défaut. Le fichier MPLAB.conf est à copier dans le dossier /home/<login>/.config/geany/colorschemes/ et ensuite le choisir le thème dans Affichage -> changer le jeu de couleurs... et sélectionner MPLAB.


3.2 Coloration syntaxique

Ceci va permettre à Geany de reconnaitre les directives, mots-clés et registres pour ensuite les colorer selon les couleurs définies par le thème. Mon fichier est disponible ici. Il n'est pas exhausif, vu le nombre de registres possibles. Selon votre modèle de PIC® il faudra compléter les champs "instructions", "registers" et "directives". Il faut impérativement saisir les noms en caractères minuscules, sur une seule ligne et séparés par un espace. Le fichier filetypes.asm est à copier dans les dossier /home/<login>/.config/geany/filedefs/




3.3 Intégration des commandes

On va assigner des commandes à des boutons de l'interface de Geany pour l'assemblage et la programmation flash. Dans le menu Construire choisir "Définir les commandes de construction".
La première ligne correspond au bouton bleu jaune et rouge. On va y définir la commande qui lance l'assemblage :
gpasm %f ; cat %e.lst | grep Program


Le deuxième ligne correspond au bouton avec la brique. On va l'utiliser pour flasher le PIC :
pk2cmd -P PIC16F18855 -W -M -F"%e.hex" -R
A noter que le modèle du PIC® utilisé est défini dans la commande. C'est la méthode fiable, mais pas pratique, car cela devra être modifié dès qu'on travaille sur un autre modèle. Sinon on peut essayer l'autodétection (légèrement plus lent) :
pk2cmd -P -W -M -F"%e.hex" -R




3.4 Utilisation

Il ne reste plus qu'a écrire le code. En cas d'erreur d'assemblage, cela s'affichera dans la partie basse de la fenêtre.


Ne pas tenir compte de la mention "compilation terminée avec succès", il s'agit de Geany et non GPASM qui la génère. Si l'assemblage a réussi, le message ressemble à l'exemple ci-dessous. Le fait d'avoir rajouté une commande cat juste après gpasm nous permet d'afficher la quantité de mémoire flash que notre programme utilise. L'info est récupérée depuis le fichier de listing (.lst).



3.5 Intégration shell

Les fichiers asm étant de simples fichiers texte (text/plain), si l'on assigne l'ouvrture d'un tel fichier à l'éditeur Geany, tous les fichiers textes s'ouvriront alors avec Geany ; ce qui n'est pas forcément bienvenu si l'on souhaite continuer à utiliser un autre éditeur pour les fichiers texte hors assembleur.

Créer un fichier asm.xml dans le dossier /usr/share/mime/packages/ avec le contenu suivant :


Mettre à jour la base MIME avec la commande
sudo update-mime-database /usr/share/mime


4. Compilateur C


Bon allez, vu que j'ai parlé de l'installation du compilateur XC pour avoir accès à l'assembleur pic-as, on peut évoquer l'usage du compilateur C. Bien évidemment il est possible de l'utiliser de manière autonome :
/opt/microchip/xc8/v2.40/pic/bin/xc8 --chip=16F18855 prog_de_test.c

Les fichiers sources doivent avoir l'extension ".c". Le chemin d'accès à l'éxécutable xc8 (ou xc16 ou xc32) est à adapter selon la version du compilateur XC et configuration. Pour éviter d'avoir à mettre le chemin complet on peut ajouter dans le fichier .bashrc la ligne suivante :
export PATH=$PATH:/opt/microchip/xc8/v2.40/pic/bin/

La commande devient tout simplement :
xc8 --chip=16F18855 fichier_source.c

Et tout comme avec les fichiers .asm, il est possible d'intégrer cette commande dans Geany ou tout autre éditeur qui accepte les commandes externes et la syntaxe C. Enjoy !