Vous êtes sur la page 1sur 21

Départements de Génie Electrique

Filière d’ingénieur
Systèmes Intelligents, Communicants et Mobiles (SICOM)

Rapport des travaux pratiques


Informatique embarquée

Encadré par : Pr. Aicha Alami Hassani


Préparer par : - Mouka Ibtissam
- Fathllah Ikrame
- EZ-ZAMRANI Omar
- Amine Tarik

Année universitaire 2021-2022


Introduction :
La "FOX Board G20" est un système embarqué économique de faible dimension pour
système d'exploitation Linux, architecturée autour d’un processeur ARM9™ AT91SAM9G20
400 MHz d'Atmel™. 

De part ses caractéristiques, la platine "FOX Board G20" est donc toute indiquée pour
l'étude et l'évaluation dans le cadre du développement de mini-serveurs web, proxy,
routeur, firewall et autres systèmes de contrôle embarqués.

La platine support dispose également d'un connecteur d'alimentation, d'un connecteur


Ethernet (Base 10/100), de 2 ports USB 2.0 host, d'un port Client sur mini USB, d'une pile de
sauvegarde pour horloge RTC, d'un bouton-poussoir libre d'utilisation, d'un emplacement
pour afficheurs uOLED intelligents de "4D Systems" (proposés en option en bas de page)
ainsi que d'un connecteur mâle au pas de 2,54 mm permettant le raccordement d'un  port
série "console/Debug" (3,3 Vcc)

La carte dispose de part et d'autre de 2 rangées de 20 trous au pas de 2.54 mm destinés à


recevoir des connecteurs optionnels qui vous permettrons de monter la carte "FOX" sur une
platine principale de votre réalisation (nous proposons des connecteurs dédiés à cet effet au
bas de la page (2 connecteurs mâles et 2 connecteurs femelles sont nécessaires).

Ces connecteurs donnent accès aux nombreux signaux :

o 28 ports d'entrées/sorties
o 2 ports série (niveau 3,3 V)
o 4 entrées de conversion "A/N"
o bus I2C™ / SPI™
o Sortie PWM
o etc..

1
Objectif de TP :
 D’intégrer un noyau linux sur carte embarque à base LINUX
 Exécuter des commandes Shell
 Savoir l’architecture des GPIO et leurs fonctionnements sur Linux
 Mise en œuvres de programme divers sur Fox G20 (Led, Conteur 7 seg )
Architecture de FOX G20 :

Les caractéristiques de FOX G20 :

2
La platine FOX Board G20 La platine "FOX Board G20" est un système embarqué avec un OS Linux,
construite autour d’un processeur ARM9 AT91SAM9G20 cadencé à 400 MHz d'Atmel. Elle est
composée d'une platine support avec étage de régulation multiple (2 x 3,3 V / 1,8 V / 1 V) sur
laquelle est insérée le module CPU « NETUS G20 » (lequel intègre le processeur AT91SAM9G20). La
platine support fourni : un connecteur d'alimentation, un connecteur Ethernet (Base 10/100), 2
ports USB 2.0 host, un port client sur mini USB, une pile de sauvegarde pour horloge RTC, un
bouton-poussoir libre d'utilisation, un emplacement pour afficheurs uoled intelligents de "4D
Systems", un connecteur mâle au pas de 2,54 mm pour le raccordement du port série
"console/debug" une zone de prototypage rapide disposant de ports série, ports d’entrées/sorties
parallèle, I2C/SPI, convertisseurs A/N, PWM, Ethernet Ports USB 10/100BaseT 12 Mb/s Zone de
prototypage Connecteur J7 Zone de prototypage Connecteur J6 Connexion afficheur uoled Module
Netus G20 Port mini USB Port Debug Carte microsd.

Préparation de la carte microSD :

Le premier élément de code exécute lors de démarrage de la carte FOXG20 est


le RomBOOT, Ce firmware est stocké dans le processeur Atmel ,il cherche un
code exécutable sur la mémoire Dataflash ,cette dernier est programmée par
défauts avec le chargeur de démarrage appelée AcmeBoot qui démarre linux à
partir de la carte microSD
La carte microSD contient deux partitions :
Kernel : partition FAT16 qui contient le noyau linux
Rootfs  : partition ext4 qui contient le système de fichier de linux

Partitionnement de la carte microSD :

En générale, les cartes microSD sont constitues d’une seul partition principale formatée en
FAT32, il faudra donc démontrer cette partition et en crée deux nouvelles conformément à

3
l’architecture décrire ci-dessus, le partitionnement et le formatage détruiront
irrémédiablement les données présentes sur le support indiqué
Il existe des outils
 Qlqs en ligne de commande
Sous Windows (en mode DOS) :diskpart
Sous linux : fdisk
 Qlqs logiciels
Gparted : un logiciel graphique
Ease Partition Master Free : assez complet en version gratuit
Pour effectuer les deux opérations on suivre les étapes suivantes :
1) Insère la microSD dans un adaptateur USB/microSD
2) Démontrer la microSD, c-à-d la déconnecter le système de fichier
3) Détruire le partitionnement existe
4) Crée et formater les deux partitions :la première en FAT16 de 32 Mo nommé Kernel et
le reste en ext4 nommé rootfs
5) Retirer l’adaptateur USB/microSD puis après qlq second, le rebrancher les deux
partitions nouvellement crées automatiquement.
Copie du noyau et du système de fichier
On a décompacté les archives du Kernel et du FS (kernel.tar.bz2) et (rootfs.tar.bz2) et copier
leur contenu respectivement dans les partitions rootfs et KERNEL par les commandes linux
suivantes :
$sudo tar –xvjpSf Kernel.tar.bz2 -c /media/$USER/KERNEL
$sudo tar –xvjpSf rootfs.tar.bz2 -c /media/$USER/rootfs

