Travaux Pratiques: Linux

embarqué

Réalisés par :

Noureddine ALOUI, aloui.noureddine@gmail.com

Mustapha TOUZRI, touzri.mustapha@gmail.com

Adnen CHERIF, adnen adnane.cherif@fst.utm.tn

1
Sommaire
TP0 : Prise en main de la carte Raspberry PI .................................................................................... 4
1. Objectifs ...................................................................................................................................... 4
2. Introduction ................................................................................................................................. 4
3. Applications................................................................................................................................. 5
3.1. Création de l’image de système d’exploitation et premier boot .......................................... 5
3.2. Manipulation des commandes Linux sous Raspberry PI. .................................................... 6
3.3. Programmation Python avec la carte Raspberry PI. ........................................................... 7
TP1 : Contrôle des broches GPIO de la carte Raspberry PI............................................................. 8
1. Objectifs ...................................................................................................................................... 8
2. Introduction ................................................................................................................................. 8
3. Applications................................................................................................................................. 9
3.1. Contrôle des GPIO avec le langage Python....................................................................... 10
3.2. Contrôle des GPIO avec le langage C ............................................................................... 11
TP2 : Manipulation d’un protocole de communication sur un bus unifilaire. .............................. 13
1. Objectifs .................................................................................................................................... 13
2. Introduction ............................................................................................................................... 13
2.1. Le capteur AM2302 ........................................................................................................... 13
2.2. Protocole de communication ............................................................................................. 14
3. Applications............................................................................................................................... 16
3.1. Programmation avec le langage Python ............................................................................ 16
3.2. Programmation avec le langage C ..................................................................................... 16
TP3 : La carte Raspberry PI et la communication série............................ Erreur ! Signet non défini.
1. Objectifs .............................................................................................. Erreur ! Signet non défini.
2. Introduction ......................................................................................... Erreur ! Signet non défini.
3. Applications......................................................................................... Erreur ! Signet non défini.
3.3. Communication série unidirectionnelle Arduino vers Raspberry PiErreur ! Signet non défini.
3.4. Communication série unidirectionnelle Raspberry Pi vers ArduinoErreur ! Signet non défini.
3.5. Interface graphique de gestion de communication série.............. Erreur ! Signet non défini.
TP4 : Implémentation d’un serveur WEB embarqué sous la carte Raspberry PIErreur ! Signet non défini.
1. Objectifs .............................................................................................. Erreur ! Signet non défini.
2. Introduction ......................................................................................... Erreur ! Signet non défini.
3. Applications......................................................................................... Erreur ! Signet non défini.
3.1. Contrôle des GPIO avec un navigateur WEB.............................. Erreur ! Signet non défini.

2
 3.2. Manipulation des capteurs avec un navigateur WEB .................. Erreur ! Signet non défini.
Liste des références ....................................................................................... Erreur ! Signet non défini.

3
TP0 : Prise en main de la carte Raspberry PI

1. Objectifs
 Installation du système d’exploitation libre Raspberry PI OS sur la carte Micro-SD.
 Configuration de l’adresse IP et activation de service SSH avec le logiciel Putty.
 Configuration du serveur VNC et accès au bureau Raspberry PI OS.
 Manipulation de quelques commandes Linux.
 Programmation Python sous Raspberry PI OS.

2. Introduction

La carte Raspberry Pi est un « nano-ordinateur » à base d’un processeur ARM, conçu

par des professeurs du département informatique de l'université de Cambridge. Il est
destiné à des applications d’informatique embarquée [1].

Figure 1. La carte Raspberry PI 4.

4
La Raspberry Pi 4 B est une carte de la taille d'une carte de crédit. Il possède les
spécifications techniques suivantes [2][3][4]:
 Processeur: Broadcom BCM2711, Quad core Cortex-A72 (ARM v8) 64-bit SoC@
1.5GHz.
 Mémoire vive: 2GB, 4GB ou 8GB LPDDR4-3200 SDRAM (dépend du modèle)
 Connectivité WIFI : 2.4 GHz et 5.0 GHz IEEE 802.11
 Connectivité : Bluetooth: 5.0
 Port Ethernet: Gigabit
 Ports USB: 2 USB 3.0 et 2 USB 2.0.
 Ports d’entré sortie: 40 pins GPIO.
 Sortie HDMI: 2 × micro-HDMI ports (support jusqu’à 4kp60)
 Interface série d'affichage (DSI) MIPI (Mobile Industry Processor Interface): 2
