Nota

Ciao, benvenuto nella community di appassionati di SunFounder Raspberry Pi, Arduino & ESP32 su Facebook! Approfondisci l’utilizzo di Raspberry Pi, Arduino e ESP32 insieme ad altri appassionati.

Perché Unirsi?

Supporto Esperto: Risolvi i problemi post-vendita e le sfide tecniche con l’aiuto della nostra community e del nostro team.
Impara & Condividi: Scambia suggerimenti e tutorial per migliorare le tue competenze.
Anteprime Esclusive: Ottieni accesso anticipato agli annunci dei nuovi prodotti e anteprime esclusive.
Sconti Speciali: Goditi sconti esclusivi sui nostri prodotti più recenti.
Promozioni Festive e Giveaway: Partecipa a promozioni e giveaway durante le festività.

👉 Pronto a esplorare e creare con noi? Clicca [Qui] e unisciti oggi stesso!

4.1.15 Campanello d’Allarme

Introduzione

In questo progetto, realizzeremo un dispositivo di allarme manuale. Puoi sostituire l’interruttore a levetta con un termistore o un sensore fotosensibile per creare un allarme temperatura o un allarme luminoso.

Componenti Necessari

Per questo progetto, avremo bisogno dei seguenti componenti.

È sicuramente conveniente acquistare un intero kit, ecco il link:

Nome	ELEMENTI IN QUESTO KIT	LINK
Raphael Kit	337	Raphael Kit

Puoi anche acquistarli separatamente dai link seguenti.

INTRODUZIONE COMPONENTE	LINK PER L’ACQUISTO
Scheda di estensione GPIO	ACQUISTA
Breadboard	ACQUISTA
Cavi Jumper	ACQUISTA
Resistore	ACQUISTA
LED	ACQUISTA
Cicalino	ACQUISTA
Interruttore a Scorrimento	ACQUISTA
Transistor	ACQUISTA
Condensatore	ACQUISTA

Schema del Circuito

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

Procedure Sperimentali

Passo 1: Costruisci il circuito.

Passo 2: Cambia la directory.

cd ~/raphael-kit/python/

Passo 3: Esegui.

sudo python3 4.1.15_AlarmBell.py

Dopo l’avvio del programma, l’interruttore a levetta verrà spostato verso destra, e il cicalino emetterà suoni di allarme. Allo stesso tempo, i LED rosso e verde lampeggeranno a una certa frequenza.

Codice

Nota

Puoi Modificare/Resettare/Copiare/Eseguire/Fermare il codice qui sotto. Ma prima devi accedere al percorso del codice sorgente come 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()

Spiegazione del Codice

import threading

Qui, importiamo il modulo Threading che ti permette di eseguire più operazioni contemporaneamente, mentre i programmi normali possono eseguire il codice solo dall’alto verso il basso. Con il modulo Threading, il LED e il cicalino possono funzionare separatamente.

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 funzione ledWork() imposta lo stato operativo dei 2 LED: mantiene acceso il LED verde per 0,5s e poi lo spegne; allo stesso modo, mantiene acceso il LED rosso per 0,5s e poi lo spegne.

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 funzione buzzerWork() è utilizzata per impostare lo stato operativo del cicalino. Qui impostiamo la frequenza tra 130 e 800, per accumulare o decrescere a intervalli di 20.

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

Nella funzione on() :

Definiamo la variabile flag=1, che indica l’inizio del controllo del thread.
Avviamo il cicalino, impostando il ciclo di lavoro al 50%.
Creiamo 2 thread separati affinché i LED e il cicalino possano funzionare contemporaneamente.

La funzione threading.Thread() viene utilizzata per creare il thread e il suo prototipo è il seguente:

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

Tra i metodi di costruzione, il parametro principale è target, dobbiamo assegnare un oggetto callable (in questo caso le funzioni ledWork e buzzerWork) al parametro target.

Successivamente, start() viene chiamato per avviare l’oggetto thread, ad esempio, tBuzz.start() avvia il nuovo thread tBuzz.

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

La funzione off() definisce flag=0 per uscire dai thread ledWork e buzzerWork e quindi spegnere il cicalino e i LED.

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

main() contiene l’intero processo del programma: innanzitutto legge il valore dell’interruttore a slitta; se l’interruttore è spostato a destra (il valore di lettura è 1), viene chiamata la funzione on(), e il cicalino viene attivato per emettere suoni mentre i LED rosso e verde lampeggiano. Altrimenti, il cicalino e i LED non funzionano.