Introduction à la carte FOX LX832

La carte FOX LX832 est un système embarqué à bas coût utilisant un système d'exploitation Linux et développée par le constructeur italien Acmesystems. Elle est dotée d'un processeur AXIS à 100MHz (processeur ETRAX 100LX), de 32 MB de RAM, 8MB de mémoire flash, de connectiques USB, Ethernet, de plusieurs ports séries ainsi que de nombreuses entrées/sorties numériques pouvant être reliées à plusieurs BUS de données. Le système Linux est déjà préinstallé sur la carte, ce qui la rend fonctionnelle dès l'achat.

Elle permet de développer en bon nombre de langages : C, C++, PHP, PYTHON, Shell… et offre des connexions HTTP, FTP, SSH, TELNET et série. De petite taille et faible consommation électrique (1.4 W), elle est idéale pour mettre en place rapidement des projets de type embarqué.

Ses deux connecteurs 40 broches permettent de connecter la carte Fox à des cartes d'extension (à acheter ou construire séparément). Le constructeur propose des cartes possédant différentes caractéristiques, telles que des connexions Zigbee, GSM/GPRS, mais aussi un lecteur de carte mémoire, ou l'ajout d'une horloge système.

Il est important de noter qu'à partir du 31 juillet 2010, le processeur de la carte changera au profit d'un processeur ARM9. La carte « FOX Board LX832 » changera de nom pour « FOX Board G20 ». La production de cartes fox LX continuera jusqu'à ce qu'ils ne trouvent plus de processeurs ETRAX 100LX. Le constructeur estime que ses stocks seront épuisés bien après la date du 31 juillet 2010.

Le prix dans le commerce pour cette carte tourne autour de 170 euros.

Note : Acmesystems a annoncé la sortie prochaine (septembre 2009) de sa nouvelle carte G20 quelque temps après la rédaction de ce tutoriel … dévoilant toutes les caractéristiques de son nouveau produit. Le constructeur invite ses nouveaux clients à regarder l'éventualité de la nouvelle carte Fox G20. Cette dernière embarque la distribution Linux OpenWRT et son architecture se rapproche très fortement de la carte fox LX832 actuelle. Ce tutoriel n'est pas pour autant inutile, car on ne trouve pas encore de modèle G20 dans le commerce auprès les revendeurs français, et de par le fait que les cartes seront très proches. Je publierai un nouveau tutoriel complémentaire sur la G20 à l'occasion de la sortie de la nouvelle carte.

La carte a besoin d'une alimentation régulée de +5V DC, que cela soit via son connecteur J14 ou le J2. La tension ne doit en aucun cas fluctuer, sinon la carte va tout simplement griller. La carte seule consomme 280mA, valeur qui augmentera plus l'on rajoutera de périphériques. Pour allumer la carte, il suffit de brancher l'alimentation. Le voyant vert indique la mise sous tension.

Internet regorge d'exemples de systèmes embarqués. Il s'avère que la carte Fox est assez souvent utilisée dans des projets amateurs et même professionnels, en raison de son prix attractif et de ses caractéristiques techniques très intéressantes.
Différents projets réalisés avec la carte fox sont listés sur le site du constructeur.

On y trouve différentes utilisations possibles :

• carte mère pour robots mobiles ;
• appareil de téléchargement autonome de fichiers torrents ;
• carte mère pour ballon dirigeable ;
• streaming vidéo ;
• système de contrôle pour des trains (modélisme) ;
• système de domotique ;
• lecteur de puce RFID ;
• serveur GSM/envoi de SMS.

Les utilisations sont infinies, et ne dépendent que de l'imagination du développeur !

Mandriva
À partir d'une distribution Mandriva Linux One 2009 Spring fraichement installée, nous commençons par installer les paquets suivants à l'aide du gestionnaire de logiciels :
subversion, gcc, make, libncurses-devel, zlib1-devel, flex, byacc, bc.

Normalement le système installé possède par défaut tous les autres prérequis nécessaires à l'installation. En cas de package manquant, se référer à la liste en début de partie.
Puis nous téléchargeons le compilateur croisé ainsi que pmake pour l'installation du SDK avec les commandes suivantes :

wget http://foxlx.acmesystems.it/download/cris-dist-1.63-1.i386.rpm
wget http://foxlx.acmesystems.it/download/pmake-1.45-16.i386.rpm

Ensuite, en root (su -) nous tapons :

rpm -U pmake-1.45-16.i386.rpm
rpm -U cris-dist-1.63-1.i386.rpm

Ubuntu
À partir d'une distribution Ubuntu 8.10 vierge, nous commençons par installer les paquets suivant en tapant les commandes apt-get suivantes :

