Système Embarqués
Manipulation
Introduction
Le Raspberry Pi est un micro-ordinateur de la taille d'une carte
de crédit développé par la Raspberry Pi Foundation au RoyaumeUni. Son objectif initial était de promouvoir l'enseignement de
l'informatique et de l'électronique à bas coût. Aujourd'hui, il
est utilisé dans divers domaines allant de l'éducation à
l'industrie en passant par les projets de bricolage (DIY).
•
Taille compacte : Environ la taille d'une carte de crédit.
•
Coût abordable : Le prix commence autour de 35 euros.
•
Polyvalence : Utilisé pour la programmation, les projets
électroniques, les robots, les serveurs domestiques, etc.
Les composants de base d'un Raspberry Pi
•
Processeur ARM : Comparable à un smartphone de milieu de
gamme.
•
RAM : De 1 Go à 8 Go selon les modèles.
•
Ports GPIO : 40 broches pour connecter des composants
électroniques (capteurs, LEDs, moteurs).
•
Ports USB : Pour connecter clavier, souris, clés USB, etc.
•
Port HDMI : Pour brancher un écran.
•
Port réseau Ethernet et Wi-Fi intégré pour les modèles
récents.
•
Lecteur de carte microSD : Pour le stockage et le système
d'exploitation.
Système d'exploitation
Le Raspberry Pi utilise principalement Raspberry Pi OS
(anciennement Raspbian), une version de Linux optimisée pour le
Raspberry Pi.
Les bases pour débuter avec un Raspberry Pi
•
Matériel nécessaire : Raspberry Pi, carte microSD,
alimentation, clavier, souris, écran (avec câble HDMI).
•
Installation du système d'exploitation :
•
Téléchargez Raspberry Pi Imager pour préparer la carte
microSD avec Raspberry Pi OS.
•
Insérez la carte microSD
connectez-le et démarrez.
dans
le
Raspberry
Pi,
Figure 1 : les ports de la carte Raspberry
Logiciel pour commencer




Imager Raspberry
Putty
VNC Viewer
Ip Scanner
Mettez les carte mémoire dans les lecteurs carte mémoire et
brancher le dans vous pc et copier le dossier Raspberry contient
les 4 setup des logiciels.
**************************************
Installation système
d’exploitation
1ère étape : installation d’imager Raspberry
Vous pouvez télécharger de site officiel.
Lien :
Raspberry Pi Imager : https://www.raspberrypi.com/software/
Et aussi vous le trouverez dans USB dossier « Raspberry setup ».
Lancer l’installation et suivre les étapes.
Figure 2 : Téléchargement Raspberry Imager
Dès que l’installation termine lancer le logiciel et copier le
fichier de système d’exploitation dans vos pc.
1. Insérer la carte mémoire sur vos PC
2. Lancer le logiciel Raspberry Imager
1
2
3
Figure 3 : lancement de logiciel
Voici l’interface de l’imager Raspberry (Figure1) et les étapes
à suivre pour installer le système sous la carte mémoire :
1ère étape : choisir le type de la carte que vous aviez ;
2ème étape : sélectionner le système que vous souhaitiez
l’installer ou si vous aviez déjà télécharger l’installation à
partir le site officiel vous pouviez choisir l’installation
custom (le dernier choix)
Vous le trouverez dans le dossier Raspberry dans la carte mémoire
3ème étape le choix de stockage : sélectionner le nom de la carte
mémoire et cliquer sur suivant.
1
Figure 4 : choix de modèle de la carte Raspberry (Model PI 3)
2
Figure 5 : choix de système d'exploitation (Soit il télécharge en ligne soit vous
utiliser l’installation Custom)
3
Cliquer sur suivant
En suite cliquer sur modifier les réglages
1. Modifier le nom de l’hôte
2. Changer le nom d4utilisateur pi et le mot de passe « 1234 »
3. Saisir le nom et le mot de passe de Wi-Fi
4. Aller sur l’onglet Service et activer SSH
5. Puis cliquer sur enregistrer
PI1
123
4
SSTI@2023
Figure 6 : choix de stockage et cliquer suivant
Attendez dès que l’écriture et la vérification termine puis
cliquer sur continuer.
Finalement vous éjectez la carte SD de vos PC et la rebrancher.
**************************************
Création d’un fichier ssh
Dans le dossier boots existe sur la carte mémoire crée un fichier
text (.txt) ensuite renommer avec le nom ssh vaut mieux de
supprimer(.txt) comme ça ssh.txt  ssh.
Clique droit avec
la souris 
nouveau  fichier
texte  ssh
Ejecter la carte mémoire
**************************************
Installation de PuTTY
SSH, qui signifie Secure Shell, est un outil professionnel qui
vous permet de vous connecter en toute sécurité à votre
ordinateur
sur
un
réseau.
En chiffrant le chemin de communication et en utilisant
l’authentification par mot de passe, les informations de sortie
sont envoyées et reçues en toute sécurité.
Après l’installation, la connexion s’établit comme suit :
1. Nom d’hôte (ou adresse IP) : Entrez le nom d’hôte ou l’adresse
IP de votre ordinateur. (à la place de raspberrypi.local mettez
votre propre adresse comme pi1.local)
2. Assurez-vous d’entrer « 22 » dans Port.
3. Pour Type de connexion, sélectionnez « SSH ».
Une fenêtre de commande apparaitre saisi le login « pi » et
cliquer
entrée
aussi
la
même
chose
pour
le
mot
de
passe : « 1234 »
Finalement vous êtes connecté sur la carte Raspberry :
Alors maintenant
entrée :
en
tapant
la
commande
suivante et
cliquer
Pour configurer le VNC viewer on doit accéder a l’espace
interface pour l’activer en descendant avec la flèche de bas
vers l’option « Interface Options » :
Cliquer sur entrée
Alors maintenant on doit activer les options SSH et VNC
1 SSH option :
Cliquer sur « Yes »
2 Ensuite VNC :
Cliquer sur VNC
Cliquer sur « Yes »
Maintenant cliquer sur finish en utilisant la flèche de gauche
ou droit
Dès que vous termine la configuration on doit lancer une autre
commande pour mettre à jour les modification :
Sudo reboot
**************************************
Installation VNC Viewer
VNC est un logiciel de bureau à distance qui permet à un
utilisateur de contrôler un ordinateur à distance, comme s’il
était devant l’écran.
Lien pour le téléchargé :
https://www.realvnc.com/en/connect/download/viewer/?lai_vid=DB
wyM0m9LSxkg&lai_sr=5-9&lai_sl=l
Lancé le logiciel pour l’installation, et suivre les étapes
suivantes de 1 à 6:
1
2
4
3
5
6
Lancer le logiciel et saisir l’adresse de la carte :
Exemple : « raspberrypi.local » et cliquer sur entrée
Après le saisi de l’adresse de la Raspberry cliquer sur entrer,
une connexion sera établie avec la carte afin de saisir le nom
d’utilisateur et le mot de passe cliquer sur continuer comme
dans les deux figures suivantes :
Finalement le bureau de système vous apparait :
Terminal
Icone VNC
Dossier
Mise à
jour
Chrome
navigateur
Bluetooth
Menu
démarrer
Paramètre
Wi-Fi
Bureau
Raspberry
Activation des protocoles
de communication sur la
carte
Afin activer les interface de communication on clique sur l’icône
de la Raspberry en haut à gauche puis cliquer sur Préférences >
configuration du Raspberry PI comme les figures suivantes :
1
2

