RÉPUBLIQUE ALGÉRIENNE DÉMOCRATIQUE ET POPULAIRE

MINISTÈRE DE L’ENSEIGNEMENT SUPÉRIEUR ET DE LA

RECHERCHE SCIENTIFIQUE
ÉCOLE NATIONALE SUPÉRIEURE D’INFORMATIQUE

2ème Année Cycle Supérieur (2CS)

2022-2023

TP n° 5

Communication Série UART

Réalisé par : Encadré par :

- ZERROUK Ahmed (SIL1) - SEHAD Abdenour

Année universitaire : 2022-2023

1
Table des matières

1 Partie théorique 3
1.1 Etude théorique sur la Communication UART . . . . . . . . . . . . . . . . . 4
1.1.1 UART en général : . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.1.1 Le protocole UART . . . . . . . . . . . . . . . . . . . . . . 4
1.1.2 Branchement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.3 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Etude théorique sur la Communication I2C. . . . . . . . . . . . . . . . . . . 5
1.2.1 Branchement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Partie pratique 6
2.1 LED avec Raspberry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.1 Branchement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.2 Code python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Bouton avec Raspberry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.1 Branchement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.2 Code python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 LDR avec Raspberry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3.1 Branchement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3.2 Code python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4 LED avec Arduino et Raspberry via UART . . . . . . . . . . . . . . . . . . . 9
2.4.1 Branchement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4.2 Code python dans raspberry . . . . . . . . . . . . . . . . . . . . . . . 10
2.4.3 Code c dans l’arduino . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2
Chapitre 1

Partie théorique

3
1.1 Etude théorique sur la Communication UART
1.1.1 UART en général :
La communication série est simplement un moyen de transférer des données. Les données
seront envoyées séquentiellement, un bit à la fois, contrairement à la communication parallèle,
où plusieurs bits sont envoyés en même temps.

1.1.1.1 Le protocole UART

Plus précisément, lorsque on utilise Serial avec Arduino et Raspberry Pi, nous utilisons
le protocole UART. UART signifie “Universal Asynchronous Reception and Transmission”
Il s’agit à la base d’un protocole multi-maître asynchrone basé sur la communication série,
qui nous permettra de communiquer entre les 2 cartes.
Multi-maître signifie que tous les appareils connectés seront libres d’envoyer des données
quand ils le souhaitent. C’est l’une des principales différences avec les protocoles maître-esclaves,
où seul l’appareil maître peut initier une communication.

1.1.2 Branchement
Afin d’assurer cette communication il faut s’assurer que les deux carte (Arduino et
Raspberry) sont branchées de la manière suivante :
TX de l’arduino connecté avec RX de Raspberry et
RX de l’arduino avec TX de Raspberry
TX c’est le transmetteur et RX c’est le récepteur

1.1.3 Fonctions
Les fonctions d’écriture sont : ser.write(msg.encode()) //Dans le code python avec ser
c’est le serial de communication, msg c’est le message a envoyer
Serail1.write(msg) //Dans le code c

Les fonctions de lecture sont : ser.read() //Dans le code python avec ser c’est le serial
de communication
Serail1.read() //Dans le code c

4
1.2 Etude théorique sur la Communication I2C.
I²C (Inter-Integrated Circuit), est un bus informatique synchrone, multi-maître, multi-esclave,
à commutation de paquets, asymétrique, inventé en 1982 par Philips Semiconductor (maintenant
NXP Semiconductors). Il est largement utilisé pour connecter des circuits intégrés périphériques
à faible vitesse aux processeurs et aux microcontrôleurs dans les communications intra-carte
à courte distance.

1.2.1 Branchement

Figure 1.1 – I2C branchement

5
Chapitre 2

Partie pratique

6
 2.1 LED avec Raspberry
2.1.1 Branchement

Figure 2.1

2.1.2 Code python