sudo apt-get install make
sudo apt-get install gcc
sudo apt-get install libc6-dev
sudo apt-get install libncurses5-dev
sudo apt-get install pmake
sudo apt-get install zlib1g-dev
sudo apt-get install flex
sudo apt-get install bison
sudo apt-get install subversion

Ensuite, sous Ubuntu, le lien symbolique /bin/sh pointe vers /bin/dash au lieu de /bin/bash. Or cela est nécessaire pour notre installation. Ainsi il suffit de faire :

sudo ln -sf /bin/bash /bin/sh

pour changer le lien symbolique.
Il faut ensuite télécharger le compilateur croisé :

wget http://foxlx.acmesystems.it/download/cris-dist_1.63-1_i386.deb

et installer le package en tapant :

dpkg -i cris-dist_1.63-1_i386.deb

Procédure commune
Maintenant que tous les packages préliminaires ont été récupérés, nous allons maintenant créer un dossier pour le SDK, télécharger son script d'installation et l'exécuter en tapant :

mkdir ~/foxboard
wget http://www.acmesystems.it/download/install_svn_sdk.sh
chmod +x install_svn_sdk.sh
./install_svn_sdk.sh

L'installation démarre et télécharge le SDK (devboard-R2_01-distfiles.tar.gz) et commence à l'installer. Au bout de quelque temps apparaît le message suivant :

### Selected product: "fox" ###
etrax100boot must be run by root.
To make this easier (but less secure) you can make etrax100boot setuid root.
Do you want to make etrax100boot setuid root now [yn]? (default n):

Répondre y pour permettre à etrax100boot d'être lancé en root (programme chargé de flasher la carte fox).
Une fois l'installation terminée, un dossier devboard-R2_01 est alors créé et contient notre SDK.
Il sera alors possible de configurer ce SDK pour changer le noyau de la carte fox en activant/désactivant différentes options et en chargeant différents drivers. Cette manipulation fera l'objet d'un autre tutoriel.
En attendant, nous allons d'abord vérifier qu'il n'existe pas de mise à jour du SDK en tapant :

cd devboard-R2_01
./sdk_update

Comme indiqué précédemment, il n'est pas possible d'utiliser directement le SDK sous Windows. Il faut passer par une machine virtuelle. À titre d'exemple, j'ai utilisé VirtualBox pour ce tutoriel. L'installation d'un système Linux avec cette application est relativement simple et intuitive. Il suffit de télécharger une distribution au format .iso et de faire « nouveau » et suivre les indications. Puis en faisant « lancer » nous allons ensuite chercher le .iso fraîchement installé. Une fois le système en place, il n'y a plus qu'à se référer au paragraphe précédent sur la partie Linux.

Il est important à noter que pour bénéficier d'une connexion réseau opérationnelle il faudra activer la connexion de pont, sinon la carte fox ne sera pas joignable.

Le constructeur fournit également une image de machine virtuelle préinstallée basée sur debian Sarge 3.1 avec le SDK déjà installé. Le principe est alors le même, il faut par contre installer l'application VMware et double cliquer simplement sur le .vmx contenu dans le fichier zip suivant : http://foxlx.acmesystems.it/download/foxsdk.zip. Vous pourrez trouver plus d'informations sur la configuration du SDK sous VMware sur le site du constructeur.

Bénéficiant d'un port Ethernet il est possible de la brancher à n'importe quel réseau. La DEL jaune clignotante indique l'activité réseau de la carte.
Par défaut, une carte neuve est configurée de la sorte :

Adresse IP: 192.168.0.90
Netmask: 255.255.255.0
Passerelle: 192.168.0.1

Si votre réseau est configuré de la sorte, la Fox s'y intègre sans problème et celle-ci est accessible directement. L'idéal dans un premier temps est de connecter la carte à notre PC à l'aide d'un câble croisé.
Déjà nous pouvons vérifier la connexion de la carte avec un :

ping 192.168.0.90

Si la connexion ne se fait pas, essayons en root la commande suivante :

ifconfig interface_ethernet 192.168.0.10 netmask 255.255.255.0

où interface_ethernet est l'interface réseau de notre PC (eth1 dans mon cas). Nous nous allouons alors l'adresse IP 192.168.0.10 pour être dans le même réseau que la FOX.

IV-A-1. TELNET▲

telnet 192.168.0.90

IV-A-2. SSH▲

ssh root@192.168.0.90

IV-A-3. Web▲

IV-A-4. Envoi de fichiers▲

scp <fichier> root@192.168.0.90:<dossier_absolu>

