Recycling Smart

Recycling ist eine wichtige Praxis mit ökologischen, wirtschaftlichen und sozialen Vorteilen und sollte sowohl auf individueller als auch auf gesellschaftlicher Ebene unterstützt werden. Wenn Schulen das Prinzip der Mülltrennung und Wiederverwertung aktiv vermitteln, fördern sie das Umwelt- und Verantwortungsbewusstsein der jungen Generation und sensibilisieren die Schüler*innen dafür, wie sie zu einer nachhaltigen Zukunft beitragen können. Mithilfe von KI-Technologie lässt sich Recycling niedrigschwelliger und motivierender gestalten. Der Erwerb von Kenntnissen in KI-bezogenen Themenfeldern kann die Kreativität der Lernenden fördern und ihre Fähigkeit stärken, innovative Lösungen für die Herausforderungen der Zukunft zu entwickeln.

Dieses Unterrichtsmaterial beruht auf der Idee, Recycling mithilfe von KI-gestützter Objekterkennung zu erleichtern. Die Konstruktion und Programmierung eines intelligenten Recyclingsystems fördern Fähigkeiten in den Bereichen Künstliche Intelligenz und Robotik. Das Material basiert auf einem Projekt, mit dem Schüler*innen einer Berufsschule zum Recyceln motiviert werden sollten. Es wurde im Rahmen des Wahlfachs „Künstliche Intelligenz und Machine Learning“ entwickelt und gewann den ersten Preis in seiner Kategorie beim Wettbewerb des Atatürk Mesleki ve Teknik Anadolu Lisesi in Ankara sowie den ersten Preis beim Wettbewerb „STEM Alliance – Lenovo Competition 2023: Turning Waste into Educational Wonder“. 

Recycling ist eine Praxis mit vielen wichtigen Vorteilen: Schonung natürlicher Ressourcen, Energieeinsparung, Abfallvermeidung, Umweltschutz, Schaffung von Arbeitsplätzen und Förderung von Nachhaltigkeit. Recycling kann dazu beitragen, den Verbrauch natürlicher Ressourcen zu reduzieren, und ermöglicht die Wiederverwendung von Rohstoffen, was zu einer nachhaltigeren Nutzung der natürlichen Ressourcen führt, sie für künftige Generationen bewahrt und das ökologische Gleichgewicht erhält. Durch die Verringerung der Abfallmenge entfällt die Notwendigkeit, bestehende Mülldeponien zu erweitern oder neue Flächen zu erschließen. Dadurch verringern sich die Umweltbelastung und die Probleme der Abfallentsorgung. Schließlich schafft der Recyclingsektor auch Arbeitsplätze und trägt damit zum Wirtschaftswachstum bei.

Video des Umweltprogramms der Vereinten Nationen zum #ZeroWasteDay (auf Englisch mit optionalen automatisch übersetzten Untertiteln):

sudo apt-get update

sudo apt-get upgrade

pip install tensorflow

pip install opencv-python

pip install numpy

pip install keras

pip install pigpio

pip install time

sudo apt-get update && sudo apt-get install python3-rpi.gpio

sudo apt-get update && sudo apt-get install python3-pigpio

sudo pigpiod

https://forums.raspberrypi.com/viewtopic.php?t=340847

CORAL USB:

echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

sudo apt-get update

sudo apt-get install libedgetpu1-std

sudo apt-get install libedgetpu1-max

##sudo pigpiod: Dieser Befehl muss bei jedem Neustart des Raspberry Pi ausgeführt werden, um die Steuerung zu aktivieren.

import os  # Bibliotheken importieren
import cv2
from pycoral.utils.dataset import read_label_file
from pycoral.utils.edgetpu import make_interpreter
from pycoral.adapters import common
from pycoral.adapters import classify
import pigpio
import time
import RPi.GPIO as GPIO
import numpy as np

# Pfad zum TFLite-Modell definieren (konvertiert für die Nutzung mit Edge TPU)
modelPath = '/home/admin/Desktop/TF/model_edgetpu.tflite'

# Pfad zur Datei "Labels" definieren, die mit dem Modell heruntergeladen wurde
labelPath = '/home/admin/Desktop/TF/labels.txt'

