Le document présente un plan de module sur les systèmes embarqués, axé sur le Raspberry Pi et sa programmation en Python. Il couvre des aspects techniques, tels que les bibliothèques GPIO et les exemples de code pour manipuler des entrées-sorties. Les utilisateurs apprennent ainsi à configurer et à programmer le Raspberry Pi pour diverses applications embarquées.

1. SYSTÈMES EMBARQUÉS
Deuxième Année Informatique

2. PLAN DU MODULE
 Chapitre 1: SoC et MCU
 Chapitre 2: Les microcontrôleurs STM32 et
programmation de base
 Chapitre 3 : Bibliothèques C embarqué pour STM 32
 Chapitre 4: Initiation aux MPU

3. INITIATION AUX MPU

4. LE RASPBERY PI
Le Raspberry Pi est une cible embarquée de type mini PC
Après plusieurs années de développement, et plusieurs versions, le
projet a bien évolué. Malgré son faible coût, la carte dispose d'un
panel d'entrées-sorties considérable et se prête aussi bien à des
applications embarquées.
le Raspberry Pi dispose néanmoins d'un OS officiel qu'il s'agit tout
simplement d'un Linux Debian. Cet OS a été surnommé Raspbian

5. Modèles :

6. Exemple de carte

9. Port GPIO: Raspberry Pi - modèles A et B

10. Port GPIO: Raspberry Pi - modèles A+, B+, et B2
L'ensemble de ces fonctionnalités peuvent être activées une à une selon nos besoins.

11. Numérotations
Le Raspberry Pi autorise deux numérotations : celle de la sérigraphie du
connecteur de la carte (GPIO.BOARD), ou la numérotation électronique de la puce
(GPIO.BCM).
En noir la numérotation GPIO.BOARD. En rouge, la numérotation GPIO.BCM:

12. Activation d’une
fonctionnalité
La méthode que nous allons voir est la méthode standardisée à partir des versions « + ».
Elle est donc compatible modèles A+, B+, B2.
Il suffit d’ouvrir un terminal, depuis une interface graphique, et/ou lancez la commande
suivante :
sudo raspi-config

13. Sélectionner votre choix et accepter avec des « yes » en répondant à toutes les questions
Rebooter la machine: sudo reboot
Tester la connexion avec le périphérique:
lsmod | grep i2c_ (pour I2C)
lsmod | grep spi_ (pour SPI)

14. PROGRAMMATION PYTHON DU
PORT GPIO
La bibliothèque historique du python : RPi.GPIO.
Pour l'installer, il suffit donc d'un simple pip install : pip install RPi.GPIO
SI on ne dispose pas pip il faut l’installer:
wget https://bootstrap.pypa.io/get-pip.py
python get-pip.py
Le port GPIO n'est accessible qu'en mode root. N'oubliez donc pas de lancer
Python avec la commande sudo, sinon cela ne fonctionnera pas:
sudo python mon_script.py

15. Code Python:
import RPi.GPIO as GPIO
# exemples de choix de l’un des deux modes
GPIO.setmode(GPIO.BOARD)
GPIO.setmode(GPIO.BCM)
# On peut aussi demander la configuration établie
configuration = GPIO.getmode()
# exemples de configurations des entrées-sorties
GPIO.setup(3, GPIO.IN) # broche 3 est une entrée numérique
GPIO.setup(12, GPIO.OUT, initial=GPIO.HIGH) # broche 12 est une sortie initialement a
l‘état haut
# exemple lecture d’une entrée
GPIO.input(12)
# exemples d’écriture d’une sortie
GPIO.output(12, GPIO.LOW)
GPIO.output(12, not GPIO.input(12))
l'état haut peut valoir au choix
GPIO.HIGH, 1 ou encore True.
De même, l'état bas peut valoir
GPIO.LOW, 0 ou False.

16. Exemple de
clignotement de diode
LED
# Import des modules
import RPi.GPIO as GPIO
import time
# Initialisation de la numerotation et des
E/S
GPIO.setmode(GPIO.BOARD)
GPIO.setup(3, GPIO.OUT, initial =
GPIO.HIGH)
# On fait clignoter la LED
while True:
GPIO.output(3, not GPIO.input(3))
time.sleep(0.5)
Blink.py

17. Exemple clignotement dégradé de diode LED
Dans ce cas nous voulons augmenter l’intensité de
la diode LED jusqu’à arriver au maximum puis
revenir jusqu’au minimum
Pour cela nous allons utiliser la PWM (Pulse Width
Modulation) qui consiste en un signal carré dont on
fait varier le rapport cyclique, en d'autres termes,
dont on fait varier la durée de l'état haut, par
rapport à l'état bas,
Nous allons utiliser:
p = GPIO.PWM(channel, frequence)
# pour envoyer un PWM sur un canal avec une
fréquence donnée
p.start(rapport_cyclique)
#ici, rapport_cyclique vaut entre 0.0 et 100.0
p.ChangeFrequency(nouvelle_frequence)
p.ChangeDutyCycle(nouveau_rapport_cyclique)
p.stop()

18. Pwm.py
# Import des modules
import RPi.GPIO as GPIO
import time
# Initialisation de la numerotation et des E/S
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT, initial = GPIO.LOW)
Rapport = 10.0
sens = True
p = GPIO.PWM(12, 200)
p.start(rapport) #ici, rapport_cyclique vaut entre 0.0 et 100.0

19. # On fait varier l'intensite de la LED
while True:
if sens and rapport < 100.0:
rapport += 10.0
elif sens and rapport >= 100.0:
sens = False
elif not sens and rapport > 10.0:
rapport -= 10.0
elif rapport == 10.0:
sens = True
p.ChangeDutyCycle(rapport)
time.sleep(0.25)

20. Exemple de lecture d’un bouton
Une fois le bouton appuyé, nous
attendrons le relâchement tout
simplement.
Les deux broches de notre bouton
seront branchées sur une masse et la
broche 19 du GPIO (GPIO10). Une
résistance de pull-up sera également
branchée entre une des broches de
+3,3V et la broche 19.
Enfin, notre LED sera branchée cette
fois entre une masse et la broche 12
(GPIO18).

21. # Import des modules
import RPi.GPIO as GPIO
import time
# Initialisation de la numerotation et des E/S
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(19, GPIO.IN)
# Si on detecte un appui sur le bouton, on allume la LED
# et on attend que le bouton soit relache
while True:
state = GPIO.input(19)
if not state:
# on a appuye sur le bouton connecte sur la broche 19
GPIO.output(12, GPIO.HIGH)
while not state:
state = GPIO.input(19)
time.sleep(0.02) # Pause pour ne pas saturer le processeur
GPIO.output(12, GPIO.LOW)
time.sleep(0.02) # Pause pour ne pas saturer le processeur
Button.py
Ces exemples dans le site: https://deusyss.developpez.com/tutoriels/RaspberryPi/PythonEtLeGpio/