IV-A-5. Connexion Réseau et Internet▲

ifconfig eth0 x.x.x.x

nameserver 192.168.1.1

La carte fox possède plusieurs ports série, dont un port console (port J10 sur la carte). En connectant ce port à un PC grâce à un câble RS232 classique, nous avons accès à la console Linux. Cette technique peut s'avérer extrêmement utile dans le cas d'une erreur de manip qui bloque la connexion Ethernet. Exemple, si vous vous trompez dans l'adresse IP à allouer à la carte fox et que la connexion n'est plus possible en Ethernet après reboot, il y a possibilité d'aller corriger le problème grâce au port série. À noter qu'il est possible de réinitialiser la carte dans sa configuration d'usine en allumant et éteignant avec le bouton SW1 enfoncé pendant environ 10 secondes. C'est assez radical comme solution, mais ça a le mérite d'exister.

Il faut par contre posséder :

• un port série de libre sur le PC (port série sur carte PCI par exemple) ;
• un câble RS232 ;
• un adaptateur série pour la carte Fox ;
• l'hyperterminal sous windows ou minicom sous Linux.

L'adaptateur série est nécessaire, car le protocole RS232 fonctionne sur PC à 12V et la carte fox délivre du 3.3V. Il y a possibilité de faire soit même l'adaptateur ou d'en acheter un en même temps que la Fox.

La connexion se configure alors de la sorte :
Débit : 115200 bauds
Bits de données : 8
Parité : Aucune
Bits d'arrêt : 1
Contrôle de flux : aucun

En choisissant votre port série selon votre configuration.

L'accès au terminal est alors direct. À noter que de par sa nature de « console » le port J10 (/dev/ttyS0) envoie des trames au démarrage de la carte. Donc faire attention tout de même à ne pas utiliser ce port comme port série classique, sinon votre périphérique va recevoir un gros flux de données qui ne lui sont pas destinées (périphérique fou !) Il y a toutefois possibilité de désactiver le mode console du port série (à vos risques et périls)

Bénéficiant de deux ports USB, la carte fox peut être connectée à différents périphériques USB tels que des dongles Wi-Fi ou bluetooth. Elle peut également être reliée à une webcam ou tout autre périphérique USB, du moment que les drivers sont présents sur la Fox ou bien que vous les avez à votre disposition. Cependant ces points ne seront abordés ici, et trouveront leur place peut-être dans d'autres tutoriels.

La première consiste à se rendre à cette adresse. Acmesystems met à disposition un compilateur web gcc qui vous propose de compiler un fichier source avec le compilateur adapté à la Fox. Il suffit alors d'aller chercher notre fichier bonjour.c sur notre disque et de cliquer sur compiler. Nous recevons alors un fichier .out que nous allons envoyer sur la carte Fox grâce à la commande suivante :

scp bonjour.out root@192.168.0.90:/mnt/flash/

Il faut alors indiquer à Linux que notre fichier .out est un exécutable. On se connecte alors à la Fox et se rend dans le répertoire /mnt/flash pour exécuter le code suivant :

chmod +x bonjour.out

Il ne reste alors plus qu'à l'exécuter en tapant :

./bonjour.out

L'intérêt de cette méthode est de permettre le développement de programmes très rapidement sur une machine n'ayant pas le SDK d'installé. L'inconvénient est tout de même de ne pas pouvoir linker notre code à d'éventuelles bibliothèques.

La seconde méthode est un peu plus complexe. Elle nécessite en effet l'installation du SDK, ce que nous venons de faire. Pour pouvoir commencer à développer, nous allons devoir activer l'environnement, c'est-à-dire charger les variables d'environnement qui vont pointer vers notre compilateur croisé. Il faut déjà se rendre dans notre dossier devboard-R2_01 créé lors de l'installation du SDK, puis taper :

. init_env

Nous nous rendons alors dans apps puis créons un nouveau dossier :

cd apps
mkdir helloworld

Nous pouvons ainsi y déposer notre bonjour.c
Nous allons ensuite changer le compilateur habituel, au profit de celui proposé par notre SDK en tapant :

make cris-axis-linux-gnu

Le programme qui sera généré par la suite ne pourra pas être exécuté par notre système Linux. Pour revenir à notre compilateur gcc standard et tester en local, il suffit de taper :

make host

Nous allons alors avoir besoin d'un Makefile pour pouvoir compiler notre programme. Ne serait-ce que pour charger toutes les informations relatives à la cross-compilation présentes dans le fichier devboard-R2_01/tools/build/Rules.axis :

AXIS_USABLE_LIBS = UCLIBC GLIBC
include $(AXIS_TOP_DIR)/tools/build/Rules.axis