Démarrage de la carte FOX G20


Pour allumer la carte , il suffit de brancher l’alimentation mais avant ceci il faut insérer la
carte microSD contenant l’OS linux dans le lecteur situé à l’arrière de la carte

Ensuite connecter la carte au réseau à l’aide d’un câble LAN , connecter l’alimentation à la
carte et connecter l’alimentation au secteur

En générale :
Carte microSD. Elle contient deux partitions : FAT16 : Noyau (Kernel) EXT4 : système de fichiers.
Capacité maximale de 8 Go. Le premier élément de code exécuté lors du démarrage est le
RomBOOT. Ce firmware est stocké dans le processeur Atmel. Il cherche un code exécutable sur la
mémoire Dataflash. Cette dernière est programmée par défaut avec le chargeur de démarrage
appelé AcmeBoot, qui démarre linux à partir de la carte microSD. Détail des connexions disponibles :
SIN42 Platine système embarqué FOX Board G20 Page 4 sur 51
Connexion Wiki du fabricant : Insérez la carte microSD amorçable contenant l’OS linux dans le
lecteur. Connectez la carte au réseau à l’aide d’un câble LAN. Connectez l’alimentation à la carte.

4
Connectez l’alimentation au secteur. Lorsque la carte est alimentée, le voyant vert noté 3V3
s’éclaire. Si vous êtes connecté au port débuggé, vous voyez la séquence de démarrage à l’écran.
Après environ 5 secondes, le voyant rouge noté PC7 se met à clignoter. S’il reste allumé sans
clignoter, c’est que la carte microSD n’est pas présente, n’est pas bootable ou le système qu’elle
contient est défectueux. Après environ 20 secondes, le système est opérationnel et il est possible de
s’y connecter par le réseau au moyen d’une connexion ssh, à condition de connaitre l’adresse IP de
la carte. Remarque : Le mot de passe de root par défaut est netusg Sous linux (Ubuntu) Ouvrez un
terminal, octroyez-vous les droits super-utilisateur et ouvrez une connexion ssh. SIN42 Platine
système embarqué FOX Board G20
Accès à la carte FOX G20 :
Pour accéder à la Fox G20 avec PuTTY sous Windows on utilise le port Debug qui permet d’établir
une connexion USB RS232
Sous Windows Wiki du fabricant : Vous devez disposer du logiciel PuTTY (Exécutez PuTTY et
établissez une connexion ssh avec la carte.
On configure sur PuTTY le port ouvert (Le port COM3 ) avec comme caractéristique 115200
Puis on démarre la carte FOX G20
Pour identifier
Login : root
Password : netusg20

Trouvez l’adresse IP de la carte FOX Board G20 Wiki du fabricant : Par défaut, la carte est configurée
en adressage automatique. Elle attend donc qu’un serveur DHCP lui attribut ses paramètres TCP/IP.
Pour trouver l’adresse IP qui lui a été attribuée, vous pouvez utiliser le port debug ou un logiciel de
scan d’adresses IP (ipscan.exe par exemple) Port debug Le port debug (DPI : Debug Port Interface)
permet d’établir une connexion avec la carte au moyen d’une connexion USB qui émule une liaison
série RS232. Il est construit autour d’un FTDI FT232 qui ne nécessite pas d’installation de pilotes sous
linux. En revanche, sous Windows, il faudra télécharger et installer les pilotes de chez FTDI. Sous
Windows, on pourra utiliser HyperTerminal. Sous linux, on pourra utiliser Minicom. Les
caractéristiques de la liaison sont : bds, 8 bits, 1 Stop, NP, pas de contrôle de flux .

Le port debug

5
Pour plus de détaille
Pour obtenir l’adresse IP, on utilise la commande suivante
$ ifconfig ou $ifconfig eth0
Pour allouer notre propre adresse IP s’il n’affiche pas un adresse nous exécutons la commande linux
suivante :
$ ifconfig eth0 192.168.x.xxx ( ex: 192.168.2.102 ).

Utilisation des Ports GPIO


Le CPU AT91SM9G20 utilisé sur la FOX Board G20 dispose de 3 ports appelés A, B et C avec
32 bits chacun. Tous les bits ne sont pas disponibles sur les connecteurs de la carte et
certains sont multiplexés avec d’autres types de liaisons comme des ports série, I2C, SPI,
convertisseur A/N,USB, ….L’utilisateur dispose de 28 lignes GPIO sur les deux connecteurs J6
et J7 de la carte
.

6
Les GPIO Sysfs est utilisé pour gérer les ligne GPIO de la carte FOX G20 , c’est un système de
fichier virtuel , qui permet d’exporter depuis le noyau vers l’utilisateur des information sur
les périphériques du système et leurs pilotes ,ainsi la gestion des I/O se fait par le biais de
simple situé dans /sys/class/gpio , notamment les fichiers exports et unexport

Le fichier exports permet d’exporter une ligne GPIO identifiée par son ID
Le fichier unexport permet de libérer une ligne GPIO identifiée par son ID

Les ID de noyau du système sont disponible en annexe : Kernel ID


Le système d’exploitation Linuxe traite ces ports GPIO comme des fichiers chaque port a
deux fichier principales qui sont la valeur (value) et la direction (Direction) ces deux fichiers se
trouvent dans un répertoire qui porte le nom du pin utilisé.
-Direction : c’est un fichier qui contient soit la chaine de caractère out si le pin est une sortie soit IN
s’il s’agit d’une entrée.
-Value : ce fichier contient soit la valeur 1 ou 0 .la valeur 1 pour un état haut du pin et la valeur 0
pour l’état bas.
Avant de trouver ces fichiers il faut tout d’abord activer (exporter) le pin avec la commande
Echo ‘pin ID’ > /sys/class/gpio/export
Une fois qu’on exécute cette commande on peut remarquer l’apparition d’un répertoire qui porte
le nom du pin exemple (pioA11). On peut parcourir ce répertoire avec la commande :
Cd /sys/class/gpio/pioA11
Puis on tape la commande « ls » pour voir le contenu du répertoire, on va trouver les deux fichiers
Value et Direction

Exemple 1 : Allumer une LED

On utilise la ligne 7 : j6.25


# echo 7 >/sys/class/gpio/export (activation de la ligne)
# écho out >/sys/class/gpio/pioA7/Direction ( écrire « out » dans le fichier direction pour
que la Ligne sera considérer comme une sortie)
# echo 1 >/sys/class/gpio/pioA7/value (définir la ligne à l’état haut pour allumer la led)

