Note

Bonjour et bienvenue dans la Communauté Facebook des passionnés de Raspberry Pi, Arduino et ESP32 de SunFounder ! Plongez plus profondément dans l’univers des Raspberry Pi, Arduino et ESP32 avec d’autres passionnés.

Pourquoi rejoindre ?

Support d’experts : Résolvez les problèmes après-vente et les défis techniques avec l’aide de notre communauté et de notre équipe.
Apprendre et partager : Échangez des astuces et des tutoriels pour améliorer vos compétences.
Aperçus exclusifs : Accédez en avant-première aux annonces de nouveaux produits et aux aperçus.
Réductions spéciales : Profitez de réductions exclusives sur nos produits les plus récents.
Promotions festives et cadeaux : Participez à des cadeaux et des promotions de vacances.

👉 Prêt à explorer et à créer avec nous ? Cliquez [Ici] et rejoignez-nous aujourd’hui !

4.1.15 Alarme

Introduction

Dans ce projet, nous allons créer un dispositif d’alarme manuel. Vous pouvez remplacer l’interrupteur à bascule par un thermistor ou un capteur photosensible pour créer une alarme de température ou de lumière.

Composants Requis

Pour ce projet, nous avons besoin des composants suivants.

Il est certainement pratique d’acheter un kit complet, voici le lien :

Nom	ÉLÉMENTS DANS CE KIT	LIEN
Kit Raphael	337	Raphael Kit

Vous pouvez également les acheter séparément à partir des liens ci-dessous.

INTRODUCTION DU COMPOSANT	LIEN D’ACHAT
Carte d’extension GPIO	ACHETER
Plaque d’expérimentation (Breadboard)	ACHETER
Fils de Liaison	ACHETER
Résistance	ACHETER
LED	ACHETER
Buzzer	ACHETER
Interrupteur à glissière	ACHETER
Transistor	ACHETER
Condensateur	ACHETER

Schéma de Câblage

Nom T-Board	physique	wiringPi	BCM
GPIO17	Pin 11	0	17
GPIO18	Pin 12	1	18
GPIO27	Pin 13	2	27
GPIO22	Pin 15	3	22

Procédures Expérimentales

Étape 1 : Construisez le circuit.

Étape 2 : Changez de répertoire.

cd ~/raphael-kit/python/

Étape 3 : Exécutez.

sudo python3 4.1.15_AlarmBell.py

Après le démarrage du programme, l’interrupteur à bascule sera basculé vers la droite et le buzzer émettra des sons d’alarme. En même temps, les LED rouges et vertes clignoteront à une certaine fréquence.

Code

Note

Vous pouvez Modifier/Réinitialiser/Copier/Exécuter/Arrêter le code ci-dessous. Mais avant cela, vous devez aller dans le chemin du code source comme raphael-kit/python.

#!/usr/bin/env python3

import RPi.GPIO as GPIO
import time
import threading

BeepPin=22
ALedPin=17
BLedPin=27
switchPin=18

Buzz=0
flag =0
note=150
pitch=20

def setup():
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(BeepPin, GPIO.OUT)
    GPIO.setup(ALedPin,GPIO.OUT,initial=GPIO.LOW)
    GPIO.setup(BLedPin,GPIO.OUT,initial=GPIO.LOW)
    GPIO.setup(switchPin,GPIO.IN)
    global Buzz
    Buzz=GPIO.PWM(BeepPin,note)

def ledWork():
    while flag:
        GPIO.output(ALedPin,GPIO.HIGH)
        time.sleep(0.5)
        GPIO.output(ALedPin,GPIO.LOW)
        GPIO.output(BLedPin,GPIO.HIGH)
        time.sleep(0.5)
        GPIO.output(BLedPin,GPIO.LOW)

def buzzerWork():
    global pitch
    global note
    while flag:
        if note >= 800 or note <=130:
            pitch = -pitch
        note = note + pitch
        Buzz.ChangeFrequency(note)
        time.sleep(0.01)