PROGS = bonjour

all: $(PROGS)
$(PROGS): $(PROGS).o
    $(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@
    scp bonjour root@192.168.1.90:/mnt/flash/
    
clean:
    rm -f $(PROGS) *.o core

En tapant make, le fichier est alors compilé de la même façon qu'avec le web compilateur. Il peut même être intéressant de glisser l'envoi du fichier dans le makefile via scp. Cela fait gagner un peu de temps si on passe son temps par la suite à compiler et tester son programme sur la carte.
Le programme est alors prêt à être exécuté.

La commande setbits va nous permettre de manipuler les valeurs de sortie de la carte

setbits -p port -b bit -s état

où port est la valeur de port à utiliser (a, b ou g), bit est le numéro de bit à changer et état sa valeur binaire (0 ou 1)
On peut alors, allumer notre LED :

setbits -p g -b 25 -s 1

et l'éteindre

setbits -p g -b 25 -s 0

On peut même créer un script shell pour la faire clignoter :

#/bin/sh
while [ 1 ]
do
 setbits -p g -b 25 -s 1
 sleep 1
 setbits -p g -b 25 -s 0
 sleep 1
done

La commande readbits nous permet, quant à elle, de lire la valeur des sorties de la fox.

input=`readbits -p a -b 1`

Nous permettra alors de lire le bit 1 du port a. Il deviendra ainsi très simple de tester la valeur d'une entrée pour faire par exemple fluctuer d'autres bits de sortie. On pourra par exemple placer un interrupteur en entrée, qui une fois pressé déclenchera une action prédéfinie par la carte sur les sorties. Les possibilités sont infinies.

Travailler avec le shell peut-être intéressant, car rapide à utiliser. Toutefois si l'on souhaite passer à des programmes plus complexes nous pouvons travailler directement en C. Ce dernier gère sans problèmes les entrées/sorties. L'exemple suivant est la traduction en C du précédent script shell qui fait clignoter la LED :

#include "stdio.h"
#include "stdlib.h"
#include "unistd.h"
#include "sys/ioctl.h"
#include "fcntl.h"
#include "asm/etraxgpio.h"

int main(void) {
  int fd;
  int i;
  int iomask;

  if ((fd = open("/dev/gpiog", O_RDWR))<0) {
    printf("Open error on /dev/gpiog\n");
    exit(0);
  }

  iomask=1<<25;

  while (1) {
    printf("Led allumée\n");
    ioctl(fd,_IO(ETRAXGPIO_IOCTYPE,IO_SETBITS),iomask);
    sleep(1);

    printf("Led éteinte\n");
    ioctl(fd,_IO(ETRAXGPIO_IOCTYPE,IO_CLRBITS),iomask);
    sleep(1);
  }
  close(fd);
  exit(0);
}

Nous commençons par ouvrir le port choisi, en l'occurrence /dev/gpiog pour le port G dans notre cas. De la même façon, nous avons /dev/gpioa et /dev/gpiob pour les ports A et B. Attention à ne pas oublier de fermer les ports ouverts à la fin du programme.

Nous mettons ensuite en place le masque qui permet de définir quels bits nous allons modifier, et l'appliquons grâce à la fonction ioctl. IO_SETBITS permet comme son nom l'indique de mettre à 1 les bits définis par le masque et IO_CLRBITS les passe à 0.

Le principe de lecture de bit en entrée est légèrement différent. On utilise la syntaxe suivante :

input=ioctl(fd, _IO(ETRAXGPIO_IOCTYPE, IO_READBITS));

ioctl ne renvoie pas directement la valeur du bit, mais un masque de bits correspondant à tout le port. En appliquant un ET logique entre input et notre masque de bits (définissant le bit qui nous intéresse) il nous est possible de connaître la valeur du bit. Voici le code, dans le cas d'une entrée numérique sur le bit n°16 du port G :

#include "stdio.h"
#include "stdlib.h"
#include "unistd.h"    
#include "sys/ioctl.h"
#include "fcntl.h"     
#include "asm/etraxgpio.h"

int main(void) {
  int fd;
  int input;
  int iomask;

  if ((fd = open("/dev/gpiog", O_RDWR))<0) {
    printf("Open error on /dev/gpiog\n");
    exit(0);
  }

  iomask=1<<16;

  while (1) {
    input=ioctl(fd, _IO(ETRAXGPIO_IOCTYPE, IO_READBITS));
    if ((input&iomask)==0) {
      printf("Valeur d'entrée : 1\n");
    } else {
      printf("Valeur d'entrée : 0\n");
    }
    sleep(1);
  }
}