voies.
 Interface série pour caméra (6CSI) MIPI: 2 voies.
 Port audio stéréo : 4 pôles.
 H.265 (décodeur 4kp60), H264 (décodeur 1080p60, encodeur 1080p30)
 Carte mémoire: Micro-SD pour le système d’exploitation et le stockage de
données.
 Alimentation: 5V DC via le connecteur USB-C (minimum 3A).
 Alimentation: 5V DC via GPIO (minimum 3A).

3. Applications

3.1. Création de l’image de système d’exploitation et premier boot

Dans un premier temps, il est nécessaire de télécharger une image de système

d’exploitation compatible avec Raspberry PI 4 B et de l’écrire sur une carte mémoire
Micro-SD. Cette carte sera ensuite le disque de démarrage de la carte Raspberry Pi.
a) Télécharger un système d’exploitation compatible avec la carte Raspberry depuis
le site web officiel [6].
b) Formater la carte Micro-SD et créer un système d’exploitation bootable.
c) Donner une adresse APIPA (Automatic Private Internet Protocol Addressing) fixe
à la Raspberry Pi fixe.

5
d) Insérer la carte Micro-SD dans l’emplacement sur la carte Raspberry Pi et brancher
le clavier, la souris et l’alimentation. La carte doit booter sur le système
d’exploitation.
e) Télécharger et installer le logiciel PUTTY depuis le site officiel, pour configurer la
carte Raspberry PI [8].
f) Activer le serveur VNC (Virtual Network Computing) :
 Authentifier pour connecter : Login : pi et mot de passe : raspberry.
 Configurer le système du Raspberry PI en tapant la commande : sudo raspi-
config.

g) Télécharger et installer le logiciel VNC Viewer (un client VNC) depuis le site web
officiel [7].
h) Utiliser le logiciel VNC pour contrôler la carte Raspberry PI.

3.2. Manipulation des commandes Linux sous Raspberry PI.

a) Utiliser la commande mkdir (make directory) pour créer un répertoire nommé
UnixTIC2 sur le bureau de la carte Raspberry PI.
b) Utiliser la commande cd qui permet de changer le répertoire courant pour créer
l’arborescence ci-dessous dans le répertoire UnixTIC2.

UnixTIC2

2021 2022 2023

TPUnix

c) Créer un fichier « TP1.txt » sous le répertoire TPUnix en utilisant la commande

touch suivie du nom du fichier
d) Déplacer le dossier UnixTIC2 vers 2023 en utilisant la commande mv (move).
e) Supprimer le répertoire 2023 en utilisant la commande rm(remove) .
f) Renommer les répertoires 2021 et 2022 par Groupe1 et Groupe2 (utiliser la
commande mv).
g) Utiliser la commande pwd (print working directory) pour afficher le chemin
d'accès vers le répertoire où se situe l'utilisateur qui a entré la commande.
h) Utiliser la commande ls pour afficher le contenue de bureau.
i) Tester autres commandes de choix.

6
3.3. Programmation Python avec la carte Raspberry PI.
a) Lancer Python sous le système d’exploitation de Raspberry PI.
b) Ecrire un programme Python qui permet d’afficher le message « Bonjour
FST » cinq fois.
c) Développer une application de choix avec Python.

7
TP1 : Contrôle des broches GPIO de la carte
Raspberry PI

1. Objectifs

 Etre capable de contrôler les GPIO de la carte Raspberry PI par les langages de
programmation Python et C.
 Savoir installer et utiliser une bibliothèque sous Raspberry PI OS.

2. Introduction

Les GPIO (General Purpose Input/Output ou Entrées/Sorties pour un usage générique)

permet à l’utilisateur de la carte Raspberry PI d’utiliser les entrées-sorties, les
interfaces de communications (UART, I2C, SPI, PWM) et l’alimentation [4].
La carte Raspberry PI possède 40 broches dont 2 broches 5V et deux broches 3.3V,
ainsi qu’un certain nombre de broches de masse 0V.
Une broche GPIO en sortie peut fournir une valeur haute de 3.3V ou une valeur basse
0V, de même une broche GPIO en entrée peut être lue comme haute 3.3V ou basse
0V.

Figure 2. Broches GPIO de la carte Raspberry PI 4.

8
 Figure 3. Spécifications techniques des broches GPIO de la carte Raspberry PI 4.

