Bemerkung

Hallo und willkommen in der SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasten-Gemeinschaft auf Facebook! Tauchen Sie tiefer ein in die Welt von Raspberry Pi, Arduino und ESP32 mit anderen Enthusiasten.

Warum beitreten?

  • Expertenunterstützung: Lösen Sie Nachverkaufsprobleme und technische Herausforderungen mit Hilfe unserer Gemeinschaft und unseres Teams.

  • Lernen & Teilen: Tauschen Sie Tipps und Anleitungen aus, um Ihre Fähigkeiten zu verbessern.

  • Exklusive Vorschauen: Erhalten Sie frühzeitigen Zugang zu neuen Produktankündigungen und exklusiven Einblicken.

  • Spezialrabatte: Genießen Sie exklusive Rabatte auf unsere neuesten Produkte.

  • Festliche Aktionen und Gewinnspiele: Nehmen Sie an Gewinnspielen und Feiertagsaktionen teil.

👉 Sind Sie bereit, mit uns zu erkunden und zu erschaffen? Klicken Sie auf [hier] und treten Sie heute bei!

4.1.15 Alarmglocke

Einführung

In diesem Projekt werden wir ein manuelles Alarmsystem erstellen. Sie können den Kippschalter durch einen Thermistor oder einen lichtempfindlichen Sensor ersetzen, um einen Temperaturalarm oder einen Lichtalarm zu erstellen.

Erforderliche Komponenten

Für dieses Projekt benötigen wir die folgenden Komponenten.

../_images/list_Alarm_Bell.png

Es ist sicherlich praktisch, ein gesamtes Kit zu kaufen, hier ist der Link:

Name

ARTIKEL IN DIESEM KIT

LINK

Raphael Kit

337

Raphael Kit

Sie können sie auch einzeln über die untenstehenden Links kaufen.

KOMPONENTENBESCHREIBUNG

KAUF-LINK

GPIO-Erweiterungsplatine

BUY

Steckbrett

BUY

Jumper-Kabel

BUY

Widerstand

BUY

LED

BUY

Summer

BUY

Schiebeschalter

BUY

Transistor

BUY

Kondensator

BUY

Schaltbild

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/Schematic_three_one10.png

Experimentelle Verfahren

Schritt 1: Schalten Sie den Stromkreis.

../_images/image266.png

Schritt 2: Verzeichnis wechseln.

cd ~/raphael-kit/python/

Schritt 3: Ausführen.

sudo python3 4.1.15_AlarmBell.py

Nach dem Start des Programms wird der Kippschalter nach rechts geschaltet und der Summer gibt Alarmsignale aus. Gleichzeitig blinken die roten und grünen LEDs mit einer bestimmten Frequenz.

Code

Bemerkung

Sie können den untenstehenden Code Modifizieren/Zurücksetzen/Kopieren/Ausführen/Stoppen. Davor müssen Sie jedoch zum Quellcode-Pfad, wie raphael-kit/python, navigieren.

#!/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()

Code-Erklärung

import threading

Hier importieren wir das Modul Threading, welches es ermöglicht, mehrere Dinge gleichzeitig zu tun, während normale Programme Code nur von oben nach unten ausführen können. Mit den Threading-Modulen können die LED und der Summer getrennt voneinander arbeiten.

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)

Die Funktion ledWork() hilft, den Arbeitszustand dieser 2 LEDs zu definieren: Sie lässt die grüne LED für 0,5s leuchten und schaltet sie dann aus; ebenso lässt sie die rote LED für 0,5s leuchten und schaltet sie dann aus.

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)

Die Funktion buzzWork() wird verwendet, um den Arbeitszustand des Summers zu definieren. Hier setzen wir die Frequenz zwischen 130 und 800 und lassen sie in einem Intervall von 20 ansteigen oder abfallen.

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

In der Funktion on() :

  1. Definieren Sie die Marke „flag=1“, die das Ende des Steuerthreads anzeigt.

  2. Starten Sie den Summer und setzen Sie den Tastverhältnis auf 50%.

  3. Erstellen Sie 2 separate Threads, damit die LED und der Summer gleichzeitig arbeiten können.

Die Funktion threading.Thread() wird verwendet, um den Thread zu erstellen, und ihr Prototyp lautet:

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

Unter den Konstruktionsmethoden ist target der Hauptparameter, wir müssen ein aufrufbares Objekt (hier die Funktionen ledWork und BuzzWork) zu target zuweisen.

Danach wird start() aufgerufen, um das Thread-Objekt zu starten, z.B. wird tBuzz.start() verwendet, um den neu installierten Thread tBuzz zu starten.

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

Die Funktion Off() definiert „flag=0“, um die Threads ledWork und BuzzWork zu beenden und dann den Summer und die LED auszuschalten.

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() enthält den gesamten Ablauf des Programms: Zuerst wird der Wert des Schiebeschalters gelesen; wenn der Kippschalter nach rechts geschaltet ist (der Wert ist 1), wird die Funktion on() aufgerufen, der Summer gibt Töne aus und die rote und die grüne LED blinken. Andernfalls arbeiten der Summer und die LED nicht.

Phänomen-Bild

../_images/image267.jpeg