Exemple 2 : configuration d’un switch

On utilise la ligne 22 : j6.37


#echo 22 > / sys / class / gpio / export
#echo IN > /sys / class / gpio / pioA22/ direction
(écrire ’’IN’’ dans le fichier direction pour que la ligne sera considérer
comme une entrée)
(afficher la valeur du switch : 1 si le switch est dans l’état haut, 0 si le

7
switch est dans l’état bas)
# cat /sys/class/gpio/pioA11/value

Exemple3 : clignotement d’une LED


Pour réaliser cet exemple on a créé un fichier dans un éditeur de texte qui contient le
programme complet :

echo 11 /sys/class/gpio/export (l’activation de la ligne)


echo out /sys/class/gpio/pioA22/direction (la ligne sera considérer comme une sortie)
While(1) (une boucle infini)
Do
echo 1 /sys/class/gpio/pioA22/value (allumer la led)
Sleep(1) (laisser la led allumer pendent 1 seconde)
echo 0 /sys/class/gpio/pioA22/value (etteindre la led)
Sleep(1) (laisser la led etteindre pendent 1 seconde)
Done
Pour lancer l’exécution du programme : exemple3.sh on tape sur la terminal :

./exemple3.sh

Connexion au site web embarqué


Après avoir changer l’adresse IP, on saisi dans la barre d’adresse cette adresse IP , une page
s’affiche qui nous donne la possibilité entre deux environnement : le Shell et le codiac, on
clique sur le codiad, on se connecte avec le login et le mot de passe indiquer puis on
commence la création de notre propre projet qui vont inclure des fichier sources
programmer en langage C.