Remarque : les broches physiques 27 et 28 (ID_SD et ID_SC) de la carte Raspberry

PI sont réservées à l’accès à la mémoire EEPROM (Electrically Erasable
Programmable Read Only Memory), donc il est déconseillé de les utilisées.

3. Applications
Matériel Utilisé :
 Carte Raspberry PI.
 Une diode LED.
 Une résistance de 68_300 Ω pour la LED.
 Une plaque d'essai
 Des câbles “jumper wire”.

9
 Figure 4. Schéma de câblage de la carte Raspberry PI 4.

3.1. Contrôle des GPIO avec le langage Python

 Compilation et exécution avec l’IDE Thonny Python IDE

a) Lancer le logiciel Thonny Python IDE et créer un fichier « TestGPIO.py ».
b) Ecrire un programme qui permet de clignoter une diode LED connectée sur la
broche numéro 4 BCM (numérotation Broadcom) en suivant les étapes suivantes :
1) Importer les bibliothèques GPIO et time :
from RPi import GPIO
import time
2) Utiliser la numérotation BCM :
GPIO.setmode(GPIO.BCM)
3) Activer le pin 4 en sortie :
GPIO.setup(pin, GPIO.OUT)
4) Utiliser la fonction :
GPIO.output(pin, GPIO.HIGH/GPIO.LOW) #0/1 ou
true/flse
pour définir une broche de sortie sur HIGH ou LOW.
5) Définir la vitesse de clignotement en secondes:
time.sleep(secondes)
c) Exécuter le programme (Run)
d) Déboguer le programme pour observer et contrôler l'exécution (Debug).

10
  Compilation et exécution avec les lignes de commande
a) Créer un nouveau fichier « Blink.py » sur le bureau de Raspberry PI OS.
b) Réécrire le programme de clignotement d’une diode LED avec le langage Python.
c) Enregistrer le programme et fermer le fichier « Blink.py ».
d) Lancer l’environnement d’exécution de commandes « Terminal ».
e) Compiler et exécuter le programme en utilisant la commande suivante :
sudo python Blink.py

3.2. Contrôle des GPIO avec le langage C

WiringPi est une bibliothèque écrite en C, conçue pour ressembler le langage

Arduino. Elle contient les routines les plus utiles qui permettent l’accès aux
périphériques les plus utilisés de la carte Raspberry PI.

a) Télécharger une version récente de la bibliothèque wiringpi

b) Utiliser l’outil de bas niveau dpkg (Debian package) avec l'option -i, ou --install,
pour installer la bibliothèque.
sudo dpkg -i
c) Utiliser la commande :
 gpio –v : pour vérifier l’installation de la bibliothèque wiringpi
 gpio readall : pour obtenir un aperçu complet de toutes les broches E/S
disponibles sur votre carte Pi.

Compilation et exécution avec l’IDE Geany

a) Démarrer l’IDE Geany

b) Ecrire un programme qui permet de clignoter une diode LED connectée sur la
broche numéro 7 physique en suivant les étapes suivantes :
1) Créer un nouveau fichier « TestGPIO.c » sous Geany.
2) Au début du programme C, inclure la bibliothèque wiringPi :
#include <wiringPi.h>
3) Initialiser la bibliothèque wiringPi en utilisant l’un de ces appels :
wiringPiSetup();
wiringPiSetupGpio();
wiringPiSetupPhys () ;
wiringPiSetupSys () ;

11
 4) Définir la broche comme sortie, en utilisant la fonction :
pinMode(pin, OUTPUT) ;
5) Utiliser la fonction :
digitalWrite(pin, HIGH/LOW) ;
pour définir une broche de sortie sur HIGH ou LOW.
6) Définir une vitesse de clignotement en utilisant les fonctions :
delay(milliseconds) ;
delayMicroseconds(microseconds) ;
c) Compiler (F9) et exécuter le programme (F5).

Compilation et exécution avec les lignes de commande

a) Créer un nouveau fichier « Blink.c » sur le bureau de Raspberry PI OS.

b) Réécrire le programme de clignotement d’une diode LED en langage C.
c) Enregistrer le programme et fermer le fichier « Blink.c ».
d) Lancer l’environnement d’exécution de commandes « Terminal ».
e) Compiler le programme en utilisant la commande suivante :
gcc Blink.c -o Blinkout –lwiringPi
f) Exécuter le fichier générer en utilisant la commande suivante :
sudo ./Blinkout

