Bemerkung

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

Warum beitreten?

  • Expertenunterstützung: Lösen Sie Probleme nach dem Kauf und technische Herausforderungen mit Hilfe unserer Community und unseres Teams.

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

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

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

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

👉 Bereit, mit uns zu entdecken und zu gestalten? Klicken Sie auf [here] und treten Sie noch heute bei!

4.9 Ampelsimulation

Einführung

Dieses Projekt demonstriert den Einsatz von LEDs und einer 4-stelligen 7-Segment-Anzeige, um ein reales Ampelsystem zu simulieren. Die LEDs repräsentieren die roten, gelben und grünen Länder, während die 7-Segment-Anzeige die verbleibende Zeit für jede Lichtphase herunterzählt. Es bietet eine anschauliche Möglichkeit, GPIO-Steuerung, Zeitabläufe und 7-Segment-Anzeigen in einem lehrreichen oder prototypischen Umfeld kennenzulernen.

Was Sie benötigen

Für dieses Projekt werden die folgenden Komponenten benötigt:

KOMPONENTENBESCHREIBUNG

KAUFLINK

Steckbrett

BUY

Jumper-Kabel

BUY

Widerstand

BUY

LED

BUY

4-stellige 7-Segment-Anzeige

-

74HC595

BUY

Fusion HAT+

-

Raspberry Pi

-

Schaltplan

Nachfolgend ist der schematische Schaltplan für das Projekt zur Ampelsimulation dargestellt:

../_images/4.1.9_sch.png

Verdrahtungsdiagramm

Verwenden Sie das Verdrahtungsdiagramm, um die Komponenten korrekt aufzubauen:

../_images/4.1.9_bb.png

Beispiel ausführen

Der gesamte in diesem Tutorial verwendete Beispielcode befindet sich im Verzeichnis ai-lab-kit. Führen Sie die folgenden Schritte aus, um das Beispiel auszuführen:

cd ~/ai-lab-kit/python/
sudo python3 4.9_TrafficLight.py

Code

Hier ist das Python-Skript für die Ampelsimulation:

#!/usr/bin/env python3

from fusion_hat.pin import Pin, Mode
import threading

# Setup GPIO pins for 74HC595 shift register
SDI = Pin(17,mode=Mode.OUT)   # Serial Data Input
RCLK = Pin(4,mode=Mode.OUT)  # Register Clock
SRCLK = Pin(27,mode=Mode.OUT) # Shift Register Clock

# Define GPIO pins for digit selection on the 7-segment display
placePin = [Pin(pin,mode=Mode.OUT) for pin in (23, 24, 25, 12)]

# Segment codes for numbers 0-9 on 7-segment display
number = (0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90)

# Setup GPIO pins for traffic light LEDs
ledPinR = Pin(5,mode=Mode.OUT) # Red LED
ledPinG = Pin(6,mode=Mode.OUT)  # Green LED
ledPinY = Pin(13,mode=Mode.OUT)  # Yellow LED

# Duration settings for traffic lights
greenLight = 30
yellowLight = 5
redLight = 60

# Traffic light color names
lightColor = ("Red", "Green", "Yellow")

# Initialize state variables
colorState = 0
counter = 60
timer1 = None

def setup():
   """ Initialize the traffic light system and start the timer. """
   global timer1
   timer1 = threading.Timer(1.0, timer)
   timer1.start()

def clearDisplay():
   """ Clear the 7-segment display. """
   for _ in range(8):
      SDI.high()
      SRCLK.high()
      SRCLK.low()
   RCLK.high()
   RCLK.low()

def hc595_shift(data):
   """ Shift data to the 74HC595 shift register for digit display. """
   for i in range(8):
      SDI.value(0x80 & (data << i))
      SRCLK.high()
      SRCLK.low()
   RCLK.high()
   RCLK.low()

def pickDigit(digit):
   """ Select a specific digit to display on the 7-segment display. """
   for pin in placePin:
      pin.low()
   placePin[digit].high()

def timer():
   """ Handle the timing for traffic light changes. """
   global counter, colorState, timer1
   timer1 = threading.Timer(1.0, timer)
   timer1.start()
   counter -= 1
   if counter == 0:
      counter = [greenLight, yellowLight, redLight][colorState]
      colorState = (colorState + 1) % 3
   print(f"counter : {counter}    color: {lightColor[colorState]}")

def lightup():
   """ Update the traffic light LED based on the current state. """
   global colorState
   ledPinR.low()
   ledPinG.low()
   ledPinY.low()
   [ledPinR, ledPinG, ledPinY][colorState].high()

