Retrouvez cet article dans : Linux Magazine 90

Le développement d’applications en C sur les microcontrôleurs PIC de Microchip est resté longtemps réservé à des compilateurs commerciaux. Il est possible aujourd’hui d’écrire du code sous licence GPL à l’aide d’une suite d’outils que nous allons vous détailler dans cet article.

SDCC, le compilateur open source sera la charnière de cet article, mais, pas seulement, puisque nous aborderons aussi l’utilisation de la suite GPUTILS (assembleur et linker) et du bootloader Tiny Bootloader de Claudiu Chiculita. Un prochain article abordera l’intégration de ces outils dans l’éditeur de texte Scite qui deviendra pour l’occasion un mini environnement de développement pour les PIC. L’objectif est de développer au travers d’une série d’articles dont celui-ci est le premier, une bibliothèque d’outils permettant de réaliser des applications courantes sur les PIC.
Ce premier article décrit la mise en œuvre de ces outils pour les PIC16 (série 18FXXX) et les PIC14 (série 16FXXX). Un exemple d’utilisation avec le 16F88 permettra de mettre en œuvre ce microcontrôleur, remplaçant surpuissant du célèbre 16F84.

GPUTILS GNU PIC Utilities

GPUtils est une collection d’outils pour les PIC qui est constituée d’un assembleur, d’un linker et d’un simulateur. La lecture de l’article de Denis Bodor de Linux Magazine n°73 de juin 2005 vous en apprendra un peu plus sur l’utilisation de ces outils en assembleur. Le but de cet article étant la programmation en C, nous nous contenterons d’installer GPUtils pour permettre l’assemblage et l’édition de liens des fichiers assembleur générés par SDCC, ainsi que pour configurer et installer le bootloader.
GPUtils a été installé sur une MANDRIVA 2006 avec les paquets RPM de la version 0.13.0. Une fois GPUtils installé, en mode console, tapez gpasm -v. Vous devez obtenir l’écran suivant :

        [mandon@(none) Desktop]$ gpasm -v
gpasm-0.13.0 beta

SDCC : Small Device C Compiler

SDCC est un compilateur C ANSI libre et multi-cible. Il permet non seulement l’écriture de programmes pour les PIC de Microchip, mais également pour une foule de microprocesseurs plus exotiques les uns que les autres. Outre la célèbre série des 8051 d’INTEL, il permet de développer sur Z80, MOTOROLA 68HC08 et DALLAS. SDCC a été écrit par Sandeep Dutta sous licence GPL. Le code a été transféré sur SourceForge en 1999 permettant à tous les développeurs et utilisateurs d’accéder au code source. SDCC est en perpétuel développement et on ne peut douter d’une constante amélioration de son efficacité. Il est à noter que le développement de SDCC pour AVR et GBZ80 est abandonné.
Raphaël NEIDER est responsable du développement de SDCC sur PIC, outre la correction des bugs et l’optimisation du portage sur PIC16, il a réalisé une partie du portage sur PIC14 (série 16FXXX). Nous avons écrit quelques applications sur 16F88 qui s’avèrent stables et efficaces.
L’installation de SDCC a été réalisée sur MANDRIVA 2006 sans problème particulier à partir du paquetage RPM de la version 2.6.0. Des paquets DEBIAN sont également disponibles, à défaut pour les autres distributions, un fichier TAR compressé est utilisable. À noter que nous avons également utilisé ce compilateur sous CYGWIN sans problème.
Une fois SDCC installé, en ouvrant une console terminal, tapez SDCC. Vous obtiendrez un écran d’aide dont la première ligne vous indiquera la version que vous avez installée.

[mandon@(none) Desktop]$ sdcc
SDCC : mcs51/gbz80/z80/avr/ds390/pic16/pic14/TININative/xa51/ds400/hc08 2.6.0 #4 309 (Sep 29 2006) (UNIX)
Usage : sdcc [options] filename