def on():
    global flag
    flag = 1
    Buzz.start(50)
    tBuzz = threading.Thread(target=buzzerWork)
    tBuzz.start()
    tLed = threading.Thread(target=ledWork)
    tLed.start()

def off():
    global flag
    flag = 0
    Buzz.stop()
    GPIO.output(ALedPin,GPIO.LOW)
    GPIO.output(BLedPin,GPIO.LOW)

def main():
    lastState=0
    while True:
        currentState =GPIO.input(switchPin)
        if currentState == 1 and lastState == 0:
            on()
        elif currentState == 0 and lastState == 1:
            off()
        lastState=currentState

def destroy():
    off()
    GPIO.cleanup()

if __name__ == '__main__':
    setup()
    try:
        main()
    except KeyboardInterrupt:
        destroy()

Explication du Code

import threading

Ici, nous importons le module Threading qui permet d’exécuter plusieurs tâches en même temps, alors que les programmes normaux ne peuvent exécuter le code que de haut en bas. Avec les modules Threading, la LED et le buzzer peuvent fonctionner séparément.

def ledWork():
    while flag:
        GPIO.output(ALedPin,GPIO.HIGH)
        time.sleep(0.5)
        GPIO.output(ALedPin,GPIO.LOW)
        GPIO.output(BLedPin,GPIO.HIGH)
        time.sleep(0.5)
        GPIO.output(BLedPin,GPIO.LOW)

La fonction ledWork() aide à définir l’état de fonctionnement de ces 2 LED : elle maintient la LED verte allumée pendant 0,5 s puis l’éteint ; de même, elle maintient la LED rouge allumée pendant 0,5 s puis l’éteint.

def buzzerWork():
    global pitch
    global note
    while flag:
        if note >= 800 or note <=130:
            pitch = -pitch
        note = note + pitch
        Buzz.ChangeFrequency(note)
        time.sleep(0.01)

La fonction buzzWork() est utilisée pour définir l’état de fonctionnement du buzzer. Ici, nous définissons la fréquence entre 130 et 800, pour accumuler ou diminuer à un intervalle de 20.

def on():
    global flag
    flag = 1
    Buzz.start(50)
    tBuzz = threading.Thread(target=buzzerWork)
    tBuzz.start()
    tLed = threading.Thread(target=ledWork)
    tLed.start()

Dans la fonction on() :

Définir le marqueur « flag=1 », indiquant la fin du thread de contrôle.
Démarrer le Buzz et régler le cycle de service à 50 %.
Créer 2 threads distincts pour que la LED et le buzzer puissent fonctionner en même temps.

La fonction threading.Thread() est utilisée pour créer le thread et son prototype est le suivant :

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

Parmi les méthodes de construction, le paramètre principal est target, nous devons assigner un objet appelable (ici les fonctions ledWork et BuzzWork) à target.

Ensuite, start() est appelé pour démarrer l’objet thread, par exemple, tBuzz.start() est utilisé pour démarrer le thread nouvellement installé tBuzz.

def off():
    global flag
    flag = 0
    Buzz.stop()
    GPIO.output(ALedPin,GPIO.LOW)
    GPIO.output(BLedPin,GPIO.LOW)

La fonction Off() définit « flag=0 » afin de quitter les threads ledWork et BuzzWork et ensuite éteindre le buzzer et les LED.

def main():
    lastState=0
    while True:
        currentState =GPIO.input(switchPin)
        if currentState == 1 et lastState == 0:
            on()
        elif currentState == 0 et lastState == 1:
            off()
        lastState=currentState

Main() contient l’ensemble du processus du programme : d’abord lire la valeur de l’interrupteur à glissière ; si l’interrupteur à bascule est basculé vers la droite (la lecture est 1), la fonction on() est appelée, le buzzer est actionné pour émettre des sons et les LED rouges et vertes clignotent. Sinon, le buzzer et les LED ne fonctionnent pas.