def display():
   """ Display the current counter value on the 7-segment display. """
   global counter

   for i in range(4):
      digit = counter // (10 ** (3 - i)) % 10
      if i == 0 and digit == 0:
            continue
      clearDisplay()
      pickDigit(i)
      hc595_shift(number[digit])

def loop():
   """ Main loop to continuously update display and lights. """
   while True:
      display()
      lightup()

def destroy():
   """ Clean up resources when the script is terminated. """
   global timer1
   timer1.cancel()
   ledPinR.low()
   ledPinG.low()
   ledPinY.low()

try:
   setup()
   loop()
except KeyboardInterrupt:
   destroy()

Code verstehen

  1. Initialisierung:

    • Richtet die GPIO-Pins für das Schieberegister, die 7-Segment-Anzeige und die LEDs der Ampel ein.

    • Definiert Konstanten für die Dauer der einzelnen Lichtphasen und initialisiert Zustandsvariablen.

  2. Funktionen für die 7-Segment-Anzeige:

    • clearDisplay: Löscht alle Segmente auf der Anzeige.

    • hc595_shift: Sendet Daten an das Schieberegister, um die Anzeigesegmente zu steuern.

    • pickDigit: Aktiviert eine bestimmte Ziffer für das Multiplexing.

  3. Timer-Funktion:

    • Verarbeitet den Countdown und steuert die Übergänge zwischen den einzelnen Ampelphasen.

  4. Ampelsteuerung:

    • Aktualisiert die LEDs entsprechend dem aktuellen Zustand der Ampel.

  5. Hauptschleife:

    • Aktualisiert kontinuierlich die Anzeige und die LEDs.

  6. Bereinigung (Cleanup):

    • Stellt sicher, dass alle Ressourcen beim Beenden des Programms ordnungsgemäß freigegeben werden.

Fehlerbehebung

  1. Ampel-LEDs funktionieren nicht:

    • Ursache: Falsche Verdrahtung oder defekte LEDs.

    • Lösung:

      • Überprüfen Sie, ob die LEDs korrekt mit den GPIO-Pins 5 (Rot), 6 (Grün) und 13 (Gelb) verbunden sind.

      • Testen Sie jede LED einzeln mit einem einfachen GPIO-Steuerskript.

  2. 7-Segment-Anzeige zeigt keinen Countdown an:

    • Ursache: Fehlerhafte Verdrahtung oder falsche Konfiguration des Schieberegisters.

    • Lösung:

      • Stellen Sie sicher, dass die Pins SDI, RCLK und SRCLK des Schieberegisters korrekt mit GPIO 17, 4 und 27 verbunden sind.

      • Überprüfen Sie, ob die Ziffernauswahl-Pins mit der Konfiguration von placePin übereinstimmen.

  3. Countdown-Timer bleibt stehen:

    • Ursache: Der Timer-Thread wird nicht korrekt neu gestartet.

    • Lösung: Stellen Sie sicher, dass die Funktion timer() den Aufruf timer1.start() enthält, um den Timer-Thread neu zu starten.

  4. Falsche Lichtdauer:

    • Ursache: Falsche Dauerwerte oder fehlerhafte Zustandswechsel.

    • Lösung:

      • Überprüfen Sie die Werte für redLight, greenLight und yellowLight.

      • Kontrollieren Sie die Logik in der Funktion timer(), um korrekte Zustandswechsel sicherzustellen.

Erweiterungsideen

  1. Fußgängerüberweg: Fügen Sie einen Fußgänger-Taster hinzu, der den Ampelzyklus kurz unterbricht, damit Fußgänger sicher die Straße überqueren können.

    from fusion_hat import Pin
pedestrian_button = Pin(22, Pin.IN, Pin.PULL_DOWN)

def handle_pedestrian():
      global colorState, counter
      if colorState == 1:  # If Green Light
         counter = 5  # Shorten green light duration
pedestrian_button.when_activated = handle_pedestrian

  2. Adaptive Zeitsteuerung: Passen Sie die Dauer der Ampelphasen dynamisch an die aktuelle Verkehrsdichte an.

  3. Ereignisprotokollierung: Speichern Sie Änderungen des Ampelzustands mit Zeitstempel in einer Datei zur späteren Analyse:

    with open("traffic_log.txt", "a") as log_file:
      log_file.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} - {lightColor[colorState]} light\n")

Fazit

Dieses Projekt simuliert ein Ampelsystem und vermittelt praktische Erfahrungen mit GPIO-Steuerung, Schieberegistern und 7-Segment-Anzeigen. Es ist eine unterhaltsame und lehrreiche Möglichkeit, Elektronik und Programmierung zu erkunden und gleichzeitig eine reale Anwendung nachzubilden. Versuchen Sie, das System weiter auszubauen, um es noch interaktiver zu gestalten!