Département : Génie éléctrique

Fillière : Cycle d’Ingénieur d’état (‘’ Systèmes Intélligents et

Communicants et Mobiles – SICOM ‘’)

Rapport du TravauxPratiques

- TP -

Informatique Embarqué

Réalisé par :

Abdessamad bendaoud
Ayoub Fillali
Mohammed Azzimani

Encadré par :

Pr. Aicha AlamiHassani

Introduction
L’objectif du TP « Système Embarqués » est de s’initier au système
embarqué en général en utilisons
la Fox G20 une carte embarqué tournant sous Linux avec processeur ARM
cette carte propose une
multitude d’avantage dont la multitude de langages de programmations
supporter : C, C++, Python,
Shell...
A la fin de ce TP nous serons capables de :
* 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 la carte Fox G20 :

Les caractéristiques de la carte Fox G20
La carte Fox G20 :
Intègre un processeur ARM9 AT91SAM9G20
à 400 MHZ
Processeur ARM9 AT91SAM9G20 :
Microcontrôleur RISC 32 bits hautes performances

- Horloge jusqu’à 400MHZ

- Extensions d'instructions DSP
- Cache de données de 32 Ko
- Cache d'instruction de 32 Ko
- ROM de 64 Ko
- SRAM de 32 Ko
- Port de périphérique pleine vitesse USB 2.0, hôte double et port USB 2.0, Ethernet
MAC
10/100 Base T, interface de bus externe, Interface de capteur d'image, matrice de bus,
contrôleur de système, contrôleur de réinitialisation, contrôleur d'arrêt, générateur
d'horloge, contrôleur de gestion de l'alimentation , Contrôleur d'interruption avancé,
Unité
de mise au point, Minuterie d'intervalle périodique, Minuteur de surveillance,
Minuteur en
temps réel, Convertisseur AD à 4 canaux 10 bits, Trois contrôleurs PIO 32 bits,
Contrôleur
DMA périphérique à 24 canaux, Interface de carte multimédia à deux emplacements,
SSC , 4
* USART, 2 * UART à deux fils, 2 * SPI, deux minuteries / compteurs 16 bits à 3
canaux, TWI,
Balayage de frontière JTAG IEEE 1149.1, broches 96 E / S.

Configuration de la carte FOXG20 :

Puisque la FOX G20 n’a qu’un ROM de 64 Ko insuffisant pour contenir le noyau
linux donc utilisation de stockage externe est obligatoire. Donc la mémoire flash
exécute le Rom Boot. Ce firmware est stocké dans le processeur son rôle est de
chercher un code exécutable dans la partition boot de de la micro_SD.

Partitionement de la carte microSD :

D’après le logiciel open source de gestion de disc (GPARTED) qui assura le
partitionnement de la carte microSD.
On a réalisé deux partitions , la première en FAT16 de 128Mo qui
accueillera le boot du système et la deuxième partie ext3 de 512Mo
Configuration du Kernel et du FS :

On a décompacté les archive du Kernel et du FS 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

L’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 :

Pour relier les deux en utilise la

structure suivante :

FTDI GND <-> fox GND

FTDI RX <-> Fox TX
FTDI TX <-> Fox RX

Configuration de l’IP adresse :

Après le boot On se connecte à la carte :

Login : root
Password : netusg20
- On utilise la commande suivante pour afficher l’état de eth0 :
$ 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 ).

Programmation en ligne de commandes shell:

Réglage de la date et de l’heure
La commande qui permet d’afficher ou modifier la date est la
commande :
$ date

Le rôle de la pile :

Si on tape la commande précédente sur une carte qui ne contient pas une
pile, on aura la date de
réalisation du kernel sur lequel elle fonctionne et même si on modifie la
date et l’heure, une fois que
la carte est redémarré elle ne va pas conserver la nouvelle date et la
commande ($date) va toujours
afficher la date de réalisation du kernel.
La solution c’est d’utiliser la plie qui a pour rôle d’alimenté la carte avec
une très faible tension pour
que le compteur de la date et l’heure ne s’arrête jamais même si la carte
est éteinte.
- Modification du date et heure :
Pour modifier la date et l’heure il suffit d’ajouter l’option –S à la
commande ($date) puis la date
qu’on veut saisir :
Exemple :

$ date –S '17 12 2018 01 :21 :33’

Pour fixer la date et l’heure à l’heure internationale de référence :
6
$ hwclock –systohc—utc
Pour fixer la date et l’heure à l’heure local :
$ hwclock –systohc—localtime

Utilisation des GPIO