Nous allons d’ores et déjà tester son fonctionnement. Pour cela, ouvrez un éditeur de texte et recopiez le source en C ci-dessous :

#define __18F458
#include <pic18F458.h>
#pragma stack 0x200 100
unsigned int i;
void main(void) {
TRISB = 0;
while(1) 	{
		PORTBbits.RB7=1;
		for (i=1;i<10000;i++);
		PORTBbits.RB7=0;
		for (i=1;i<10000;i++);
		}
}

Après avoir créé un dossier projet, enregistrez le fichier test.c, passez dans la fenêtre terminal dans ce dossier. Tapez sdcc -mpic16 -p18F458 test.c. Vous devez obtenir le résultat suivant :

warning: processor mismatch in "/usr/bin/../share/sdcc/lib/pic16/crt0i.o"
message: using default linker script "/usr/share/gputils/lkr/18f458.lkr"
warning: processor mismatch in "pic18f458.o"

Malgré ces messages d’avertissement, SDCC a compilé, assemblé et linké notre programme. Si l’on analyse le dossier, on va trouver test.asm, test.cod, test.o, test.lst et test.hex. C’est ce dernier fichier qui pourra être programmé dans le PIC 18F458 pour vérifier si notre LED clignote bien.
Il est important de noter que ce programme de test ne nous est utile que pour vérifier le fonctionnement de SDCC. En effet, les habitués des PIC verront tout de suite qu’il manque la définition des octets de configuration (horloge, watchdog, etc.). Nous verrons dans les paragraphes qui suivent que l’utilisation d’un bootloader évite l’obligation de définir cette configuration dans nos programmes.
Ce premier exemple simple nous a permis de définir l’architecture d’un programme avec SDCC. On voit que les directives #define de début permettent à sdcc -mpic16 -p18F458 test.c ent de définir le type du processeur utilisé, dans notre cas un 18F458. On inclut ensuite la librairie correspondante. La ligne suivante #pragma est optionnelle et permet de définir la taille de la pile. Par défaut, SDCC affectera une taille de pile standard pour l’application si celle-ci n’est pas définie par une directive #pragma stack. La suite du programme est traditionnelle.
Un certain nombre de structures sont définies dans le fichier 18f458.H. Sa lecture vous permettra de mieux connaître la façon dont SDCC identifie les différents registres du PIC. Ce fichier est dans :

        /usr/share/sdcc/include/pic16

De la même façon, si vous avez décidé de travailler avec des PIC14, vous pourrez analyser les fichiers d’en-tête dans le dossier :

        /usr/share/sdcc/include/pic

Nous allons maintenant étudier d’un peu plus près ce qui se passe lors de la compilation. Pour cela, nous allons ajouter à la ligne de commande l’option -V (verbose) :

        sdcc -V -mpic16 -p18F458 test.c

Le résultat est le suivant :

[mandon@(none) programme 1]$ sdcc -V -mpic16 -p18F458 test.c
+ "/usr/bin/sdcpp" -nostdinc -Wall -std=c99 -Dpic18f458
-D__18f458 -DSTACK_MODEL_SMALL -obj-ext=.o
-DSDCC_MODEL_SMALL -DSDCC=260 -DSDCC_pic16 -D__pic16 -I"/usr/bin/../share/sdcc/include/pic16"
-I"/usr/share/sdcc/include/pic16"  "test.c"
+ "/usr/bin/gpasm" -DSDCC_MODEL_SMALL
-Dpic18f458 -D__18F458 -DSTACK_MODEL_SMALL
-c "test.asm" -o "test.o"
+ "/usr/bin/gplink" -I"/usr/bin/../share/sdcc/lib/pic16"
-I"/usr/share/sdcc/lib/pic16"   -o test test.o  crt0i.o pic18f458.lib libsdcc.lib
warning: processor mismatch in
    "/usr/bin/../share/sdcc/lib/pic16/crt0i.o"