La programmation en C :
Pour linux tout les portes GPIO sont considérer comme des fichiers, pour cela on doit utiliser
des drivers qui assurent l’activation des différents portes, la direction, l’affectation d’une
valeur a une LED ainsi la récupération de l’état d’un SWITCH.

Le driver utilisé pour configurer les ports :


Ce programme de configuration des ports GPIO de la FoxG20 est exploité dans
toutes les applications qu’on a réalisé durant les séances de TP.

8
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <time.h>
#define LOW 0
#define HIGH 1
#define IN 1
#define OUT 0
struct S_GPIO_LINE {
char id_line[5];
int id_pin;
int direction;
int value;
};
typedef struct S_GPIO_LINE S_GPIO_LINE;
int tableau[4];
/* ********************************** */
/* LOAD_GPIO_LINE */
/* Initialisation of a GPIO line */
/* ********************************** */
int load_gpio_line(S_GPIO_LINE *ps_line )
{
FILE *p_gpio_line;
/* Exporting GPIO line */
if ((p_gpio_line = fopen("/sys/class/gpio/export", "w")) == NULL)
{
printf("Cannot open export file.\n");

exit(1);

}
fprintf(p_gpio_line,"%d",ps_line->id_pin);
fclose(p_gpio_line);
return 0;
}
/* ****************************************** */
/* SET_GPIO_DIRECTION */
/* Sets the direction (IN/OUT) of a GPIO line */

