Nota

Ciao e benvenuto nella Community degli appassionati di SunFounder per Raspberry Pi, Arduino e ESP32 su Facebook! Esplora a fondo Raspberry Pi, Arduino e ESP32 con altri appassionati.

Perché unirsi?

  • Supporto Esperto: Risolvi problemi post-vendita e sfide tecniche con l’aiuto della nostra comunità e del nostro team.

  • Impara & Condividi: Scambia consigli e tutorial per migliorare le tue competenze.

  • Anteprime Esclusive: Ottieni l’accesso anticipato agli annunci di nuovi prodotti e alle anteprime.

  • Sconti Speciali: Godi di sconti esclusivi sui nostri prodotti più recenti.

  • Promozioni Festive e Giveaway: Partecipa ai giveaway e alle promozioni per le festività.

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

3.1.10 Campanello di 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 di temperatura o un allarme luminoso.

Componenti Necessari

Per questo progetto, sono necessari i seguenti componenti.

../_images/4.1.15_alarm_bell_list.png

Schema di Collegamento

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
../_images/4.1.15_alarm_bell_schematic.png

Procedure Sperimentali

Passo 1: Costruisci il circuito.

../_images/4.1.15_alarm_bell_circuit.png

Passo 2: Cambia directory.

cd ~/davinci-kit-for-raspberry-pi/python-pi5

Passo 3: Esegui il programma.

sudo python3 3.1.10_AlarmBell.py

Dopo l’avvio del programma, l’interruttore a levetta verrà spostato a destra, e il cicalino emetterà un suono di allarme. Contemporaneamente, i LED rosso e verde lampeggeranno a una certa frequenza.

Avvertimento

Se compare il messaggio di errore RuntimeError: Cannot determine SOC peripheral base address, fai riferimento a Se gpiozero non funziona.

Codice

Nota

Puoi Modificare/Reimpostare/Copiare/Eseguire/Interrompere il codice qui sotto. Tuttavia, prima di eseguire queste azioni, devi accedere al percorso sorgente del codice, ad esempio davinci-kit-for-raspberry-pi/python-pi5.

#!/usr/bin/env python3

from gpiozero import LED, Button, TonalBuzzer
import time
import threading

# Inizializzazione del TonalBuzzer sul pin GPIO 22
BeepPin = TonalBuzzer(22)

# Inizializzazione dei LED sui pin GPIO 17 e 27
ALedPin = LED(17)
BLedPin = LED(27)

# Inizializzazione del pulsante sul pin GPIO 18
switchPin = Button(18)

# Flag globale per controllare lo stato del buzzer e dei LED
flag = 0

def ledWork():
    """
    Control LED blinking pattern based on the flag state.
    When flag is set, alternately blink ALedPin and BLedPin.
    """
    while True:
        if flag:
            # Lampeggio alternato dei LED
            ALedPin.on()
            time.sleep(0.5)
            ALedPin.off()
            BLedPin.on()
            time.sleep(0.5)
            BLedPin.off()
        else:
            # Spegne entrambi i LED se il flag non è attivo
            ALedPin.off()
            BLedPin.off()

# Definisce una melodia come una lista di note e delle rispettive durate
tune = [
    ('C4', 0.1), ('E4', 0.1), ('G4', 0.1),
    (None, 0.1),
    ('E4', 0.1), ('G4', 0.1), ('C5', 0.1),
    (None, 0.1),
    ('C5', 0.1), ('G4', 0.1), ('E4', 0.1),
    (None, 0.1),
    ('G4', 0.1), ('E4', 0.1), ('C4', 0.1),
    (None, 0.1)
]

def buzzerWork():
    """
    Play a tune using the buzzer based on the flag state.
    The tune is played only when the flag is set.
    """
    while True:
        for note, duration in tune:
            if flag == 0:
                break
            print(note)  # Visualizza la nota corrente nella console
            BeepPin.play(note)  # Riproduce la nota corrente
            time.sleep(duration)  # Pausa per la durata della nota
        BeepPin.stop()  # Ferma il buzzer dopo aver riprodotto la melodia

def main():
    """
    Monitor button press to update the flag state.
    Sets the flag when the button is pressed.
    """
    global flag
    while True:
        flag = 1 if switchPin.is_pressed else 0