message: using default linker script
   "/usr/share/gputils/lkr/18f458.lkr"
warning: processor mismatch in "pic18f458.o"

On voit en première ligne que SDCC est appelé et on retrouve le chemin des fichiers inclus. Le résultat est un fichier assembleur test.asm. Gpasm est ensuite appelé et transforme le fichier test.asm en test.o, le fichier objet. Reste ensuite à linker l’ensemble. Cette opération est réalisée par Gplink qui inclut les bibliothèques pour PIC18 situées dans /usr/share/sdcc/lib/pic16/.
L’ensemble de cette opération nous fournit un fichier test.hex directement utilisable dans notre PIC.

Transférer le programme dans le microcontrôleur

Il reste maintenant à transférer ce programme test.hex dans le PIC. Pour cela, deux techniques peuvent être mises en œuvre. La première consiste à utiliser un programmateur de PIC du type JDM par exemple associée à PICPROG et, après avoir placé votre PIC sur son support, à le programmer. Cette technique présente plusieurs inconvénients : d’abord, celui de devoir déplacer le circuit de la carte cible vers le programmateur avec les risques que cela comporte. Le deuxième inconvénient est celui de la perte de temps liée à cette opération. Il est plus utile de consacrer son temps au développement d’une application plutôt qu’aux différentes manipulations !!

Le programmeur JDM est un classique sur genre. On retrouve le schéma original sur http://www.jdm.homepage.dk/newpic.htm. De nombreux autres circuits reprennent une connectique identique et se disent donc compatible JDM.

Nous avons choisi d’installer un bootloader dans le microcontrôleur pour transférer notre nouveau programme. Un bootloader est un programme résidant dans le processeur en haut de mémoire qui assure la communication avec le PC à chaque démarrage. Le bootloader reçoit le programme de l’utilisateur du PC et le transfère dans la mémoire du microcontrôleur. A la fin de cette opération, il lance l’exécution de ce programme. Les bootloaders sont utilisables sur tous les microcontrôleurs utilisant de la mémoire flash. Pour Microchip, il s’agit de toutes les références du type XXFXXX.
Le bootloader est constitué :

• d’un programme à installer dans le microcontrôleur ;
• d’un programme à installer dans le PC assurant la communication.

Pour peu que la carte cible soit équipée d’un connecteur de communication, il ne sera alors plus nécessaire de déplacer le PIC à chaque changement de programme, mais juste de lancer le downloader pour transférer le programme dans le PIC. Que de temps gagné pour le développement !!

Tiny Downloader

Nous allons maintenant choisir le bootloader destiné à notre microcontrôleur. Il existe de nombreux programmes assurant cette fonction. Leurs caractéristiques sont relativement proches. Toutefois, on peut apprécier la qualité d’un bootloader selon les critères suivants :

• la taille du code résidant dans le PIC ;
• la disponibilité du programme PC dans différents environnements.

Le bootloader que nous utilisons, Tiny Bootloader, est probablement celui qui est le moins " gourmand " en taille mémoire. Il occupe environ 100 mots mémoire dans le PIC et est compatible avec la plupart des références de Microchip. Malheureusement, le downloader (programme PC) n’existait que sous Windows. Pour pallier cet inconvénient majeur pour nous autres utilisateurs LINUX, nous avons réécrit l’application sous Python 2.4 avec le composant PySerial.
Dans un premier temps, nous allons voir comment installer le bootloader dans le microcontrôleur. Pour cela, téléchargez le fichier TinyBld191.zip sur le site de Claudiu Chiculita :

        http://www.etc.ugal.ro/cchiculita/software/picbootloader.htm

Après avoir décompressé et enregistré le programme dans votre dossier personnel, vous obtiendrez l’arborescence suivante :

tinybldWin.exe
info
picsource	16f
		18f
		1ds
		other
		test
		bankswitch.inc
		icdtypes.inc
		spbrgselect.inc
		Tinybld16_logic.wmf
		Tinybld18_logic.wmf