3
Sur la figure étape 3 activer toutes les interfaces. Une
fois que vous avez terminé avec l’application de
configuration Raspberry Pi, cliquez sur “OK” et laissez
votre configuration se mettre à jour. On vous demandera
ensuite si vous souhaitez redémarrer Raspberry Pi OS
maintenant ou plus tard. Pour consolider les changements,
il est toujours préférable de redémarrer immédiatement.
1ère application : écrire
simple programme pour
commencer avec Thonny
Lancer le logiciel de programmation ThonnyIDE à partir le menu
et cliquer sur ‘Programming’ > cliquer sur Thonny IDE suivre les
étapes de 1 à 3 :
Thonny est un éditeur de code Python convivial pour les
débutants, qui est préinstallé sur Raspberry Pi OS. L’interface
est propre et simple, et comme un interpréteur Python est
intégré, nous pouvons commencer à coder immédiatement sans avoir
à installer quoi que ce soit d’autre.
1
2
3
Enregistrer vos travaux
Saisi le nom de
fichier avec
l’extension
1
Choix de dossier
2
3
2ème application : allumé une LED connectée avec la carte
utilisant les GPIO
Étape 1 : Installer la bibliothèque RPi.GPIO
Avant de commencer, assurez-vous que la bibliothèque RPi.GPIO
est installée sur votre Raspberry Pi. Si elle ne l’est pas,
exécutez les commandes suivantes dans le terminal :
sudo apt-get update
sudo apt-get install python3-rpi.gpio
Importation des bibliothèques :

RPi.GPIO : pour contrôler les broches GPIO.

time : pour gérer les pauses (temporisations)
l’allumage et l’extinction de la LED.
entre
import RPi.GPIO as GPIO # Importer la bibliothèque GPIO pour contrôler
les broches
import time
# Importer la bibliothèque pour gérer le délai
Configuration des broches GPIO :

GPIO.setmode(GPIO.BCM) : Configure la Raspberry Pi pour
utiliser la numérotation des broches BCM.

GPIO.setmode(GPIO.BOARD) : Configure la Raspberry Pi pour
utiliser la numérotation des broches physique.

GPIO.setup(LED_PIN, GPIO.OUT) : Définit la broche 17 comme
sortie pour contrôler la LED.
Allumer et éteindre la LED :

GPIO.output(LED_PIN, GPIO.HIGH) : Envoie un signal "haut"
pour allumer la LED.

GPIO.output(LED_PIN, GPIO.LOW) : Envoie un signal "bas"
pour éteindre la LED.
Nettoyage :

GPIO.cleanup() : Réinitialise toutes les broches GPIO après
l'exécution du programme.

Utiliser les broches GPIO en entrée
Pour lire l'état d'un capteur ou d'un bouton, configurez une
broche en entrée.
# Configuration de la broche 17 en entrée
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP)
while True:
state = GPIO.input(17)
print(state)
# Lire l'état de la broche 17
if GPIO.input(17) == GPIO.HIGH:
print("Bouton appuyé")
else :
print("Bouton relâché")

Utiliser les broches GPIO en entrée et la résistance interne
# Configuration de la broche 17 en entrée avec une résistance
de pull-up
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP)
# Configuration de la broche 17 en entrée avec une résistance
de pull-down
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
Créer un fichier python
#**********************************
import RPi.GPIO as GPIO # Importer la bibliothèque GPIO pour contrôler
les broches
import time
# Importer la bibliothèque pour gérer le délai
# Configuration des broches GPIO en mode BCM
GPIO.setmode(GPIO.BCM)
# Définir le numéro de la broche où la LED est connectée (par exemple,
GPIO17)
LED_PIN = 17
# Configurer la broche comme sortie
GPIO.setup(LED_PIN, GPIO.OUT)
# Allumer la LED pendant 5 secondes, puis l'éteindre
GPIO.output(LED_PIN, GPIO.HIGH)
# Allumer la LED
print("LED allumée")
time.sleep(5)
# Garder la LED allumée pendant 5 secondes
GPIO.output(LED_PIN, GPIO.LOW)
# Éteindre la LED
print("LED éteinte")
# Nettoyer les configurations GPIO après utilisation
GPIO.cleanup()
#*************************************
4ème
Application
Raspberry Pi
:
Bouton
poussoir
avec
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(23,
GPIO23
GPIO.IN,
GPIO.setup(24, GPIO.OUT)
pull_up_down=GPIO.PUD_UP)#Button
#LED to GPIO24
try:
while True:
button_state = GPIO.input(23)
if button_state == False:
GPIO.output(24, True)
print('Button Pressed...')
time.sleep(0.2)
else:
GPIO.output(24, False)
except:
GPIO.cleanup()
*************************************
to
5ème Application : développer une interface
graphique à base Tkinter deux bouton pour la
fonction On et OFF d’une LED
Tkinter est la bibliothèque standard de Python pour créer des
interfaces graphiques (GUI). Elle est incluse dans la plupart
des distributions Python, ce qui en fait l'une des options les
plus accessibles pour développer des applications avec une
interface graphique. Tkinter permet de créer facilement des
fenêtres, des boutons, des étiquettes, des champs de saisie,
etc.
Exemple 1 d’une fenêtre
import tkinter as tk
# Créer une fenêtre principale
window = tk.Tk()
# Définir un titre pour la fenêtre
window.title("Contrôle de LED")
window.geometry(‘250x250’)
window.resizable()
# Lancer la boucle principale de Tkinter
button = tk.Button(window, text="Cliquez ici", command=’ ’,
bg=’red’,fg=’blue’)