# GPIO-Pins für die Servomotoren definieren
servo1 = 23
servo2 = 24
servo3 = 25
servo4 = 21

# PWM (Pulsweitenmodulation) für die Servosteuerung über die Pigpio-Bibliothek initialisieren
pwm = pigpio.pi()
pwm.set_mode(servo1, pigpio.OUTPUT)
pwm.set_mode(servo2, pigpio.OUTPUT)
pwm.set_mode(servo3, pigpio.OUTPUT)
pwm.set_mode(servo4, pigpio.OUTPUT)

# PWM-Frequenz für die Servomotoren einstellen
pwm.set_PWM_frequency(servo1, 50)
pwm.set_PWM_frequency(servo2, 50)
pwm.set_PWM_frequency(servo3, 50)
pwm.set_PWM_frequency(servo4, 50)

# Ausgangspositionen der Servomotoren einstellen
pwm.set_servo_pulsewidth(servo1, 500)
time.sleep(1)
pwm.set_servo_pulsewidth(servo2, 500)
time.sleep(1)
pwm.set_servo_pulsewidth(servo3, 500)
time.sleep(1)
pwm.set_servo_pulsewidth(servo4, 500)
time.sleep(1)

# Funktion für die Klassifizierung eines Bildes mit dem zur Verfügung gestellten TF Lite Interpreter
def classifyImage(interpreter, image):
    size = common.input_size(interpreter)
    common.set_input(interpreter, cv2.resize(image, size, fx=0, fy=0, interpolation=cv2.INTER_CUBIC))
    interpreter.invoke()
    return classify.get_classes(interpreter)

def main():
    # Das Modell in den TF Lite Interpreter laden
    interpreter = make_interpreter(modelPath)
    interpreter.allocate_tensors()
    labels = read_label_file(labelPath)

    # Das Videoaufnahmegerät öffnen
    cap = cv2.VideoCapture(0)
    last_detection_cam = 0 #"cam" steht für "Glas"
    last_detection_metal = 0 #"metal" steht für "Metall"
    last_detection_plastik = 0
    last_detection_kompost = 0

    while cap.isOpened():
        # Einen Frame vom Videoaufnahmegerät erfassen
        ret, frame = cap.read()
        if not ret:
            break

        # Das Bild horizontal drehen
        frame = cv2.flip(frame, 1)

        # Das Bild klassifizieren und anzeigen
        results = classifyImage(interpreter, frame)
        cv2.imshow('frame', frame)

        # Informationen über das erkannte Objekt extrahieren
        detected_label = labels[results[0].id]
        confidence_score = results[0].score
        print(f'Detected Label: {detected_label}, Score: {confidence_score}')

        # Die Servomotoren entsprechend dem erkannten Objekt und Confidence Score steuern ['cam'=Glas]
        if detected_label == 'cam' and confidence_score > 0.9:
            pwm.set_servo_pulsewidth(servo1, 1700)
            last_detection_cam = time.time()
        elif detected_label == 'metal' and confidence_score > 0.9:
            pwm.set_servo_pulsewidth(servo2, 1700)
            last_detection_metal = time.time()
        elif detected_label == 'kompost' and confidence_score > 0.9:
            pwm.set_servo_pulsewidth(servo3, 1700)
            last_detection_kompost = time.time()
        elif detected_label == 'plastik' and confidence_score > 0.9:
            pwm.set_servo_pulsewidth(servo4, 1700)
            last_detection_plastik = time.time()

        # Servo-Positionen nach einer bestimmten Zeit zurücksetzen, wenn kein Objekt erkannt wurde
        if time.time() - last_detection_cam > 4:
            pwm.set_servo_pulsewidth(servo1, 500)
        if time.time() - last_detection_metal > 4:
            pwm.set_servo_pulsewidth(servo2, 500)
        if time.time() - last_detection_kompost > 4:
            pwm.set_servo_pulsewidth(servo3, 500)
        if time.time() - last_detection_plastik > 4:
            pwm.set_servo_pulsewidth(servo4, 500)

        # Überprüfen, ob die Taste q gedrückt wird, um die Schleife zu verlassen
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    # Das Videoaufnahmegerät freigeben und alle OpenCV-Fenster schließen
    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

Codebeispiele und TensorflowLite-Modell