Le dossier info contient différentes informations sur le fonctionnement des bootloaders et de Tiny Bootloader en particulier. Le dossier picsource contient le source du bootloader pour différents modèles de PIC. Nous allons nous intéresser au 16f et 18f. Nous garderons les DSPIC pour un article futur !!
Dans le dossier 16f, nous trouvons deux types de fichiers, des fichiers HEX et des fichiers ASM. Les fichiers HEX sont des fichiers déjà assemblés pour un type de PIC donné à une vitesse donnée. En effet, notre bootloader est dépendant du type de processeur utilisé et de la vitesse de communication du downloader. Nous allons configurer un 16F88 à 19200 bauds avec son oscillateur interne à 8 Mhz pour nos tests.
Bien que ce fichier existe déjà au format hex sous le nom tinybld16F88_i8MHz __19200.HEX, nous allons voir comment modifier le bootloader pour l’adapter à notre cible. Pour cela, ouvrez le fichier tinybld16F88_i8MHz __19200.asm dans votre éditeur de texte préféré.

1:	radix DEC
2:	LIST      P=16F88, F=INHX8M	; change also: Configure->SelectDevice from Mplab
3:xtal 	EQU 8000000      ; you may also want to change: _HS_OSC _XT_OSC
4:baud 	EQU 19200	      ; standard TinyBld baud rates: 115200 or 19200
5:     ; The above 3 lines can be changed and buid a bootloader for the desired frequency (and PIC type)
6:
7:    ;******************************************************************
8:    ;Tiny Bootloader	16FxxxA series	Size=100words
9:    ;claudiu.chiculita@ugal.ro
10:   ;http://www.etc.ugal.ro/cchiculita/software/picbootloader.htm
11:   ;******************************************************************
12:
13:    #include "../icdpictypes.inc" ;takes care of: #include "p16fxxxA.inc",
				      ;max_flash, IdTypePIC
14:	#include "../spbrgselect.inc"
15:	#include "../bankswitch.inc"
16:	#define first_address max_flash-100 ; 100 word in size
17:
18:	;CP    CCPMX   DEBUG   WRT1 WRT0 CPD
	;LVP   BOREN   MCLRE   FOSC2   PWRTEN
	;WDTEN  FOSC1   FOSC0
19:	;1=off  0?     1=off   off=1  1  1    0=off  1=on
	;1=on     1      0=on     0=off    0      0
20:	__CONFIG    _CONFIG1, _INTRC_IO  & _CP_OFF
	& _CCP1_RB0 & _DEBUG_OFF & _WRT_PROTECT_OFF &
21:	_CPD_OFF & _LVP_OFF & _BODEN_ON & _MCLR_ON
	& _PWRTE_ON & _WDT_OFF
22:	__CONFIG    _CONFIG2, _IESO_OFF & _FCMEN_OFF

Les lignes 2,3,4 et 18 à 22 permettent de spécifier les différentes options du processeur que nous allons utiliser. Dans notre cas, le processeur est un 16F88. Cette spécification est à la ligne 2 :

LIST      P=16F88, F=INHX8M

La fréquence de l’oscillateur choisie est de 8 Mhz :

xtal EQU 8000000

et la vitesse de communication avec le downloader de 19200 bauds :

baud EQU 19200

Les bits de configuration sont ensuite définis. Notre application va fonctionner avec l’oscillateur interne du 16F88, sans watchdog et avec un reset externe. Cette spécification est visible à la ligne 20. Les différentes possibilités de configuration du 16F88 peuvent être trouvées dans la documentation Microchip du 16F88, leur illustration est définie par deux mots de configuration dans la mémoire flash _CONFIG1 et _CONFIG2. Les différentes options peuvent être analysées dans le fichier 16F88.inc. Ce fichier est dans le dossier /usr/share/gputils/header/.
Ce programme étant écrit pour MPLAB sous Windows, nous allons devoir adapter un peu le source assembleur pour permettre l’assemblage avec GPASM. Ceci est principalement du à la forme des directives de compilation qui est un peu différente dans ces deux environnements.
Tout d’abord, il va falloir modifier le fichier spbrgselect.inc situé dans le dossier picsource.
Les lignes 29 et 32 doivent être modifiées comme indiqué ci-dessous :