12
TP2 : Manipulation d’un protocole de
communication sur un bus unifilaire.

1. Objectifs
 Comprendre le principe de fonctionnement d’un protocole de communication sur
un bus unifilaire.
 Etre capable d’acquérir et d’afficher des données de capteurs numérique avec la
carte Raspberry PI en utilisant les langages de programmation Python et C.

2. Introduction

Les cartes Raspberry PI ne disposent pas des entrées analogiques (des convertisseurs
analogique/numérique « ADC»), il est par conséquent impossible de mesurer la valeur
d’une résistance ou d’un courant directement.
Pour acquérir des données de capteurs il faut insérer une interface entre la Raspberry
PI et les capteurs analogiques ou bien utiliser des capteurs numériques qui permettent
de lire directement des valeurs numériques.
Dans ce TP on va utiliser le capteur numérique DHT22 pour mesurer la température et
l'humidité de l'air ambiant.

2.1. Le capteur AM2302

Le capteur de température et d'humidité DHT22 (AM2302) permet de mesurer des

températures de -40°C à +125°C et des taux d'humidité entre 0 et 100%. Le tableau
suivant résume les principales caractéristiques du capteur DHT22 [5].

Tableau 1. Caractéristiques techniques du capteur DHT22.

Humidité (relative %) 0 ~ 100 %

Précision d’humidité +/- 2% (+/- 5% aux extrêmes)
Température -40 ~ +150°C
Précision de +/- 0.5°C
température
Fréquence mesure max 2Hz (2 mesures par seconde)
Tension d'alimentation de 3 à 5 volts
Stabilité à long terme +/- 0.5% par an

13
 Figure 5. Schéma de câblage du capteur DHT22.

2.2. Protocole de communication

Le capteur DHT22 communique avec la carte Rapberry PI via une seule broche
d'entrée/sortie et permet de réaliser des mesures deux fois par seconde. Il utilise son
propre protocole de communication de type unifilaire; un seul fil est utilisé pour
émettre et recevoir des données. Ce protocole nécessite des timings très précis. La
figure suivante présente le format de la trame de communication.

Figure 6. Format de la trame du capteur DHT22.

14
Tableau 2. Spécifications du format de trame du capteur DHT22.

Détails du format d'une trame de communication pour le capteur DHT22.

La communication entre la carte Raspberry PI et le capteur DHT22 est réalisée en 3

étapes :
(1) Tout d'abord, le microprocesseur maître de la carte Raspberry PI réveille le
capteur DHT22 en plaçant la ligne de données un niveau BAS (LOW) pendant
au moins 800µs. Durant cette période, le capteur DHT22 se réveille et prépare
des mesures de température et d'humidité. Une fois le temps écoulé, le maître
(microprocesseur) libère la ligne de données et passer en mode écoute.

(2) Ensuite, le capteur DHT22 répond au maître pour montrer qu'il est bien
réveillé en en maintenant la ligne de données au niveau BAS (LOW) pendant
80µs puis un niveau HAUT (HIGH) pendant 80µs.

(3) Enfin, le capteur DHT22 transmet une série binaire de 40 bits (5 octets) vers le
microprocesseur de la carte Raspberry PI; les 16 premiers bits (2 octets)
contiennent la mesure de l'humidité. Les 16 bits suivants (2 octets) contiennent
la mesure de la température et les 8 bits (1 octet) contient une somme de
contrôle (checksum) qui permet de vérifier que les données reçues sont
correctes.
15
3. Applications
Matériel utilisé :

 Carte Raspberry PI.

 Un capteur DHT22.
 03 câbles “jumper wire”.

3.1.Programmation avec le langage Python

a) Télécharger et installer les bibliothèques « Adafruit _DHT »

b) Ecrire un programme en Python qui permet de mesurer et afficher la température
et l'humidité de l'air ambiant chaque 5 secondes en utilisant :
 la bibliothèque :
Adafruit_DHT
 et la fonction :
Temp, Humi= Adafruit_DHT.read(Adafruit_DHT.DHT22,
pin)
c) Commenter chaque ligne du programme développé.

3.2. Programmation avec le langage C

a) Ecrire un programme en C qui permet de mesurer et afficher la température et
l'humidité de l'air ambiant chaque 2 secondes en utilisant la fonction :
void read_dht_data();
b) Commenter chaque ligne du programme développé.

16