9
/* ****************************************** */
int set_gpio_direction(S_GPIO_LINE *ps_line, int i_direction)
{
int fd;//file
char path[35];//chemin
snprintf(path,35, "/sys/class/gpio/pio%s/direction",ps_line->id_line);
printf("path:%s\n",path);
fd = open(path, O_WRONLY);
if (-1 == fd) {
fprintf(stderr, "Failed to open gpio direction for writing!\n");
exit(1);
}
if( i_direction ) {
if (-1 == write(fd, "in", 36)) {
fprintf(stderr, "Failed to set direction!\n");
exit(1);
}
}
else {
if (-1 == write(fd, "out", 36)) {
fprintf(stderr, "Failed to set direction!\n");
exit(1);
}
}
return 0;
}
/* ***************************** */
/* SET_GPIO_LINE */
/* Sets the value of a GPIO line */
/* ***************************** */
int set_gpio_line(S_GPIO_LINE *ps_line, int value)
{
FILE *p_gpio_value;
char gpio_value[35];
char c_value[2];
if( 1) {
sprintf(gpio_value, "/sys/class/gpio/pio%s/value",ps_line->id_line);
/* Setting value */
if ((p_gpio_value = fopen(gpio_value, "w")) == NULL)
{
printf("Cannot open value file.\n");
exit(1);
}
rewind(p_gpio_value);

10
sprintf(c_value, "%d", value);
ps_line->value = value;
fwrite(&c_value, sizeof(char), 1, p_gpio_value);
fclose(p_gpio_value);
}
else{
printf("Wrong access.\n");
exit(1);
}
return 0;
}
/* ****************************************** */
/* GET_GPIO_LINE */
/* Gets value of a GPIO line */
/* ****************************************** */
int get_gpio_line(S_GPIO_LINE *ps_line)
{
FILE *p_gpio_value;
char gpio_value[35];
int value = 0;
if( 1 )
{
sprintf(gpio_value, "/sys/class/gpio/pio%s/value", ps_line->id_line);
printf("***");
/* Getting value */
if ((p_gpio_value = fopen(gpio_value, "r")) == NULL)
{
printf("Cannot open value file.\n");
exit(1);
}
value = fgetc (p_gpio_value) - 48;
fclose(p_gpio_value);
}
else
{
printf("Wrong access.\n");
exit(1);
}
return value;
}
Exemple1 : clignotement d’une LED

void main(){

11
S_GPIO_LINE LED ;
LED. id_pin=37; //On travaille avec la led de pin J7.10 dont l’identifiant
est 37
Sprintf(LEd. id_line,”B1”);
load_gpio_line(&LED); //active le pin J7.10
set_gpio_direction(&LED,0); //definer le pin comme sortie
while(1) //une boucle infinite
{
set_gpio_line(&LED,1); //allumer la led
sleep(1);
set_gpio_line(&LED,0); //etteindre la led
sleep(1);
}
}

Exemple2 : chenillard
Void main(){
S_GPIO_LINE LED [4]; //en fait un chenillard de 4 leds
Int i ;
LED[0]. id_pin=37; //on utilise le pin J7.10
Sprintf(LED[0]. id_line,”B1”);
LED[1]. id_pin=28; //on utilise le pin J7.35
Sprintf(LED[1]. id_line,”A28”);
LED[2]. id_pin=27; //on utilise le pin J7.36
Sprintf(LED[2]. id_line,”A27”);
LED[3]. id_pin=26; //on utilise le pin J7.37
Sprintf(LED[3]. id_line,”A26”);

for(i=0;i<4;i++) {
load_gpio_line(&LED[i]); // on active les 4 pins
set_gpio_direction(&LED[i],0); } //definer les 4 pin comme sorties leds
while(1) //une boucle infinite
{
for(i=0;i<4;i++){
set_gpio_line(&LED[i],1); //a chaque fois on allume une seul led
sleep(1);
set_gpio_line(&LED[i],0); //etteindre la led
sleep(1);}
}
}