27:errpercent EQU AbsResult*100/baud
28:	if (errpercent > 4)
29:		ERROR "big error in baudrate:"
30:	endif
31:	if (errpercent >= 2)
32:		MESSG "baudrate not exact:"
33:	endif

Sauvegardez ensuite le fichier en conservant le nom d’origine.
Il s’agit maintenant d’adapter le fichier tinybld16F88_i8MHz __19200.asm. Il suffit, dans ce fichier, de déplacer la directive #define first_address flash-100 en colonne 0. Cette particularité est propre à GPASM.
Le source devra avoir la forme indiquée ci-dessous :

1:  radix DEC
2:  LIST  P=16F88, F=INHX8M   ; change also: Configure->SelectDevice from Mplab
3:xtal 	EQU 8000000     ; you may also want to change: _HS_OSC _XT_OSC
4:baud 	EQU 19200	     ; standard TinyBld baud rates: 115200 or 19200
5:	; The above 3 lines can be changed
	; and buid a bootloader for the desired
	;frequency (and PIC type)
6:
7:	;*****************************************************
8:	;Tiny Bootloader	16FxxxA series	Size=100words
9:	;claudiu.chiculita@ugal.ro
10:	;http://www.etc.ugal.ro/cchiculita/software/picbootloader.htm
11:	;*****************************************************
12:
13:	#include "../icdpictypes.inc" ;takes care of: #include
		           ;"p16fxxxA.inc",  max_flash, IdTypePIC
14:	#include "../spbrgselect.inc"
15:	#include "../bankswitch.inc"
16:#define first_address max_flash-100 ; 100 word in size
17:
18:	;CP    CCPMX   DEBUG   WRT1 WRT0 CPD
	; LVP   BOREN   MCLRE   FOSC2   PWRTEN
	;WDTEN  FOSC1   FOSC0
19:	;1=off  0?     1=off   off=1  1  1    0=off
	;1=on    1=on     1      0=on     0=off    0      0
20:	__CONFIG    _CONFIG1, _INTRC_IO
	& _CP_OFF & _CCP1_RB0 & _DEBUG_OFF
	& _WRT_PROTECT_OFF &
21:	_CPD_OFF & _LVP_OFF & _BODEN_ON & _MCLR_ON
	& _PWRTE_ON & _WDT_OFF
22:	__CONFIG    _CONFIG2, _IESO_OFF & _FCMEN_OFF

La modification est à effectuer à la ligne 16. Dans certains cas, cette directive a la forme :

 #define prima_adresa max_flash-100 ; 100 word in size

Nous n’avons plus maintenant qu’à assembler le programme avec GPASM. Pour cela, ouvrez une fenêtre console, allez dans le dossier 16f, puis tapez la ligne suivante :

gpasm tinybld16F88_i8MHz\ __19200.asm

gpasm a assemblé le programme et a créé le fichier tinybld16F88_i8MHz __19200.hex que vous pouvez maintenant transférer dans votre 16F88. Pour cela, utilisez votre programmateur favori, avec le programme picprog, par exemple, décrit dans l’article de Denis Bodor du numéro 73 de Linux Magazine.
Si votre programmateur est raccordé sur dev/ttyS0, en mode console, tapez :

 picprog --erase --burn --device=pic16f88 --input tinybld16F88_i8MHz\ __19200.hex --pic /dev/ttyS0

Le résultat sera le suivant :

Picprog version 1.8.3, Copyright ©
  2006 Jaakko Hyvatti <Jaakko.Hyvatti@iki.fi>