button.grid(row= , column = , pady = , padx= )
button.place(x=, y= , pady= , padx= )
button.pack()
window.mainloop()
Interface graphique
#*************************************************
import tkinter as tk
import RPi.GPIO as GPIO
# Configuration des GPIO
LED_PIN = 17
GPIO.setmode(GPIO.BCM)
GPIO.setup(LED_PIN, GPIO.OUT)
# Fonction pour allumer la LED
def allumer_led():
GPIO.output(LED_PIN, GPIO.HIGH)
# Fonction pour éteindre la LED
def eteindre_led():
GPIO.output(LED_PIN, GPIO.LOW)
# Fonction pour fermer proprement l'application et nettoyer les
GPIO
def quitter_application():
GPIO.cleanup()
# Nettoyer les configurations GPIO
window.quit()
# Fermer la fenêtre Tkinter
# Création de la fenêtre principale
window = tk.Tk()
window.title("Contrôle LED")
# Création des boutons pour allumer et éteindre la LED
btn_allumer
=
tk.Button(window,
text="Allumer
command=allumer_led, bg="green", fg="white")
la
LED",
btn_eteindre = tk.Button(window, text="Éteindre
command=eteindre_led, bg="red", fg="white")
la
LED",
# Positionnement des boutons dans la fenêtre
btn_allumer.pack(pady=10)
btn_eteindre.pack(pady=10)
# Bouton pour quitter l'application
btn_quitter
=
tk.Button(window,
command=quitter_application)
btn_quitter.pack(pady=10)
# Lancement de la boucle principale Tkinter
window.mainloop()
text="Quitter",
5ème application : lecture la température
l’humidité utilisant capteur DHT11
et
DHT Pin Signal
Pi Pin
1
3.3V
1
2
Data/Out 11 (GPIO17)
4
Ground
6 or 9
Lancer les commandes suivantes :
pip3 install Adafruit_DHT
code complet :
import Adafruit_DHT
import time
# Définir le type de capteur et la broche GPIO
sensor = Adafruit_DHT.DHT11
gpio = 17
# Modifier le numéro de GPIO si nécessaire
while True:
# Lecture des données depuis le capteur
humidity,
gpio)
temperature
=
Adafruit_DHT.read_retry(sensor,
# Vérification de la validité des données
if humidity is not None and temperature is not None:
print('Temp={0:0.1f}*C
Humidity={1:0.1f}%'.format(temperature, humidity))
else:
print('Failed to get reading. Try again!')
# Délai de 2 secondes avant la prochaine lecture
time.sleep(2)
APPLICATION DHT 11 AVEC TKINTER
import tkinter as tk
import Adafruit_DHT
# Type de capteur et GPIO
DHT_SENSOR
nécessaire
DHT_PIN = 4
=
Adafruit_DHT.DHT11
#
Remplacez
par
DHT22
si
# Numéro du GPIO où le capteur est connecté
def update_values():
"""Lit les données du capteur et met à jour l'interface
utilisateur."""
# Lire les données depuis le capteur
humidity, temperature = Adafruit_DHT.read_retry(DHT_SENSOR,
DHT_PIN)
if humidity is not None and temperature is not None:
temp_value_label.config(text=f"{temperature:.1f} °C")
humidity_value_label.config(text=f"{humidity:.1f} %")
else:
temp_value_label.config(text="Erreur")
humidity_value_label.config(text="Erreur")
# Replanifie la mise à jour après 5 secondes
root.after(5000, update_values)
# Création de la fenêtre principale
root = tk.Tk()
root.title("Température et Humidité")
root.geometry("300x200")
# Label de titre
title_label = tk.Label(root,
font=("Arial", 16))
text="Température
&
Humidité",
title_label.pack(pady=10)
# Cadre pour la température
temp_frame = tk.Frame(root)
temp_frame.pack(pady=5)
temp_label
=
tk.Label(temp_frame,
font=("Arial", 12))
text="Température
:",
temp_label.grid(row=0, column=0, padx=5)
temp_value_label
=
tk.Label(temp_frame,
font=("Arial", 12), fg="blue")
text="--
°C",
text="Humidité
:",
temp_value_label.grid(row=0, column=1, padx=5)
# Cadre pour l'humidité
humidity_frame = tk.Frame(root)
humidity_frame.pack(pady=5)
humidity_label = tk.Label(humidity_frame,
font=("Arial", 12))
humidity_label.grid(row=0, column=0, padx=5)
humidity_value_label = tk.Label(humidity_frame,
font=("Arial", 12), fg="green")
humidity_value_label.grid(row=0, column=1, padx=5)
# Lancer la mise à jour automatique
update_values()
# Lancer l'interface graphique
root.mainloop()
text="--
%",
6ème Application : Mesure
ultrasonore HC-SR04
de
distance
par
le
capteur
CODE ultrason
import RPi.GPIO as GPIO
import time
# Définir les broches
TRIG_PIN = 11
ECHO_PIN = 13
# Initialiser la bibliothèque GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(TRIG_PIN, GPIO.OUT)
GPIO.setup(ECHO_PIN, GPIO.IN)
def distance():
# Envoyer une impulsion ultrasonique
GPIO.output(TRIG_PIN, GPIO.LOW)
time.sleep(2)
# Attente pour la stabilisation du capteur
GPIO.output(TRIG_PIN, GPIO.HIGH)
time.sleep(0.00001)
GPIO.output(TRIG_PIN, GPIO.LOW)
# Mesurer le temps entre l'émission et la réception du signal
while GPIO.input(ECHO_PIN) == 0:
pulse_start_time = time.time()
while GPIO.input(ECHO_PIN) == 1:
pulse_end_time = time.time()
pulse_duration = pulse_end_time - pulse_start_time
# Calculer la distance en utilisant la vitesse du son (343
m/s)
distance_cm = pulse_duration * 34300 / 2
return distance_cm
try:
while True:
dist = distance()
print(f"Distance: {dist:.2f} cm")
time.sleep(1)
except KeyboardInterrupt:
# Arrêter proprement lorsqu'on appuie sur Ctrl+C
GPIO.cleanup()
APPLICATION SERVO-MOTEUR
pi_pwm = GPIO.PWM (Pin no, frequency)
start (Duty Cycle)
ChangeDutyCycle(Duty Cycle)
stop()
CODE SERVO-MOTEUR
import RPi.GPIO as GPIO
from time import sleep
## add your servo BOARD PIN number ##
servo_pin = 11
GPIO.setmode(GPIO.BOARD)
GPIO.setup(servo_pin, GPIO.OUT)
pwm=GPIO.PWM(servo_pin, 50)
pwm.start(0)
## edit these duty cycle % values ##
left = 2.5
neutral = 7.5
right = 12
print("begin test")
print("duty cycle", left,"% at left -90 deg")
pwm.ChangeDutyCycle(2.5)
sleep(1)
print("duty cycle", neutral,"% at 0 deg")
pwm.ChangeDutyCycle(neutral)
sleep(1)
print("duty cycle",right, "% at right +90 deg")
pwm.ChangeDutyCycle(right)
sleep(1)
print("end of test")
pwm.stop()
GPIO.cleanup()
import RPi.GPIO as GPIO
from time import sleep
## add your servo BOARD PIN number ##
servo_pin = 11
GPIO.setmode(GPIO.BOARD)
GPIO.setup(servo_pin, GPIO.OUT)
pwm=GPIO.PWM(servo_pin, 50)
pwm.start(0)
## edit these duty cycle % values ##
left = 2.5
neutral = 7.5
right = 12
#### that's all folks ####
print("begin test")
# print("duty cycle", left,"% at left -90 deg")
# pwm.ChangeDutyCycle(2.5)
# sleep(1)
print("duty cycle", neutral,"% at 0 deg")
pwm.ChangeDutyCycle(neutral)
sleep(1)
print("duty cycle",right, "% at right +90 deg")
pwm.ChangeDutyCycle(right)
sleep(1)
print("end of test")
pwm.stop()
GPIO.cleanup()
import RPi.GPIO as GPIO
from time import sleep
servo_pin = 11
GPIO.setmode(GPIO.BOARD)
GPIO.setup(servo_pin, GPIO.OUT)
pwm = GPIO.PWM(servo_pin, 50)
# 50Hz frequency
pwm.start(0)
def angle_to_duty_cycle(angle):
# Convert angle (0-180) to duty cycle (2.5% to 12%)
return 2.5 + (angle / 18)
try:
while True:
angle = float(input("Enter angle (0 to 180): "))
if 0 <= angle <= 180:
duty_cycle = angle_to_duty_cycle(angle)
print(f"Setting
{duty_cycle}%)")
angle
to
{angle}°
pwm.ChangeDutyCycle(duty_cycle)
sleep(1)
else:
(Duty
Cycle:
print("Angle must be between 0 and 180.")
except KeyboardInterrupt:
print("Exiting program")
finally:
pwm.stop()
GPIO.cleanup()
7ème Application : contrôler les TAGs RFID avec un voyant
lumineux
1. Faire le montage.
2. Etablie le code pour la lecture d’un TAG RFID.
3. Etablie un code pour écrire sur le TAG RFID.
4. Vérifier le code d’un TAG avec deux voyant
« Rouge » pour Faux « Jaune » pour Vrai.
lumineux
sudo apt update
sudo apt upgrade
python3 -m pip install spidev --break-system-packages
python3 -m pip install mfrc522 --break-system-packages
LECTURE UN TAG RFID
from mfrc522 import SimpleMFRC522
import RPi.GPIO as GPIO
reader = SimpleMFRC522()
try:
print("Approchez votre carte RFID...")
id, text = reader.read()
print(f"ID : {id}")
print(f"Texte : {text}")
except Exception as e:
print(f"Erreur : {e}")
finally:
GPIO.cleanup()
Lecture/écriture TAG RFID
import RPi.GPIO as GPIO
from mfrc522 import SimpleMFRC522
import time
# Initialisation du lecteur RFID
reader = SimpleMFRC522()
try:
# Lire le contenu du tag source
print("Placez le tag source pour lire les données")
source_id, source_text = reader.read()
print("ID du tag source :", source_id)
print("Texte du tag source :", source_text)
# Délai pour permettre le changement de tag
print("Retirez le tag source et placez le tag cible...")
time.sleep(5) # Temps pour changer de tag (5 secondes ici,
ajustez selon vos besoins)
# Écriture sur le tag cible
print("Écriture en cours sur le tag cible...")
reader.write(source_text)
print("Données écrites avec succès sur le tag cible")
finally:
GPIO.cleanup()
Servo et RFID
import RPi.GPIO as GPIO
from mfrc522 import SimpleMFRC522
# Bibliothèque pour RFID
from time import sleep
# Configurations des broches
servo_pin = 11
# Broche GPIO pour le servo-moteur
led_green = 13
# Broche GPIO pour la LED verte
led_red = 15
# Broche GPIO pour la LED rouge
# Configuration du servo-moteur et des LEDs
GPIO.setmode(GPIO.BOARD)
GPIO.setup(servo_pin, GPIO.OUT)
GPIO.setup(led_green, GPIO.OUT)
GPIO.setup(led_red, GPIO.OUT)
# Initialisation du PWM pour le servo-moteur
pwm = GPIO.PWM(servo_pin, 50)
pwm.start(7.5)
# Fréquence de 50 Hz pour le servo
# Position initiale (0°)
# Configuration du lecteur RFID
reader = SimpleMFRC522()
# Tag RFID autorisé (remplacez par l'ID réel de votre tag)
AUTHORIZED_TAG = "1234567890"
# Remplacez par l'ID de votre tag
try:
while True:
print("Approchez votre tag RFID...")
id, text = reader.read()
# Lecture du tag RFID
print(f"ID lu: {id}")
if str(id).strip() == AUTHORIZED_TAG:
# Tag valide : tourner le servo à 90° et allumer la
LED verte
print("Tag valide. Accès autorisé.")
GPIO.output(led_green, GPIO.HIGH)
# Allumer LED
verte
pwm.ChangeDutyCycle(12)
sleep(10)
# Tourner le servo à 90°
# Attendre 10 secondes
# Retourner le servo à 0° et éteindre la LED
pwm.ChangeDutyCycle(7.5)
#
Retour
au
point
de
départ
GPIO.output(led_green, GPIO.LOW)
# Éteindre LED
verte
else:
# Tag invalide : allumer la LED rouge
print("Tag invalide. Accès refusé.")
GPIO.output(led_red, GPIO.HIGH)
sleep(3)
# Allumer LED rouge
# Attendre 3 secondes
GPIO.output(led_red, GPIO.LOW)
# Éteindre LED rouge
except KeyboardInterrupt:
print("Programme interrompu par l'utilisateur.")
finally:
pwm.stop()
GPIO.cleanup()
Ultrason & RFID
import RPi.GPIO as GPIO
from mfrc522 import SimpleMFRC522
import time
from time import sleep
import Adafruit_DHT
# Configurations des broches
TRIG = 16
# Broche du capteur ultrasonique TRIG
ECHO = 18
# Broche du capteur ultrasonique ECHO
led_green = 13
led_red = 15
# LED verte
# LED rouge
# Initialisation des GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(TRIG, GPIO.OUT)
GPIO.setup(ECHO, GPIO.IN)
GPIO.setup(led_green, GPIO.OUT)
GPIO.setup(led_red, GPIO.OUT)
# Configuration RFID
reader = SimpleMFRC522()
# ID RFID autorisé
AUTHORIZED_TAG = "1234567890"
# Remplacez par l'ID de votre tag
def measure_distance():
"""Mesure la distance à l'aide du capteur ultrasonique."""
GPIO.output(TRIG, True)
time.sleep(0.00001)
GPIO.output(TRIG, False)
start_time = time.time()
stop_time = time.time()
while GPIO.input(ECHO) == 0:
start_time = time.time()
while GPIO.input(ECHO) == 1:
stop_time = time.time()
# Calcul de la distance
elapsed_time = stop_time - start_time
distance = (elapsed_time * 34300) / 2
# Distance en cm
return distance
try:
while True:
# Étape 1 : Vérification de la présence
print("Vérification de la présence...")
distance = measure_distance()
print(f"Distance mesurée : {distance} cm")
if distance < 50:
# Si une personne est proche
print("Présence détectée. Veuillez scanner votre tag
RFID.")
# Étape 2 : Authentification RFID
id, text = reader.read()
print(f"ID lu : {id}")
if str(text).strip() == AUTHORIZED_TAG:
print("Tag valide. Accès autorisé.")
GPIO.output(led_green, GPIO.HIGH) # Allumer LED
verte
sleep(5)
# Maintenir l'accès pendant 5 secondes
GPIO.output(led_green, GPIO.LOW) # Éteindre LED
verte
else:
print("Tag invalide. Accès refusé.")
GPIO.output(led_red, GPIO.HIGH)
# Allumer LED
rouge
sleep(3)
# Maintenir l'état pendant 3 secondes
GPIO.output(led_red, GPIO.LOW)
rouge
# Éteindre LED
else:
print("Aucune présence détectée. Veille...")
sleep(1)
except KeyboardInterrupt:
print("Programme arrêté par l'utilisateur.")
finally:
GPIO.cleanup()
TKINTER ET RFID
import tkinter as tk
import RPi.GPIO as GPIO
from mfrc522 import SimpleMFRC522
# Fonction pour écrire sur le tag RFID
def write_to_rfid():
text = entry.get()
if not text:
print("Erreur : Veuillez saisir un texte à écrire.")
return
try:
reader = SimpleMFRC522()
print("Placez le tag RFID près du lecteur...")
reader.write(text)
print("Succès : Le texte a été écrit sur le tag RFID.")
except Exception as e:
print(f"Erreur : {str(e)}")
finally:
GPIO.cleanup()
# Création de la fenêtre principale
window = tk.Tk()
root.title("Écrire sur un Tag RFID")
# l'interface utilisateur
entry = tk.Entry(window, width=30)
entry.pack(pady=10)
write_button = tk.Button(window, text="Écrire sur le Tag RFID",
command=write_to_rfid)
write_button.pack(pady=20)
# Boucle principale
window.mainloop()
RFID, UTRASON & SERVOMOTEUR
import RPi.GPIO as GPIO
from mfrc522 import SimpleMFRC522
from time import sleep
import time
# Configuration des broches GPIO
SERVO_PIN = 11
LED_VERT = 13
LED_ROUGE = 15
TRIG = 16
ECHO = 18
# Tag RFID autorise
TAG_AUTORISE = "123456"
# Remplacer par l ID de votre tag
# Configuration des GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(SERVO_PIN, GPIO.OUT)
GPIO.setup(LED_VERT, GPIO.OUT)
GPIO.setup(LED_ROUGE, GPIO.OUT)
GPIO.setup(TRIG, GPIO.OUT)
GPIO.setup(ECHO, GPIO.IN)
# Initialisation du lecteur RFID
reader = SimpleMFRC522()
# Initialisation du servo moteur
servo = GPIO.PWM(SERVO_PIN, 50)
servo.start(7.5)
# Frequence 50 Hz
# Position neutre (barriere fermee)
# Fonction pour mesurer la distance avec le capteur ultrason
def mesurer_distance():
GPIO.output(TRIG, GPIO.LOW)
sleep(0.1)
GPIO.output(TRIG, GPIO.HIGH)
sleep(0.00001)
GPIO.output(TRIG, GPIO.LOW)
while GPIO.input(ECHO) == GPIO.LOW:
debut_pulse = time.time()
while GPIO.input(ECHO) == GPIO.HIGH:
fin_pulse = time.time()
duree_pulse = fin_pulse - debut_pulse
distance = duree_pulse * 34300 / 2
# Distance en cm
return distance
# Fonction pour ouvrir la barriere
def ouvrir_barriere():
print("Ouverture de la barriere...")
servo.ChangeDutyCycle(12)
# Tourner le servo a 90 degres
sleep(1)
servo.ChangeDutyCycle(0)
# Arreter le signal PWM
# Fonction pour fermer la barriere
def fermer_barriere():
print("Fermeture de la barriere...")
servo.ChangeDutyCycle(7.5)
# Remettre le servo a 0 degres
sleep(1)
servo.ChangeDutyCycle(0)
try:
while True:
# Arreter le signal PWM
print("Scanner votre tag RFID...")
texte, id = reader.read()
# Lire le tag RFID
print(f"ID du tag : {id}")
if str(id).strip() == TAG_AUTORISE:
print("Acces autorise.")
GPIO.output(LED_VERT, GPIO.HIGH)
GPIO.output(LED_ROUGE, GPIO.LOW)
ouvrir_barriere()
# Maintenir la barriere ouverte tant que la voiture
est detectee
while True:
distance = mesurer_distance()
print(f"Distance mesuree : {distance:.2f} cm")
if distance > 200:
fermer la barriere
# Si distance > 2 metres,
break
sleep(0.5)
fermer_barriere()
GPIO.output(LED_VERT, GPIO.LOW)
else:
print("Acces refuse.")
GPIO.output(LED_ROUGE, GPIO.HIGH)
GPIO.output(LED_VERT, GPIO.LOW)
sleep(3)
GPIO.output(LED_ROUGE, GPIO.LOW)
except KeyboardInterrupt:
print("Programme arrete par l utilisateur.")
finally:
servo.stop()
GPIO.cleanup()
Caméra Setup
sudo apt install python3-opencv
v4l2-ctl --list-devices
import cv2
cam = cv2.VideoCapture(0)
while True:
ret, image = cam.read()
cv2.imshow('Imagetest',image)
k = cv2.waitKey(1)
if k != -1:
break
cv2.imwrite('/home/pi/testimage.jpg', image)
cam.release()
cv2.destroyAllWindows()
camera OpenCV matricule
import cv2
import pytesseract
# Load the image
image_path = "…….."
# Replace with the path to your image
image = cv2.imread(image_path)
# Convert the image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Apply bilateral filtering to reduce noise
gray = cv2.bilateralFilter(gray, 11, 17, 17)
# Edge detection to identify the plate
edged = cv2.Canny(gray, 30, 200)
# Find contours in the image
contours,
_
=
cv2.findContours(edged,
cv2.CHAIN_APPROX_SIMPLE)
contours
=
reverse=True)[:10]
sorted(contours,
cv2.RETR_TREE,
key=cv2.contourArea,
plate_contour = None
# Look for a rectangular region to detect the plate
for contour in contours:
peri = cv2.arcLength(contour, True)
approx = cv2.approxPolyDP(contour, 0.018 * peri, True)
# If the shape is rectangular, assume it is the plate
if len(approx) == 4:
plate_contour = approx
x, y, w, h = cv2.boundingRect(contour)
plate = gray[y:y + h, x:x + w]
break
if plate_contour is None:
print("License plate not detected.")
else:
# Optional: draw the detected plate
cv2.drawContours(image, [plate_contour], -1, (0, 255, 0), 3)
# Preprocess the plate to improve OCR accuracy
plate
=
cv2.resize(plate,
interpolation=cv2.INTER_CUBIC)
None,
fx=2,
_,
plate_thresh
=
cv2.threshold(plate,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
0,
fy=2,
255,
# Extract the text from the plate with OCR (including Arabic
and English languages)
text = pytesseract.image_to_string(plate_thresh, config="-psm 8", lang="ara+eng")
print("License plate text:", text)
# Display the results (use OpenCV's imshow if you have a
monitor connected)
cv2.imshow("Processed Plate", plate_thresh)
processed plate
# Show the
cv2.imshow("Original Image", image)
original image with the plate highlighted
# Show the
cv2.waitKey(0)
cv2.destroyAllWindows()
Cv2 camera
import cv2
import pytesseract
import re
import time
# Configurer la caméra Raspberry Pi
camera = cv2.VideoCapture(0)
# Attendre avant de capturer l'image
time.sleep(2)
while True:
# Capturer l'image
ret, image = camera.read()
if not ret:
print("Error: The image could not be captured. Please
check the camera.")
continue
# Redimensionner l'image à 50% de sa taille originale
width = int(image.shape[1] * 0.5)
height = int(image.shape[0] * 0.5)
image_resized = cv2.resize(image, (width, height))
# Convertir l'image en niveaux de gris
gray = cv2.cvtColor(image_resized, cv2.COLOR_BGR2GRAY)
# Appliquer un filtrage pour réduire le bruit
gray = cv2.bilateralFilter(gray, 11, 17, 17)
# Détection des contours pour identifier la plaque
edged = cv2.Canny(gray, 30, 200)
# Trouver les contours dans l'image
contours,
_
=
cv2.findContours(edged,
cv2.CHAIN_APPROX_SIMPLE)
contours
=
reverse=True)[:10]
sorted(contours,
cv2.RETR_TREE,
key=cv2.contourArea,
plate_contour = None
# Rechercher
plaque
une
région
rectangulaire
pour
détecter
la
for contour in contours:
peri = cv2.arcLength(contour, True)
approx = cv2.approxPolyDP(contour, 0.018 * peri, True)
# Si la forme est rectangulaire, on suppose que c'est la
plaque
if len(approx) == 4:
plate_contour = approx
x, y, w, h = cv2.boundingRect(contour)
plate = gray[y:y+h, x:x+w]
break
if plate_contour is None:
print("No license plate detected. Try another image.")
else:
# Optionnel : affichage de la plaque encadrée
cv2.drawContours(image_resized,
(0, 255, 0), 3)
[plate_contour],
-1,
# Prétraitement pour améliorer la précision de l'OCR
plate
=
cv2.resize(plate,
interpolation=cv2.INTER_CUBIC)
_, plate_thresh
cv2.THRESH_BINARY)
=
None,
fx=2,
cv2.threshold(plate,
150,
fy=2,
255,
# Extraire le texte de la plaque
raw_text = pytesseract.image_to_string(plate_thresh,
lang='ara+eng', config="--psm 8")
# Supprimer les caractères spéciaux
cleaned_text = re.sub(r'[^\w\s]', '', raw_text).strip()
# Afficher les résultats
print("Raw extracted text:", raw_text)
print("Cleaned text:", cleaned_text)
# Afficher les images sur le Raspberry Pi
cv2.imshow("Processed Plate", plate_thresh)
l'image traitée de la plaque
# Afficher
cv2.imshow("Original Image", image_resized)
l'image originale avec la plaque encadrée
# Afficher
# Sortie sur 'q' (appuyez sur 'q' pour sortir)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# Libérer les ressources
camera.release()
cv2.destroyAllWindows()
APPLICATION SQLITE AVCE TKINTER ET RFID
sudo apt-get install sqlite3
sudo apt install snapd
sudo reboot
sudo snap install snapd
sudo snap install sqlitebrowser
code
import sqlite3
import tkinter as tk
from tkinter import messagebox
from mfrc522 import SimpleMFRC522
import RPi.GPIO as GPIO
import time
# Initialiser le lecteur RFID
reader = SimpleMFRC522()
# Configurer la LED sur GPIO 18
LED_PIN = 18
GPIO.setmode(GPIO.BCM)
GPIO.setup(LED_PIN, GPIO.OUT)
# Créer une connexion à la base de données SQLite
conn = sqlite3.connect("rfid_database.db")
cursor = conn.cursor()
# Créer la table `rfid_users` si elle n'existe pas déjà
cursor.execute("""
CREATE TABLE IF NOT EXISTS rfid_users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
tag_number TEXT NOT NULL UNIQUE
)
""")
conn.commit()
# Fonction pour écrire sur le tag RFID
def write_to_tag(name):
try:
print("Approchez le tag RFID pour écrire...")
reader.write(name)
print("Écriture réussie sur le tag RFID !")
messagebox.showinfo("Succès", "Écriture réussie sur le
tag RFID !")
except Exception as e:
print(f"Erreur lors de l'écriture : {e}")
messagebox.showerror("Erreur",
l'écriture : {e}")
f"Erreur
lors
de
finally:
GPIO.cleanup()
# Fonction pour enregistrer un utilisateur dans la base de
données
def register_user():
name = entry_name.get().strip()
if not name:
messagebox.showerror("Erreur", "Le nom ne peut pas être
vide.")
return
try:
# Lire l'ID du tag RFID
print("Approchez le tag RFID pour lire son numéro...")
tag_id, _ = reader.read()
tag_number = str(tag_id)
# Écrire le nom sur le tag RFID
write_to_tag(name)
# Insérer l'utilisateur dans la base de données
cursor.execute("INSERT
INTO
rfid_users
tag_number) VALUES (?, ?)", (name, tag_number))
(name,
conn.commit()
messagebox.showinfo("Succès",
enregistré avec succès !")
f"Utilisateur
'{name}'
entry_name.delete(0, tk.END)
saisie après enregistrement
# Effacer le champ de
except sqlite3.IntegrityError:
messagebox.showerror("Erreur", "Ce tag RFID est déjà
enregistré.")
except Exception as e:
print(f"Erreur : {e}")
messagebox.showerror("Erreur", f"Erreur : {e}")
finally:
GPIO.cleanup()
# Fonction pour scanner un tag RFID
def scan_tag():
try:
print("Approchez le tag RFID pour vérifier...")
tag_id, _ = reader.read()
tag_number = str(tag_id)
# Vérifiez si le tag existe dans la base de données
cursor.execute("SELECT name
tag_number = ?", (tag_number,))
result = cursor.fetchone()
FROM
rfid_users
WHERE
if result:
name = result[0]
print(f"Tag valide ! Utilisateur : {name}")
messagebox.showinfo("Succès",
f"Bienvenue,
{name}
!")
# Allumer la LED pour indiquer le succès
GPIO.output(LED_PIN, GPIO.HIGH)
time.sleep(2)
# Garder la LED allumée pendant 2
secondes
GPIO.output(LED_PIN, GPIO.LOW)
else:
print("Tag non reconnu.")
messagebox.showerror("Erreur", "Tag non reconnu.")
except Exception as e:
print(f"Erreur : {e}")
messagebox.showerror("Erreur", f"Erreur : {e}")
finally:
GPIO.cleanup()
# Interface graphique Tkinter
root = tk.Tk()
root.title("Enregistrement et Scanner RFID")
# Section pour enregistrer un utilisateur
label_name = tk.Label(root, text="Nom de l'utilisateur :")
label_name.grid(row=0, column=0, padx=10, pady=10)
entry_name = tk.Entry(root, width=30)
entry_name.grid(row=0, column=1, padx=10, pady=10)
btn_register
=
tk.Button(root,
command=register_user)
text="Enregistrer",
btn_register.grid(row=1, column=0, columnspan=2, pady=10)
# Section pour scanner un tag
btn_scan
=
tk.Button(root,
command=scan_tag)
text="Scanner
un
tag",
btn_scan.grid(row=2, column=0, columnspan=2, pady=10)
# Démarrer l'application Tkinter
root.mainloop()
# Fermer la connexion à la base de données
conn.close()
Enregistrement d’une empreinte
from pyfingerprint.pyfingerprint import PyFingerprint
import time
try:
# Initialisation du capteur d empreintes
sensor = PyFingerprint('/dev/ttyUSB0', 57600, 0xFFFFFFFF,
0x00000000)
if not sensor.verifyPassword():
raise ValueError("Erreur : Impossible de verifier le mot
de passe du capteur")
print("Empreintes
enregistrees
{}/{}".format(sensor.getTemplateCount(),
sensor.getStorageCapacity()))
:
# Premiere lecture de l empreinte
print("Placez votre doigt sur le capteur...")
while not sensor.readImage():
pass
sensor.convertImage(0x01)
# Verification si l empreinte existe deja
result = sensor.searchTemplate()
if result[0] >= 0:
print("Cette empreinte
{}".format(result[0]))
existe
deja
a
else:
print("Retirez votre doigt...")
time.sleep(2)
# Deuxieme lecture de la meme empreinte
print("Placez a nouveau le meme doigt...")
while not sensor.readImage():
pass
sensor.convertImage(0x02)
# Comparaison des deux lectures
la
position
if sensor.compareCharacteristics() == 0:
print("Les
Reessayez.")
empreintes
ne
correspondent
pas.
else:
# Enregistrement de l empreinte
sensor.createTemplate()
position = sensor.storeTemplate()
print("Empreinte enregistree
position {}".format(position))
except Exception as e:
print("Erreur : {}".format(e))
avec
succes
a
la
Empreinte vérification
from pyfingerprint.pyfingerprint import PyFingerprint
try:
# Configure the fingerprint sensor
sensor = PyFingerprint('/dev/ttyAMA0', 57600, 0xFFFFFFFF,
0x00000000)
if not sensor.verifyPassword():
raise ValueError('Failed to verify fingerprint sensor
password')
print('Sensor initialized.')
print(f'Templates stored: {sensor.getTemplateCount()}')
while True:
print('Waiting for finger...')
while not sensor.readImage():
pass
sensor.convertImage(0x01)
# Search for a match
result = sensor.searchTemplate()
position = result[0]
accuracy = result[1]
if position == -1:
print('No match found.')
else:
print(f'Match
Accuracy: {accuracy}')
except Exception as e:
print('Error:', e)
found!
Position:
{position},
Empreinte SERVO
from pyfingerprint.pyfingerprint import PyFingerprint
import RPi.GPIO as GPIO
from time import sleep
# Configuration GPIO pour le servo moteur
SERVO_PIN = 11
# Numero du pin GPIO pour le servo
GPIO.setmode(GPIO.BOARD)
GPIO.setup(SERVO_PIN, GPIO.OUT)
# Initialisation du servo moteur
servo = GPIO.PWM(SERVO_PIN, 50)
servo.start(7.5)
# Servo a 50 Hz
# Position initiale (barriere fermee)
# Fonction pour ouvrir la barriere
def ouvrir_barriere():
print("Ouverture de la barriere...")
servo.ChangeDutyCycle(12)
# Tourner le servo a 90 degres
sleep(1)
servo.ChangeDutyCycle(0)
# Arreter le PWM
# Fonction pour fermer la barriere
def fermer_barriere():
print("Fermeture de la barriere...")
servo.ChangeDutyCycle(7.5)
# Retourner le servo a 0 degres
sleep(1)
servo.ChangeDutyCycle(0)
# Arreter le PWM
try:
# Configuration du capteur d empreinte
sensor = PyFingerprint('/dev/ttyAMA0', 57600, 0xFFFFFFFF,
0x00000000)
if not sensor.verifyPassword():
raise ValueError('Echec de la verification du mot de
passe du capteur d empreinte')
print('Capteur initialise.')
print('Empreintes
enregistrees
{}'.format(sensor.getTemplateCount()))
:
while True:
print('En attente d une empreinte...')
# Attente qu une empreinte soit placee
while not sensor.readImage():
pass
sensor.convertImage(0x01)
# Recherche une correspondance
result = sensor.searchTemplate()
position = result[0]
precision = result[1]
if position == -1:
print('Aucune correspondance trouvee.')
else:
print('Correspondance trouvee !
Precision : {}'.format(position, precision))
Position
:
{},
ouvrir_barriere()
empreinte est reconnue
barriere
si
une
sleep(5)
#
Ouvre
la
# Garde la barriere ouverte pendant 5
secondes
fermer_barriere()
#
Ferme
la
barriere
secondes
except Exception as e:
print('Erreur :', e)
finally:
servo.stop()
GPIO.cleanup()
# Arreter le PWM du servo
# Reinitialiser les GPIO
SERVO EMPREINTE DISTANCE
from pyfingerprint.pyfingerprint import PyFingerprint
import RPi.GPIO as GPIO
from time import sleep, time
apres
5
# GPIO configuration for the servo motor
SERVO_PIN = 11
# GPIO pin number for the servo motor
TRIG_PIN = 16
# TRIG pin for the distance sensor
ECHO_PIN = 18
# ECHO pin for the distance sensor
GPIO.setmode(GPIO.BOARD)
GPIO.setup(SERVO_PIN, GPIO.OUT)
GPIO.setup(TRIG_PIN, GPIO.OUT)
GPIO.setup(ECHO_PIN, GPIO.IN)
# Initialize the servo motor
servo = GPIO.PWM(SERVO_PIN, 50)
servo.start(7.5)
# Servo at 50 Hz
# Initial position (barrier closed)
# Function to measure distance
def measure_distance():
GPIO.output(TRIG_PIN, False)
sleep(0.1)
# Send a pulse
GPIO.output(TRIG_PIN, True)
sleep(0.00001)
GPIO.output(TRIG_PIN, False)
# Calculate the duration of the ECHO signal
while GPIO.input(ECHO_PIN) == 0:
pulse_start = time()
while GPIO.input(ECHO_PIN) == 1:
pulse_end = time()
# Calculate the distance
pulse_duration = pulse_end - pulse_start
distance = pulse_duration * 17150
distance = round(distance, 2)
return distance
# Convert duration to cm
# Function to open the barrier
def open_barrier():
print("Opening the barrier...")
servo.ChangeDutyCycle(12)
# Rotate the servo to 90 degrees
sleep(1)
servo.ChangeDutyCycle(0)
# Stop the PWM
# Function to close the barrier
def close_barrier():
print("Attempting to close the barrier...")
while True:
distance = measure_distance()
print(f"Measured distance: {distance} cm")
if distance >= 20:
# Close only if the distance is >=
20 cm
print("Closing the barrier...")
servo.ChangeDutyCycle(7.5)
to 0 degrees
# Rotate the servo back
sleep(1)
servo.ChangeDutyCycle(0)
# Stop the PWM
break
else:
print("Obstacle
detected.
The
barrier
remains
open.")
sleep(1)
try:
# Fingerprint sensor configuration
sensor = PyFingerprint('/dev/ttyUSB0', 57600, 0xFFFFFFFF,
0x00000000)
if not sensor.verifyPassword():
raise ValueError('Failed
sensor password')
to
verify
the
fingerprint
print('Sensor initialized.')
print(f'Registered
{sensor.getTemplateCount()}')
fingerprints:
while True:
print('Waiting for a fingerprint...')
# Wait for a fingerprint to be placed
while not sensor.readImage():
pass
sensor.convertImage(0x01)
# Search for a match
result = sensor.searchTemplate()
position = result[0]
accuracy = result[1]
if position == -1:
print('No match found.')
else:
print(f'Match
Accuracy: {accuracy}')
found!
open_barrier()
is recognized
# Open the barrier if a fingerprint
sleep(5)
Position:
# Keep the barrier open for 5 seconds
close_barrier()
if no obstruction
# Close the barrier after 5 seconds
except Exception as e:
print('Error:', e)
finally:
servo.stop()
GPIO.cleanup()
{position},
# Stop the servo motor PWM
# Reset GPIO pins