1 import RPi . GPIO a s GPIO
2 from time import s l e e p
3 GPIO . s e t w a r n i n g s ( F a l s e )
4 GPIO . setmode (GPIO .BOARD)
5 GPIO . s e t u p ( 3 3 ,GPIO .OUT, i n i t i a l = GPIO .LOW)
6 w h i l e True :
7 GPIO . output ( 3 3 ,GPIO . HIGH)
8 sleep (1)
9 GPIO . output ( 3 3 , GPIO .LOW)
10 sleep (1)

2.2 Bouton avec Raspberry

2.2.1 Branchement

Figure 2.2

7
 2.2.2 Code python
1 import RPi . GPIO a s GPIO # Import Raspberry Pi GPIO l i b r a r y
2 GPIO . s e t w a r n i n g s ( F a l s e ) # I g n o r e warning f o r now
3 GPIO . setmode (GPIO .BOARD) # Use p h y s i c a l p i n numbering
4 GPIO . s e t u p ( 1 0 , GPIO . IN , pull_up_down=GPIO .PUD_DOWN)
5 w h i l e True :
6 i f GPIO . i n p u t ( 1 0 ) == GPIO . HIGH :
7 p r i n t ( " Button was pushed ! " )

2.3 LDR avec Raspberry

2.3.1 Branchement

Figure 2.3

2.3.2 Code python

1 from machine import Pin
2 import time
3 l d r = machine .ADC( 2 7 )
4 w h i l e True :
5 p r i n t ( l d r . read_u16 ( ) )
6 time . s l e e p ( 2 )

8
2.4 LED avec Arduino et Raspberry via UART
2.4.1 Branchement

Figure 2.4

9
 2.4.2 Code python dans raspberry
1 import s e r i a l
2 import time
3
4 i f __name__ == ’__main__ ’ :
5 s e r = s e r i a l . S e r i a l ( ’ / dev / t t y S 0 ’ , 9 6 0 0 , t i m e o u t =1) #c o n f i g u r a t i o n
6 #du s e r i a l de communication
7 ser . reset_input_buffer ()
8 i = 0 ;#i n i t i a l i s e r i
9 w h i l e True :
10 msg = s t r ( i ) #i comme c h a r a c t r e
11 s e r . w r i t e ( msg . encode ( ) )#e n v o y e r l e c h a r a c t r e
12 #i n v e r s e r l e c h a r a c t r e a f i n de c h a n g e r
13 #l ’ e t a t de l a l e d dans l ’ a r d u i n o
14 i f ( i == 0 ) :
15 i = 1
16 else :
17 i = 0
18 time . s l e e p ( 1 )

2.4.3 Code c dans l’arduino

1 i n t LED = 7 ;
2 void setup ( ) {
3 S e r i a l . begin (9600) ;
4 S e r i a l 1 . begin (9600) ;
5 pinMode (LED, OUTPUT) ;
6 }
7 void loop ( ) {
8 // V e r i f i e r que l a c o n n e x i o n s e r i a l e s t t o u j o u r s e t a b l i e
9 while ( S e r i a l 1 . a v a i l a b l e ( ) > 0)
10 {
11 // R ecuper er l a v a l e u r de l a v a r i a b l e
12 // i envoyee d e p u i s l e r a s p b e r r y dans l a v a r i a b l e in B yt e
13 c h a r i nB yt e = S e r i a l 1 . r e a d ( ) ;
14 // Allumer l a LED s i l a v a l e u r e s t e g a l e a 1 e t
15 // l ’ e t e i n d r e s i e l l e e s t e g a l e 0 avec un d e l a i d ’ une
16 // s e c o n d e e n t r e l e s a c t i o n s
17 i f ( in By te==’ 1 ’ ) {
18 d i g i t a l W r i t e (LED, HIGH) ;
19 delay (1000) ;
20 }
21 else {
22 d i g i t a l W r i t e (LED, LOW) ;
23 delay (1000) ;
24 }
25 S e r i a l . p r i n t l n ( in B yt e ) ;
26 }
27 }

10