Picprog comes with ABSOLUTELY NO WARRANTY; for details
type `picprog --warranty’.  This is free software,
and you are welcome to redistribute it under certain conditions;
type `picprog --copying’ for details.
Device pic16f88, program memory: 4096, data memory: 256.
Erased and removed code protection.
Burning program memory, 102 locations,
burning data memory, 0 locations,
burning id words, 0 locations,
burning fuses, 2 locations,
done.

Fig. 1 : Le programmateur jdm avec le 16f88

Tiny Downloader

Nous en sommes au stade où la moitié seulement du travail est fait. Il s’agit maintenant d’installer le downloader sur votre machine. Le downloader que nous vous proposons a été écrit en Python avec l’extension PySerial qui permet l’utilisation des ports série sous Linux. Ce programme peut être téléchargé à l’adresse suivante : www.pictec.org.
L’interface TK a été utilisée, cette interface proposée en standard dans les différentes versions de Python lui assure une portabilité maximum. Seul le composant PySerial devra être installé. Ce dernier peut être téléchargé à l’adresse suivante :

http://pyserial.sourceforge.net.

Tiny Downloader reconnaît les ports série de votre machine, et ce, quel que soit l’OS que vous utilisez. La version que vous allez utiliser est la version 1.2. Elle est appelée à évoluer dans les prochains jours (semaines, mois... années !!) selon ma disponibilité et mes besoins...
Nous allons maintenant étudier la façon de raccorder notre 16F88 à notre PC et le câblage minimum pour faire quelques essais.

La platine d’essais

Pour faire nos essais, nous allons devoir disposer des éléments suivants :

• un PIC 16F88 ;
• une résistance de 470 ohms ;
• une LED ;
• une résistance de 10 kohms ;
• un condensateur chimique de 10 µF ;
• un poussoir ;
• une alimentation 5V continu ;
• un convertisseur RS232/TTL.

Bien qu’un des PIC les plus utilisés soit probablement le 16F84, nous avons volontairement choisi le 16F88 dans notre exemple pour plusieurs raisons. Le 16F88 est compatible avec le jeu d’instructions du 16F84 avec quelques " équipements " supplémentaires. On trouve parmi ces fonctions un UART, la gestion de l’I2C par un module spécifique, ainsi que la possibilité d’écrire dans la mémoire flash par soft. Cette dernière particularité est probablement la plus importante, puisqu’elle permet d’utiliser un bootloader avec ce microcontrôleur, ce qui n’était pas possible avec le 16F84. Enfin, le prix unitaire du 16F88 est très compétitif par rapport à celui du 16F84 qui est en fin de vie.
Voici le schéma de notre montage de test.

Le convertisseur RS232/TTL permet d’adapter les niveaux de sortie d’un port RS232 à celui de notre microcontrôleur. Autrement dit, transformer du +12V/-12V en 0-5V. De nombreux montages sont décrits et pourront être reproduits. Voir par exemple sur le site de l’auteur la page suivante : http://jmandon.free.fr/CNV232/cnv232.htm.
Cette page décrit la réalisation d’un câble avec un MAX232, composant très courant que l’on trouve dans toutes les bonnes boutiques.
On voit sur le schéma ci-dessus que nous avons placé un bouton de reset qui nous permettra de réinitialiser le 16F88 chaque fois que le downloader sera utilisé.
Ce montage a été câblé sur une plaque d’essais.

Le programme adapté au 16f88

Nous allons maintenant reprendre le programme étudié précédemment et l’adapter au 16F88.

#define __16F88
#include <pic16f88.h>
int i;
void main(void) {
TRISB = 0;
while(1) 	{
		PORTB=PORTB|1;
		for (i=1;i<10000;i++);
		PORTB=PORTB&254;
		for (i=1;i<10000;i++);
		}
}

Compilez ensuite ce programme : sdcc -mpic14 -p16F88 test.c
Le résultat de la compilation sera le suivant :