12
Exemple 3 : compteur et chenillard controlé par un switch
Void main(){
S_GPIO_LINE A ; //on utilise 4 pin pour afficheur 7 segments
S_GPIO_LINE B ;
S_GPIO_LINE C ;
S_GPIO_LINE D ;
S_GPIO_LINE LED[4]; //on utilise 4 LED pour le chenillard
S_GPIO_LINE SW ; //on utilise un switch

A. id_pin=37; //on utilise le pin J7.10


Sprintf(LED[0]. id_line,”B1”); //on active la ligne pioB1
load_gpio_line(&A); // on active le 1er pin
set_gpio_direction(&A,0); //on configure le pin J7.10 en sortie

B. id_pin=28; //on utilise le pin J7.35


Sprintf(B id_line,”A28”); //on active la ligne pioA28
load_gpio_line(&B); // on active le 2eme pin
set_gpio_direction(&B,0); //on configure le pin J7.35 en sortie

C id_pin=27; //on utilise le pin J7.36


Sprintf(C. id_line,”A27”); //on active la ligne pioA28
load_gpio_line(&C); // on active le 3eme pin
set_gpio_direction(&C,0); //on configure le pin J7.36 en sortie

D. id_pin=26; //on utilise le pin J7.37


sprintf(D.id_line,”A26”);
load_gpio_line(&D); // on active le 4eme pin
set_gpio_direction(&D,0); //on configure le pin J7.37 en sortie

LED[0].id_pin=45 //on utilise le pin J6.15


sprintf(LED[0].id_line,”B13”);

LED[0].id_pin=44 //on utilise le pin J6.16


sprintf(LED[0].id_line,”B12”);

LED[0].id_pin=53 //on utilise le pin J6.17

13
sprintf(LED[1].id_line,”B21”);

LED[3].id_pin=52 //on utilise le pin J6.18


sprintf(LED[3].id_line,”B20”);

int I;
for(i=0;i<4;i++){
load_gpio_line(&LED[i]); // on active le 3eme pin
set_gpio_direction(&LED[i],0); // configuration en sortie
}

while(1) //une boucle infinite


{
if(get_gpio_line(&SW)==0) {
for(i=0;i<4;i++){
set_gpio_line(&LED[i],1); //a chaque fois on allume une seul led
sleep(1);
set_gpio_line(&LED[i],0); //etteindre la led
sleep(1);}
}
else if(get_gpio_line(&SW)==1)
{ //si le switch est préssee on fait le comptage
set_gpio_line(&A,0);
set_gpio_line(&B,0);
set_gpio_line(&C,0);
set_gpio_line(&D,1);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,0);
set_gpio_line(&C,1);
set_gpio_line(&D,0);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,0);
set_gpio_line(&C,1);
set_gpio_line(&D,1);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,1);

14
set_gpio_line(&C,0);
set_gpio_line(&D,0);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,0);
set_gpio_line(&D,1);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,1);
set_gpio_line(&D,0);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,1);
set_gpio_line(&D,1);
sleep(1);

set_gpio_line(&A,1);
set_gpio_line(&B,0);
set_gpio_line(&C,0);
set_gpio_line(&D,0);
sleep(1);

set_gpio_line(&A,1);
set_gpio_line(&B,0);
set_gpio_line(&C,0);
set_gpio_line(&D,1);
sleep(1);

set_gpio_line(&A,1);
set_gpio_line(&B,0);
set_gpio_line(&C,1);
set_gpio_line(&D,0);
sleep(1); }
} //Fin while(1)
} //Fin de main()

