Programmation Systèmes

embarqués

Travaux pratiques :
Communication I2C

Réalise par : - Jesser Kramti

- Souhayl tlili
 ❖ Définition de protocole
Le protocole I2C (Inter-Integrated Circuit) est un protocole de communication qui utilise deux
lignes pour envoyer et recevoir des données : une broche d’horloge série (SCL) que la carte
Arduino pulse à intervalles réguliers, et une broche de données série (SDA) sur laquelle les
données sont envoyées entre les deux appareils.

1. Schémas matériels
❖ Connexion I2C entre Raspberry Pi et Arduino
Pour établir une communication I2C entre Raspberry Pi et Arduino, il faut relier
physiquement le bus qui utilise 3 broches. Une communication I2C est définie par un bus de
deux fils (parfois appelé TWI, Two Wire Interface) et une adresse. Les broches utilisées par la
communication I2C sont généralement fixées pour chaque appareil.
- Voici comment les broches sont généralement connectées :
• SDA BCM2 (RPI) <-> SDA A4 (Arduino)
• SCL BCM3 (RPI) <-> SCL A5 (Arduino)
• GND (RPI) <-> GND (Arduino)
C’est un moyen efficace d’échanger des données série entre deux ou plusieurs appareils3. Il
est important de noter que le Raspberry Pi utilise une logique de 3,3 volts, tandis que la
plupart des Arduino (y compris l’Arduino Uno) utilisent une logique de 5 volts. Malgré ces
différences de tension, il est possible d’interfacer les deux appareils.
 2. Configuration du logiciel
❖ Programme maître Raspberry Pi I2C
Le Raspberry Pi n’ouvre pas l’interface I2C par défaut, alors on l’active dans la configuration.
-Installation des Packageq nécessaires :
Sudo apt-get install i2c-tools
Sudo pip3 install smbus2
sudo raspi-config

Recherche de l’option d’interface :

Sélectionnez l’entrée P5 I2C :

Sélectionnez ensuite « OUI » :

 • Code raspberry pi :

From smbus import SMBus

Addr= 0x8
bus.write_byte(addr, 0x1)
input(‘’press return to exit ‘’)
bus.write_byte(addr, 0x0)

• Code Arduino :
Les bibliothèques de fils sont utilisées sur l’Arduino pour la communication IIC. La première chose
à faire est d’inclure le fichier d’en-tête Wire.h.

#include <Wire.h>
#define led 13

void setup()
{ Wire.begin(0x8); // L'adresse de l'esclave est 0x8
Wire.onReceive(receiveEvent);// Fonction de registre, appelée lorsque les données de
l'hôte sont reçues
pinMode(13, OUTPUT);
digitalwrite(13,LOW) ;
}

void loop() {
// Contenu du programme principal
Delay(100) ;}

void receiveEvent(int howMany) {

int x = Wire.read(); // Lecture d'un octet reçu
if (x == 1) { // Si l'octet reçu est 1
digitalWrite(led, HIGH); // Allumer la LED
}
if (x == 0) { // Si l'octet reçu est 0
digitalWrite(led, LOW); // Éteindre la LED
}
}
 Programmation Systèmes
embarqués

Travaux pratiques :
Raspberry Pi
Mesure de distances avec un
capteur HC-SR04
 ❖ Caractéristiques et principe de fonctionnement de capteur
Le capteur à ultrasons HC-SR04 permet de mesurer une distance de 2 à 344cm en envoyant
des signaux sonores à 40 kHz. En fonction du temps qui sépare l'émission de la réception, on
trouve par un calcul la distance. Le capteur est alimenté en +5V.

Un capteur à ultrasons fonctionne en émettant des ondes sonores à une fréquence trop
élevée pour que les humains puissent les entendre. Ces ondes rebondissent sur les objets à
proximité, créant des échos qui sont détectés par le capteur. En analysant le timing et la
fréquence de ces échos, le capteur peut déterminer la distance et l’emplacement de l’objet1.
Voici comment cela fonctionne en détail :
- Le capteur émet une impulsion sonore dans la plage ultrasonique.
- Cette impulsion sonore se propage à la vitesse du son à travers l’air (environ 344
mètres par seconde) jusqu’à ce qu’elle rencontre un objet.
- L’impulsion sonore rebondit sur l’objet et est renvoyée en sens inverse au capteur où
cet “écho” est reçu.
- En mesurant le temps qu’il faut pour que l’impulsion sonore voyage du capteur à
l’objet et retourne au capteur, la distance à l’objet peut être calculée très
précisément.
Ce principe de mesure est également appelé “Time of Flight” ou mesure du temps de transit.
Notez que la température a la plus grande influence sur la vitesse du son. La relation entre la
température et la vitesse du son est presque linéaire. Le son se déplace à travers l’air, le
milieu, à une vitesse de 344 mètres par seconde à une température de 20 degrés.