message: using default linker script "/usr/share/gputils/lkr/16f88.lkr"

Ce message vous indique que le linker a utilisé le fichier par défaut. Dans le dossier de votre application, vous allez trouver maintenant le fichier test.hex qui est le résultat de la compilation avec SDCC. Il reste maintenant à transférer le programme dans le PIC.

Le transfert du programme

Après avoir enregistré le downloader Python dans un dossier, passez en mode console et tapez :
python tinyjpfr.py

Vous obtenez l’écran suivant :

Sélectionnez dans la partie gauche de l’écran le port sur lequel est raccordé votre convertisseur ainsi que la vitesse (19200 bauds dans notre cas). Chargez le fichier test.hex.
Vous pouvez ensuite faire un reset du PIC et cliquer sur Detect. Le downloader vous indiquera qu’il a détecté un PIC 16F88. Pour transférer le programme dans le PIC, faites un reset, puis cliquez sur Download. Au bout de 2 secondes, la LED devrait se mettre à clignoter.

Conclusion

Cet article nous a permis de mettre en œuvre les différents outils nécessaires au développement d’applications en langage C sur les PIC. Après sa lecture, nous disposons de tous les logiciels permettant de compiler, d’assembler et de transférer des programmes dans ces microcontrôleurs. Reste maintenant à améliorer cette base et à réaliser des applications concrètes et utiles. Dans notre prochain article, nous verrons comment utilliser Scite non seulement comme éditeur de texte, mais également comme environnement de développement pour les PIC. Cette présentation sera suivie par la description de la réalisation d’une carte d’entrées/sorties communicante, le coté hardware étant réalisé autour d’un PIC 16F88 programmé en langage C avec SDCC, le logiciel de commande, lui, étant programmé en Python avec le composant PySerial.

Liens

• SDCC : http://sdcc.sourceforge.net/
• GPUTILS : http://gputils.sourceforge.net/
• Tiny Bootloader:

  http://www.etc.ugal.ro/cchiculita/software/picbootloader.htm

• Le site de l’auteur : http://www.pictec.org

L’auteur

Jean-Pierre MANDON est ingénieur en électronique et travaille sur les microcontrôleurs depuis 1986. Il a réalisé ses premières applications en assembleur sur INTEL 8031. Il travaille sur les microcontrôleurs Microchip depuis 1995, d’abord en assembleur, puis en langage C depuis 2000. Passionné des systèmes de communications et de programmation réseau, il a commencé l’interfaçage de carte réseau ISA avec des PIC en 1999. Ce projet, PicoIP, a évolué aujourd’hui vers le pilotage de carte PCMCIA et compact flash wifi à l’aide de processeurs de la série 18FXXX. Outre ses travaux sur les systèmes communicants, il dirige depuis 1993 un atelier expérimental de robotique et d’étude comportementale à l’école d’art d’Aix-en-Provence et a participé à la réalisation de nombreuses expériences artistiques. L’atelier est spécialisé dans l’interfaçage d’œuvres artistiques interactives.
L’esprit open source qui a toujours animé les projets qu’il a menés l’a poussé à orienter de façon plus nette ses travaux vers Linux et la communauté des développeurs. Il a créé cette année un atelier Linux à l’école d’art d’Aix-en-Provence destiné à encourager l’utilisation de logiciels open source dans le domaine artistique.
LAOS, le laboratoire de l’Open Source, est destiné à diffuser, auprès des étudiants des écoles d’arts, des cours et des initiations à des logiciels comme The Gimp, Blender ou Pure Data et de contribuer au développement d’applications open source. Le premier projet de cet atelier est le portage d’Arduino sur PIC. Arduino est un concept de monocarte pour le pilotage d’installations artistiques.

Liens

• www.ecole-art-aix.fr
• http://atelierloeil.free.fr
• www.pictec.org

 Retrouvez cet article dans : Linux Magazine 90