15
Exemple 3 : compteur et décompteur controlé par un switch
Void main(){
S_GPIO_LINE A ; //on utilise 4 pin pour afficheur 7 segments
S_GPIO_LINE B ;
S_GPIO_LINE C ;
S_GPIO_LINE D ;
S_GPIO_LINE LED[4]; //on utilise 4 LED pour le chenillard
S_GPIO_LINE SW ; //on utilise un switch

A. id_pin=37; //on utilise le pin J7.10


Sprintf(LED[0]. id_line,”B1”); //on active la ligne pioB1
load_gpio_line(&A); // on active le 1er pin
set_gpio_direction(&A,0); //on configure le pin J7.10 en sortie

B. id_pin=28; //on utilise le pin J7.35


Sprintf(B id_line,”A28”); //on active la ligne pioA28
load_gpio_line(&B); // on active le 2eme pin
set_gpio_direction(&B,0); //on configure le pin J7.35 en sortie

C id_pin=27; //on utilise le pin J7.36


Sprintf(C. id_line,”A27”); //on active la ligne pioA28
load_gpio_line(&C); // on active le 3eme pin
set_gpio_direction(&C,0); //on configure le pin J7.36 en sortie

D. id_pin=26; //on utilise le pin J7.37


sprintf(D.id_line,”A26”);
load_gpio_line(&D); // on active le 4eme pin
set_gpio_direction(&D,0); //on configure le pin J7.37 en sortie

while(1) //une boucle infinite


{
if(get_gpio_line(&SW)==0) {
{ //si le switch est non préssee on fait le comptage
set_gpio_line(&A,0);
set_gpio_line(&B,0);
set_gpio_line(&C,0);

16
set_gpio_line(&D,1);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,0);
set_gpio_line(&C,1);
set_gpio_line(&D,0);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,0);
set_gpio_line(&C,1);
set_gpio_line(&D,1);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,0);
set_gpio_line(&D,0);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,0);
set_gpio_line(&D,1);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,1);
set_gpio_line(&D,0);
sleep(1);
set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,1);
set_gpio_line(&D,1);
sleep(1);

set_gpio_line(&A,1);
set_gpio_line(&B,0);
set_gpio_line(&C,0);
set_gpio_line(&D,0);
sleep(1);

set_gpio_line(&A,1);

17
set_gpio_line(&B,0);
set_gpio_line(&C,0);
set_gpio_line(&D,1);
sleep(1);

set_gpio_line(&A,1);
set_gpio_line(&B,0);
set_gpio_line(&C,1);
set_gpio_line(&D,0);
sleep(1); }
else if(get_gpio_line(&SW)==1){
set_gpio_line(&A,1);
set_gpio_line(&B,0);
set_gpio_line(&C,1);
set_gpio_line(&D,0);
sleep(1);

set_gpio_line(&A,1);
set_gpio_line(&B,0);
set_gpio_line(&C,0);
set_gpio_line(&D,1);
sleep(1);

set_gpio_line(&A,1);
set_gpio_line(&B,0);
set_gpio_line(&C,0);
set_gpio_line(&D,0);
sleep(1);

set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,1);
set_gpio_line(&D,1);
sleep(1);

set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,1);
set_gpio_line(&D,0);
sleep(1);

18
set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,0);
set_gpio_line(&D,1);
sleep(1);

set_gpio_line(&A,0);
set_gpio_line(&B,1);
set_gpio_line(&C,0);
set_gpio_line(&D,0);
sleep(1);

set_gpio_line(&A,0);
set_gpio_line(&B,0);
set_gpio_line(&C,1);
set_gpio_line(&D,1);
sleep(1);

set_gpio_line(&A,0);
set_gpio_line(&B,0);
set_gpio_line(&C,1);
set_gpio_line(&D,0);
sleep(1);

set_gpio_line(&A,0);
set_gpio_line(&B,0);
set_gpio_line(&C,0);
set_gpio_line(&D,1);
sleep(1);

set_gpio_line(&A,0);
set_gpio_line(&B,0);
set_gpio_line(&C,0);
set_gpio_line(&D,0);
sleep(1); }
} //Fin while(1)
} //Fin de main()

19
20

Vous aimerez peut-être aussi