La carte FOX G20 contient 28 ports GPIO est chaque port est caractériser par :
- Le connecteur (J6 ou J7)
- La broche (la position sur la carte)
- Le pin ID
- Le nom de la ligne (exemple PA6)
Le systèmes 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 22 : j6.37
# echo 22 >/sys/class/gpio/export (activation de la ligne)
( écrire « out » dans le fichier direction pour que la
# echo out >/sys/class/gpio/pioA22/Direction
Ligne sera considérer comme une sortie)
. (définir la ligne à l’état haut pour allumer la led)
# echo 1 >/sys/class/gpio/pioA22/value
Exemple 2 : configuration d’un switch
On utilise la ligne 11 : j6.38
#echo 11 > / sys / class / gpio / export
#echo IN > /sys / class / gpio / pioA11 / 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
switch est dans l’état bas)
# cat /sys/class/gpio/pioA11/value

Exemple3 : clignotement d’une LED

Pour réaliser cet exemple on doit écrire un programme Shell :
Pour écrire ce programme o doit ouvrir un éditeur de texte par exemple (nano)
par la commande :
# nano ‘nom_du_programme’
Une fois que l’éditeur de texte est ouvert on écrit notre code :
Echo 22 >/sys/class/gpio/export ( définition de la ligne 22 comme une sortie)
Echo out >/sys/class/gpio/pioA22/Direction
I=0

While ($i eq 0)
(boucle infinie pour rester toujours dans le programme)
Do
Echo 1 >/sys/class/gpio/pioA22/value
(allumer la LED)
Sleep(1)

Echo 0 >/sys/class/gpio/pioA22/value (Etteindre la LED)

Sleep (1)
Done
Et on doit enregistrer le programme sous l’extension ‘.sh’ : exmple3.sh
Puis on donne à notre script les droits d’exécution par la commande :
# chmod +x exemple3.sh
Et finalement on lance notre programme avec la commande :
./exemple3.sh
Exemple4 : LED Contrôlée par un Switch

On ouvre l’éditeur de texte nano pour écrire un nouveau script :

SWITCH)
Echo IN >/sys/class/gpio/pioA11/direction
I=0
Fi
Done
On sauvegarde ce programme sous le nom exemple4.sh
On le donne les droits d’exécution
# chmod +x exemple4.sh
Puis on lance notre script
# ./exemple4.sh
Echo 22 >/sys/class/gpio/export
Echo out ( définition de la ligne 22 comme une sortie LED)
>/sys/class/gpio/pioA22/Direction ( définition de la ligne 11 comme entrée )
Echo 11 >/sys/class/gpio/export

While ($i eq 0)
Do
A=$(< /sys/class/gpio/pioA11/value)
(boucle infinie pour rester toujours dans le
If [A eq 1]; then
programme)
Echo 1 >/sys/class/gpio/pioA22/value
Elif [A eq 0]; then
Echo 0 >/sys/class/gpio/pioA22/value

( une variable qui prends l’état du switch)

(allumer la LED)

(Etteindre la LED)
Programmation en C:

Utilisation des GPIO

La programmation en C pour le linux nécessite une bonne gestion des fichiers parce que
pour Linux tout est fichiers les ports GPIO sont aussi considérer comme des fichiers alors
pour faire cette coordination entre la programmation c et les fichiers sur linux on aura
besoin des drivers qui sont des fonctions sur C permettant d’écrire et de lire les valeurs
qui se trouvent dans les fichiers (value et direction) de chaque pin.

Driver utilisé :

#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;
/* ************ */
/* 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 */
/* ************** */
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);
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;
}
//compteur /décompteur commandé