Prérequis
 1. Branchement du capteur au Raspberry
Le capteur HC-SR04 se connecte donc au Raspberry grâce à 4 PINs : VCC, Trig, Echo et GND.
Pour le connecter, nous aurons besoin de deux résistances : 1KΩ et 2KΩ. Connectez l'HC-
SR04 comme ceci :

Il suffit d'exécuter un script Python pour obtenir la distance calculée entre le

capteur et l'obstacle.
2. Configuration du logiciel
• Code Raspberry pi :

import RPi.GPIO as GPIO

import time

GPIO.setmode(GPIO.BCM)

TRIG = 23
ECHO = 24

GPIO.setup(TRIG,GPIO.OUT)
GPIO.setup(ECHO,GPIO.IN)

GPIO.output(TRIG, False)
print("En attente du capteur pour se stabiliser")
time.sleep(2)

GPIO.output(TRIG, True)
time.sleep(0.00001)
GPIO.output(TRIG, False)

while GPIO.input(ECHO)==0:
pulse_start = time.time()

while GPIO.input(ECHO)==1:
pulse_end = time.time()

pulse_duration = pulse_end - pulse_start

distance = pulse_duration * 17150

distance = round(distance, 2)

print("Distance:",distance,"cm")
 Programmation Systèmes
embarqués

Travaux pratiques :
Raspberry Pi
commande de moteur à
travers un capteur ultrason
HC-SR04
 ❖ Principe de fonctionnement de commande
Pour commander un moteur avec un Raspberry Pi en utilisant un capteur à ultrasons,
vous aurez besoin de deux composants principaux : un capteur à ultrasons et un
contrôleur de moteur.
Voici comment cela fonctionne ensemble :
- Le Raspberry Pi envoie un signal de déclenchement au capteur à ultrasons.
- Le capteur émet une impulsion ultrasonique qui se propage à travers l’air
jusqu’à ce qu’elle rencontre un objet.
- L’impulsion rebondit sur l’objet et est renvoyée au capteur.
- Le capteur envoie cette information au Raspberry Pi, qui calcule la distance à
l’objet.
- En fonction de cette distance, le Raspberry Pi envoie des signaux au contrôleur
de moteur pour contrôler la direction et la vitesse du moteur.

Prérequis
 1. Le branchement avec Raspberry
Brancher un capteur à ultrasons HC-SR04 et un contrôleur de moteur à un Raspberry Pi, vous
pouvez :
• Branchement du capteur à ultrasons HC-SR04.
• Branchement du contrôleur de moteur.
Ces instructions sont assez générales et peuvent nécessiter des ajustements en fonction de
configuration spécifique. Assurer également de manipuler les broches GPIO avec précaution
pour éviter d’endommager votre Raspberry Pi.

Il suffit d'exécuter un script Python pour obtenir une rotation dans les deux
sens a partir de la distance calculée entre le capteur et l'obstacle.
2. Configuration du logiciel
• Code Raspberry pi :

import RPI.GPIO as GPIO

import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(3,GPIO.OUT)
GPIO.setup(7,GPIO.IN)
GPIO.setup(8,GPIO.OUT)
a=GPIO.PWM(8,50)
a.start(0)
GPIO.setup(11,GPIO.OUT)
GPIO.setup(12,GPIO.OUT)
GPIO.output(3,False)

while true:
GPIO.output(3,True)
time.sleep(0.00001)
GPIO.output(3,False) # signale trig
while GPIO.input(7)==0
t1=time.time() # lire le temps jusqu'a echo sera 1
while GPIO.input(7)==1
t2=time.time() # lire le temps jusqu'a echo sera 0

t=(t2-t1)/2 # /2 car t=t2-t1 est le temps d'aller +

retour
d=343*t*100 # d=v*t(par métre) / v: vitesse d'onde
v=343m/s /*100 pour obtenir une resultat par
centimétre
print("la distance =",d)
if (d<10)
GPIO.output(11,True)
GPIO.output(12,False)
a.changeDutyCycle(25) # vitesse de rotation long
else
GPIO.output(11,False)
GPIO.output(12,True)
a.changeDutyCycle(75) # vitesse de rotation rapide