try:
    # Inizializza e avvia i thread per il controllo del buzzer e dei LED
    tBuzz = threading.Thread(target=buzzerWork)
    tBuzz.start()
    tLed = threading.Thread(target=ledWork)
    tLed.start()
    main()

except KeyboardInterrupt:
    # Ferma il buzzer e spegne i LED in caso di interruzione del programma
    BeepPin.stop()
    ALedPin.off()
    BLedPin.off()

Spiegazione del Codice

  1. Questa sezione include l’importazione delle librerie essenziali per implementare ritardi e threading. Vengono anche importate le classi LED, Button e TonalBuzzer dalla libreria gpiozero, indispensabili per controllare i dispositivi GPIO su un Raspberry Pi.

    #!/usr/bin/env python3

from gpiozero import LED, Button, TonalBuzzer
import time
import threading

  2. Configura un buzzer sul pin GPIO 22, due LED sui pin GPIO 17 e 27 e inizializza un pulsante sul pin GPIO 18. Inoltre, viene definito un flag globale per gestire lo stato del buzzer e dei LED.

    # Inizializza il TonalBuzzer sul pin GPIO 22
BeepPin = TonalBuzzer(22)

# Inizializza i LED sui pin GPIO 17 e 27
ALedPin = LED(17)
BLedPin = LED(27)

# Inizializza il pulsante sul pin GPIO 18
switchPin = Button(18)

# Flag globale per controllare lo stato del buzzer e dei LED
flag = 0

  3. Questa funzione controlla il lampeggio dei LED in base allo stato del flag. Se il flag è impostato (1), i LED si alternano accendendosi e spegnendosi. Se non impostato (0), entrambi i LED sono spenti.

    def ledWork():
    """
    Control LED blinking pattern based on the flag state.
    When flag is set, alternately blink ALedPin and BLedPin.
    """
    while True:
        if flag:
            # Lampeggio alternato dei LED
            ALedPin.on()
            time.sleep(0.5)
            ALedPin.off()
            BLedPin.on()
            time.sleep(0.5)
            BLedPin.off()
        else:
            # Spegne entrambi i LED se il flag non è impostato
            ALedPin.off()
            BLedPin.off()

  4. La melodia è definita come una sequenza di note (frequenza) e durate (secondi).

    # Definisce la melodia come una lista di note e delle rispettive durate
tune = [
    ('C4', 0.1), ('E4', 0.1), ('G4', 0.1),
    (None, 0.1),
    ('E4', 0.1), ('G4', 0.1), ('C5', 0.1),
    (None, 0.1),
    ('C5', 0.1), ('G4', 0.1), ('E4', 0.1),
    (None, 0.1),
    ('G4', 0.1), ('E4', 0.1), ('C4', 0.1),
    (None, 0.1)
]

  5. Riproduce una melodia predefinita quando il flag è impostato. La melodia si interrompe se il flag viene disattivato durante la riproduzione.

    def buzzerWork():
    """
    Play a tune using the buzzer based on the flag state.
    The tune is played only when the flag is set.
    """
    while True:
        for note, duration in tune:
            if flag == 0:
                break
            print(note)  # Mostra la nota corrente nella console
            BeepPin.play(note)  # Riproduce la nota corrente
            time.sleep(duration)  # Pausa per la durata della nota
        BeepPin.stop()  # Ferma il buzzer dopo aver riprodotto la melodia

  6. Controlla continuamente lo stato del pulsante per impostare o disattivare il flag.

    def main():
    """
    Monitor button press to update the flag state.
    Sets the flag when the button is pressed.
    """
    global flag
    while True:
        flag = 1 if switchPin.is_pressed else 0

  7. I thread per buzzerWork e ledWork vengono avviati, permettendo loro di funzionare contemporaneamente alla funzione principale.

    try:
    # Inizializza e avvia i thread per il controllo del buzzer e dei LED
    tBuzz = threading.Thread(target=buzzerWork)
    tBuzz.start()
    tLed = threading.Thread(target=ledWork)
    tLed.start()
    main()

  8. Ferma il buzzer e spegne i LED quando il programma viene interrotto, garantendo un’uscita pulita.

    except KeyboardInterrupt:
    # Ferma il buzzer e spegne i LED all'interruzione del programma
    BeepPin.stop()
    ALedPin.off()
    BLedPin.off()