void main(){

Int i,C[10][4]={{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1}
,{1,0,0,0},{1,0,0,1}};

S_GPIO_LINE S[4],E;
S[0].id_pin=50;
sprintf(S[0].id_line,"B18");
S[1].id_pin=51;
sprintf(S[1].id_line,"B19");
S[2].id_pin=50;
sprintf(S[2].id_line,"B16");
S[3].id_pin=50;
sprintf(S[3].id_line,"B17");

for(i=0;i<4;i++){
load_gpio_line(&S[i]);
set_gpio_direction(&S[i],0);
}
E.id_pin=11;
sprintf(E.id_line,"A11");
load_gpio_line(&E);
set_gpio_direction(&E,1);

while(1){
for(i=0;i<10;i=i){
set_gpio_line(&S[3],C[i][0]); // S : 0 1 2 3
set_gpio_line(&S[2],C[i][1]);
set_gpio_line(&S[1],C[i][2]);
set_gpio_line(&S[0],C[i][3]);
sleep(1);
if(get_gpio_line(&E)==0) i++; else { i--;if(i<0) i=9; }
}
}}
//shin 1 voie
void main(){
int i;
S_GPIO_LINE S[8],E;
S[0].id_pin=50;
sprintf(S[0].id_line,"B18");
S[1].id_pin=51;
sprintf(S[1].id_line,"B19");
S[2].id_pin=48;
sprintf(S[2].id_line,"B16");
S[3].id_pin=49;
sprintf(S[3].id_line,"B17");

S[4].id_pin=34;
sprintf(S[4].id_line,"B2");
S[5].id_pin=35;
sprintf(S[5].id_line,"B3");
S[6].id_pin=32;
sprintf(S[6].id_line,"B0");
S[7].id_pin=33;
sprintf(S[7].id_line,"B1");

for(i=0;i<8;i++){
load_gpio_line(&S[i]);
set_gpio_direction(&S[i],0);
}
E.id_pin=11;
sprintf(E.id_line,"A11");
load_gpio_line(&E);
set_gpio_direction(&E,1);

while(1){
for(i=0;i<8;i++){
set_gpio_line(&S[i],1); // S : 0 1 2 3 4 5 6 7
sleep(1);
set_gpio_line(&S[i],0);
}
}
}}
//shin 2 voie
void main(){
int i;
S_GPIO_LINE S[8],E;
S[0].id_pin=50;
sprintf(S[0].id_line,"B18");
S[1].id_pin=51;
sprintf(S[1].id_line,"B19");
S[2].id_pin=48;
sprintf(S[2].id_line,"B16");
S[3].id_pin=49;
sprintf(S[3].id_line,"B17");

S[4].id_pin=34;
sprintf(S[4].id_line,"B2");
S[5].id_pin=35;
sprintf(S[5].id_line,"B3");
S[6].id_pin=32;
sprintf(S[6].id_line,"B0");
S[7].id_pin=33;
sprintf(S[7].id_line,"B1");

for(i=0;i<8;i++){
load_gpio_line(&S[i]);
set_gpio_direction(&S[i],0);
}
E.id_pin=11;
sprintf(E.id_line,"A11");
load_gpio_line(&E);
set_gpio_direction(&E,1);

while(1){
for(i=0;i<8;i=i){
set_gpio_line(&S[i],1); // S : 0 1 2 3 4 5 6 7
sleep(1);
set_gpio_line(&S[i],0);
if(get_gpio_line(&E)==0) i++; else { i--;if(i<0) i=8; }
}
}}
//Allumer une LED
// (declaration d’une structure LED)
int main() { S_GPIO_LINE LED;
LED.id_pin=11; //(on utilise la ligne 11 , A11)
sprintf(LED.id_line, "A11");
load_gpio_line(&LED); //( Activation de la ligne)
//(declaration comme sortie)
set_gpio_direction(&LED, OUT); // (boucle infinie
pour ne pas sortir du programme )
while(1)
{
set_gpio_line(&LED, 1); //(Allumer)
sleep(1);
set_gpio_line(&LED, 0);
//( Etteindre)
sleep(1);
}
return 0;
}
//LED contrôlé par un switch

int main() {
//configuration de LED
S_GPIO_LINE LED;
LED.id_pin=11;
sprintf(LED.id_line, "A11"); //(LED est configuré sur la ligne A11)
load_gpio_line(&LED);
set_gpio_direction(&LED, 0);
//configuration PIN Switch
S_GPIO_LINE switx;
switx.id_pin=22;
sprintf(switx.id_line, "A22");
load_gpio_line(&switx); //(Switch est configuré sur la ligne A22)
set_gpio_direction(&switx, 1);
while(1){
if(get_gpio_line(&switx)==1) //( si le Switch est dans l’état haut alors
allumer la LED)
set_gpio_line(&LED, 1);
else;
set_gpio_line(&LED, 0);} //(sinon étteindre )
return 0;
}
Après la réalisation des programmes il faut les
exécuter dans la carte ceci par les étapes suivantes :

On sauvegarde notre programme sous l’extension .c

- Une fois qu’on est dans le chemin qui contient notre fichier .c on doit le
compiler avec le compilateur gcc par la commande :
# gcc programme.c –o programme
L’option –o c’est pour passer directement à l’Edition de lien pour générer le fichier
programme.exe

On execute le programme sur la carte avec la

commande :
# ./programme.exe

On trouve le chemin du fichier .c :

# cd /var/Codiad/workspace/...