Python Quellcodes & 3D-Modelle | Raspberry Pi Projekte

01. 3D-KONSTRUKTION & HARDWARE

ASTRO CAR KONSTRUKTION

Detaillierte Baugruppenübersicht und 3D-Modell des ferngesteuerten und autonom navigierenden Fahrzeugs.

3D MODELL VOM ASTRO CAR HERUNTERLADEN (PAINT 3D / .GLB) ⤓

BAUGRUPPE A

ASTRO CAR VON OBEN / UNTERBAU

01
4X Getriebemotor (DC 6V)
02
5.000 mAh RC-Akku (Stromversorgung Antrieb)
03
Motortreiber Typ „L298N-H-Brücke“
04
Schalter (fürs Licht)
05
Motortreiber Typ „L298N-H-Brücke“ (Sekundär)
06
Ultraschallsensor (HC-SR04 Distanzmessung)

BAUGRUPPE B

ASTRO CAR VON UNTEN / OBERBAU

01
Raspberry Pi 4 Model B (Zentrale Steuereinheit)
02
Servo-Motor (Ultraschall-Schwenkmechanismus)
03
LED-Frontscheinwerfer (Licht)
04
Schalter (fürs Licht)

02. QUELLTEXT-REPOSITORIUM

CODE ÜBERSICHT

Direkt nutzbare Python-Implementierungen mit GPIO-Ansteuerung, PWM-Regelung und Threading. Verbesserungsvorschläge gerne an: raspberrypiwebsite@gmail.com

01. Safe Lock 02. L298N H-Brücke 03. Tastatur-Steuerung 04. Autonome Fahrt 05. KI Katzenklappe

safe_lock.py • PWM & Passworteingabe

from gpiozero import LED, Button
import RPi.GPIO as GPIO
import threading
import getpass

# Pin-Nummerierung auf dem Board verwenden
GPIO.setmode(GPIO.BCM)

# Pin-Nummern definieren
pwm_gpio = 18
pwm_gpio1 = 21
frequency = 50

GPIO.setup(pwm_gpio, GPIO.OUT)
GPIO.setup(pwm_gpio1, GPIO.OUT)

pwm = GPIO.PWM(pwm_gpio, frequency)
pwm1 = GPIO.PWM(pwm_gpio1, frequency)

led = LED(17)
button = Button(16)

def angle_to_percent(angle):
    if angle > 180 or angle < 0:
        return False
    start = 4
    end = 12.5
    ratio = (end - start) / 180
    angle_as_percent = angle * ratio
    return start + angle_as_percent

def onButtonPressed():
    password = getpass.getpass("Bitte Passwort eingeben: ")
    if password == "123456789":
        zeit = int(input("Wie lange soll der Safe geöffnet bleiben? (in Sekunden): "))
        led.on()
        print("Button gedrückt, LED eingeschaltet")
        pwm1.start(angle_to_percent(90))
        threading.Timer(2, pwm.start, args=[angle_to_percent(180)]).start()
        threading.Timer(zeit, stop_lock).start()
    elif password == "easter_egg_123456789":
        led.on()
        print("Button gedrückt, LED eingeschaltet")
        pwm1.start(angle_to_percent(90))
        threading.Timer(2, pwm.start, args=[angle_to_percent(180)]).start()
        threading.Timer(0.5, blink_led, args=[3]).start()
    else:
        print("Falsches Passwort eingegeben")

def stop_lock():
    print("Safe Lock gestoppt")
    led.off()
    pwm.start(angle_to_percent(70))

def blink_led(num_blinks):
    for i in range(num_blinks):
        led.on()
        threading.Timer(0.5, led.off).start()

button.when_pressed = onButtonPressed

try:
    while True:
        pass
except KeyboardInterrupt:
    GPIO.cleanup()

L298NHBridge.py • Motortreiber Modul

import RPi.GPIO as io

io.setmode(io.BCM)
DC_MAX = 100
io.setwarnings(False)

ENA = 18
IN1 = 6
IN2 = 13
IN3 = 19
IN4 = 26
ENB = 12

leftmotor_in1_pin = IN1
leftmotor_in2_pin = IN2
io.setup(leftmotor_in1_pin, io.OUT)
io.setup(leftmotor_in2_pin, io.OUT)

rightmotor_in1_pin = IN3
rightmotor_in2_pin = IN4
io.setup(rightmotor_in1_pin, io.OUT)
io.setup(rightmotor_in2_pin, io.OUT)

io.output(leftmotor_in1_pin, False)
io.output(leftmotor_in2_pin, False)
io.output(rightmotor_in1_pin, False)
io.output(rightmotor_in2_pin, False)

leftmotorpwm_pin = ENA
rightmotorpwm_pin = ENB
io.setup(leftmotorpwm_pin, io.OUT)
io.setup(rightmotorpwm_pin, io.OUT)

leftmotorpwm = io.PWM(leftmotorpwm_pin, 100)
rightmotorpwm = io.PWM(rightmotorpwm_pin, 100)

leftmotorpwm.start(0)
leftmotorpwm.ChangeDutyCycle(0)
rightmotorpwm.start(0)
rightmotorpwm.ChangeDutyCycle(0)

def setMotorMode(motor, mode):
    if motor == "leftmotor":
        if mode == "reverse":
            io.output(leftmotor_in1_pin, True)
            io.output(leftmotor_in2_pin, False)
        elif mode == "forward":
            io.output(leftmotor_in1_pin, False)
            io.output(leftmotor_in2_pin, True)
        else:
            io.output(leftmotor_in1_pin, False)
            io.output(leftmotor_in2_pin, False)
    elif motor == "rightmotor":
        if mode == "reverse":
            io.output(rightmotor_in1_pin, False)
            io.output(rightmotor_in2_pin, True)
        elif mode == "forward":
            io.output(rightmotor_in1_pin, True)
            io.output(rightmotor_in2_pin, False)
        else:
            io.output(rightmotor_in1_pin, False)
            io.output(rightmotor_in2_pin, False)
    else:
        io.output(leftmotor_in1_pin, False)
        io.output(leftmotor_in2_pin, False)
        io.output(rightmotor_in1_pin, False)
        io.output(rightmotor_in2_pin, False)

def setMotorLeft(power):
    int(power)
    if power < 0:
        setMotorMode("leftmotor", "reverse")
        pwm = -int(DC_MAX * power)
        if pwm > DC_MAX:
            pwm = DC_MAX
    elif power > 0:
        setMotorMode("leftmotor", "forward")
        pwm = int(DC_MAX * power)
        if pwm > DC_MAX:
            pwm = DC_MAX
    else:
        setMotorMode("leftmotor", "stopp")
        pwm = 0
    leftmotorpwm.ChangeDutyCycle(pwm)

def setMotorRight(power):
    int(power)
    if power < 0:
        setMotorMode("rightmotor", "reverse")
        pwm = -int(DC_MAX * power)
        if pwm > DC_MAX:
            pwm = DC_MAX
    elif power > 0:
        setMotorMode("rightmotor", "forward")
        pwm = int(DC_MAX * power)
        if pwm > DC_MAX:
            pwm = DC_MAX
    else:
        setMotorMode("rightmotor", "stopp")
        pwm = 0
    rightmotorpwm.ChangeDutyCycle(pwm)

def exit():
    io.output(leftmotor_in1_pin, False)
    io.output(leftmotor_in2_pin, False)
    io.output(rightmotor_in1_pin, False)
    io.output(rightmotor_in2_pin, False)
    io.cleanup()

steuerung.py • Interaktive Tastatur-Steuerung

import sys, tty, termios, os, readchar
import L298NHBridge as HBridge

speedleft = 0
speedright = 0

print("w/s: beschleunigen")
print("a/d: lenken")
print("q: stoppt die Motoren")
print("x: Programm beenden")

def getch():
    ch = readchar.readchar()
    return ch

def printscreen():
    os.system('clear')
    print("w/s: vorwaerts / rueckwaerts beschleunigen")
    print("a/d: links / rechts lenken")
    print("q:   stoppt die Motoren")
    print("x:   Programm beenden")
    print("========== Geschwindigkeitsanzeige ==========")
    print("Geschwindigkeit linker Motor:  ", speedleft)
    print("Geschwindigkeit rechter Motor: ", speedright)

while True:
    char = getch()
    if(char == "w"):
        speedleft = speedleft + 0.5
        speedright = speedright + 0.5
        if speedleft > 1:
            speedleft = 1
        if speedright > 1:
            speedright = 1
        HBridge.setMotorLeft(speedleft)
        HBridge.setMotorRight(speedright)
        printscreen()
    if(char == "s"):
        speedleft = speedleft - 0.5
        speedright = speedright - 0.5
        if speedleft < -1:
            speedleft = -1
        if speedright < -1:
            speedright = -1
        HBridge.setMotorLeft(speedleft)
        HBridge.setMotorRight(speedright)
        printscreen()
    if(char == "q"):
        speedleft = 0
        speedright = 0
        HBridge.setMotorLeft(speedleft)
        HBridge.setMotorRight(speedright)
        printscreen()
    if(char == "d"):
        speedright = speedright + 0.5
        speedleft = speedleft - 0.5
        if speedright < -1:
            speedright = -1
        if speedleft > 1:
            speedleft = 1
        HBridge.setMotorLeft(speedleft)
        HBridge.setMotorRight(speedright)
        printscreen()
    if(char == "a"):
        speedleft = speedleft + 0.5
        speedright = speedright - 0.5
        if speedleft < -1:
            speedleft = -1
        if speedright > 1:
            speedright = 1
        HBridge.setMotorLeft(speedleft)
        HBridge.setMotorRight(speedright)
        printscreen()
    if(char == "x"):
        HBridge.setMotorLeft(0)
        HBridge.setMotorRight(0)
        HBridge.exit()
        print("Programm Ende")
        break
    char = ""

autonome_fahrt.py • Sonar-Hinderniserkennung

import RPi.GPIO as GPIO
import time
import sys, tty, termios, os, readchar
import L298NHBridge as HBridge

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

trigPin = 22
echoPin = 24
pwm_gpio = 25
frequence = 50
MAX_DISTANCE = 600
timeOut = MAX_DISTANCE * 60

GPIO.setup(pwm_gpio, GPIO.OUT)
pwm = GPIO.PWM(pwm_gpio, frequence)

speedleft = 0
speedright = 0

def angle_to_percent(angle):
    if angle > 180 or angle < 0:
        return False
    start = 4
    end = 12.5
    ratio = (end - start) / 180
    angle_as_percent = angle * ratio
    return start + angle_as_percent

def pulseIn(pin, level, timeOut):
    t0 = time.time()
    while(GPIO.input(pin) != level):
        if((time.time() - t0) > timeOut * 0.000001):
            return 0
    t0 = time.time()
    while(GPIO.input(pin) == level):
        if((time.time() - t0) > timeOut * 0.000001):
            return 0
    pulseTime = (time.time() - t0) * 1000000
    return pulseTime

def getSonar():
    GPIO.output(trigPin, GPIO.HIGH)
    time.sleep(0.00001)
    GPIO.output(trigPin, GPIO.LOW)
    pingTime = pulseIn(echoPin, GPIO.HIGH, timeOut)
    distance = pingTime * 340.0 / 2.0 / 10000.0
    return distance

def getSonar1():
    GPIO.output(trigPin, GPIO.HIGH)
    time.sleep(0.00001)
    GPIO.output(trigPin, GPIO.LOW)
    pingTime = pulseIn(echoPin, GPIO.HIGH, timeOut)
    distance1 = pingTime * 340.0 / 2.0 / 10000.0
    return distance1

def getSonar2():
    GPIO.output(trigPin, GPIO.HIGH)
    time.sleep(0.00001)
    GPIO.output(trigPin, GPIO.LOW)
    pingTime = pulseIn(echoPin, GPIO.HIGH, timeOut)
    distance2 = pingTime * 340.0 / 2.0 / 10000.0
    return distance2

def setup():
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(trigPin, GPIO.OUT)
    GPIO.setup(echoPin, GPIO.IN)

def getch():
    ch = readchar.readchar()
    return ch

def printscreen():
    os.system('clear')
    print("w/s: vorwaerts / rueckwaerts beschleunigen")
    print("a/d: links / rechts lenken")
    print("q:   stoppt die Motoren")
    print("x:   Programm beenden")
    print("========== Geschwindigkeitsanzeige ==========")
    print("Geschwindigkeit linker Motor:  ", speedleft)
    print("Geschwindigkeit rechter Motor: ", speedright)

def strate_servo():
    pwm.start(angle_to_percent(90))

def Right_servo():
    pwm.start(angle_to_percent(180))

def Left_servo():
    pwm.start(angle_to_percent(10))

def strate():
    distance = getSonar()
    print("The distance of strate is : %.2f cm" % (distance))
    if distance <= 29:
        ende()
        check()

def Right():
    distance1 = getSonar1()
    print("The distance of right is : %.2f cm" % (distance1))

def Left():
    distance2 = getSonar2()
    print("The distance of left is : %.2f cm" % (distance2))

def forward():
    speedleft = 0.2
    speedright = 0.5
    if speedleft > 0.2:
        speedleft = 0.2
    if speedright > 0.5:
        speedright = 0.5
    HBridge.setMotorLeft(speedleft)
    HBridge.setMotorRight(speedright)
    printscreen()

def backward():
    speedleft = -1
    speedright = -1
    if speedleft < -1:
        speedleft = -1
    if speedright < -1:
        speedright = -1
    HBridge.setMotorLeft(speedleft)
    HBridge.setMotorRight(speedright)
    printscreen()

def rightr():
    speedright = +1
    speedleft = -1
    if speedright < -1:
        speedright = -1
    if speedleft > 1:
        speedleft = 1
    HBridge.setMotorLeft(speedleft)
    HBridge.setMotorRight(speedright)
    printscreen()

def leftl():
    speedleft = +1
    speedright = -1
    if speedleft < -1:
        speedleft = -1
    if speedright > 1:
        speedright = 1
    HBridge.setMotorLeft(speedleft)
    HBridge.setMotorRight(speedright)
    printscreen()

def check():
    distance1 = getSonar1()
    distance2 = getSonar2()
    Right_servo()
    Right()
    time.sleep(0.5)
    Left_servo()
    time.sleep(1.5)
    Left()
    time.sleep(0.1)
    strate_servo()
    if distance1 or distance2 < 10:
        backward()
    if distance1 < distance2:
        leftl()
        time.sleep(1)
        strate()
        loop()
    if distance1 > distance2:
        rightr()
        time.sleep(1)
        strate()
        loop()

def ende():
    speedleft = 0
    speedright = 0
    HBridge.setMotorLeft(speedleft)
    HBridge.setMotorRight(speedright)
    printscreen()

def loop():
    distance = getSonar()
    forward()
    strate_servo()
    while distance > 30:
        strate()

if __name__ == '__main__':
    print('Program is starting...')
    setup()
    try:
        loop()
    except KeyboardInterrupt:
        GPIO.cleanup()
        speedleft = 0
        speedright = 0
        HBridge.setMotorLeft(speedleft)
        HBridge.setMotorRight(speedright)
        printscreen()

03. EDGE-AI DOWNLOAD-PAKET

KI KATZENKLAPPE: DATEIEN & VIDEOS

Kompiliertes TensorFlow Lite Modell, EdgeTPU-Beschleunigerdatei, Python-Detektionsskripte und das vollständige bootfähige Betriebssystem-Image.

cat_detection.tflite ⤓ cat_detection_edgetpu.tflite ⤓ ALLE DATEIEN AUF GITHUB ↗ RASPBERRY PI-IMAGE DOWNLOAD (GOOGLE DRIVE) ↗

detect.py • Video-Inferenz & OpenCV-Anzeige

⤓ DOWNLOAD

# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Main script to run the object detection routine."""
import argparse
import sys
import time

import cv2
from tflite_support.task import core
from tflite_support.task import processor
from tflite_support.task import vision
import utils


def run(model: str, camera_id: int, width: int, height: int, num_threads: int,
        enable_edgetpu: bool) -> None:
  """Continuously run inference on images acquired from the camera.

  Args:
    model: Name of the TFLite object detection model.
    camera_id: The camera id to be passed to OpenCV.
    width: The width of the frame captured from the camera.
    height: The height of the frame captured from the camera.
    num_threads: The number of CPU threads to run the model.
    enable_edgetpu: True/False whether the model is a EdgeTPU model.
  """

  # Variables to calculate FPS
  counter, fps = 0, 0
  start_time = time.time()

  # Start capturing video input from the camera
  cap = cv2.VideoCapture(camera_id)
  cap.set(cv2.CAP_PROP_FRAME_WIDTH, width)
  cap.set(cv2.CAP_PROP_FRAME_HEIGHT, height)

  # Visualization parameters
  row_size = 20  # pixels
  left_margin = 24  # pixels
  text_color = (0, 0, 255)  # red
  font_size = 1
  font_thickness = 1
  fps_avg_frame_count = 10

  # Initialize the object detection model
  base_options = core.BaseOptions(
      file_name=model, use_coral=True, num_threads=num_threads)
  detection_options = processor.DetectionOptions(
      max_results=3, score_threshold=0.3)
  options = vision.ObjectDetectorOptions(
      base_options=base_options, detection_options=detection_options)
  detector = vision.ObjectDetector.create_from_options(options)

  # Continuously capture images from the camera and run inference
  while cap.isOpened():
    success, image = cap.read()
    if not success:
      sys.exit(
          'ERROR: Unable to read from webcam. Please verify your webcam settings.'
      )

    counter += 1
    image = cv2.flip(image, 1)

    # Convert the image from BGR to RGB as required by the TFLite model.
    rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    # Create a TensorImage object from the RGB image.
    input_tensor = vision.TensorImage.create_from_array(rgb_image)

    # Run object detection estimation using the model.
    detection_result = detector.detect(input_tensor)

    # Draw keypoints and edges on input image
    image = utils.visualize(image, detection_result)

    # Calculate the FPS
    if counter % fps_avg_frame_count == 0:
      end_time = time.time()
      fps = fps_avg_frame_count / (end_time - start_time)
      start_time = time.time()

    # Show the FPS
    fps_text = 'FPS = {:.1f}'.format(fps)
    text_location = (left_margin, row_size)
    cv2.putText(image, fps_text, text_location, cv2.FONT_HERSHEY_PLAIN,
                font_size, text_color, font_thickness)

    # Stop the program if the ESC key is pressed.
    if cv2.waitKey(1) == 27:
      break
    cv2.imshow('object_detector', image)

  cap.release()
  cv2.destroyAllWindows()


def main():
  parser = argparse.ArgumentParser(
      formatter_class=argparse.ArgumentDefaultsHelpFormatter)
  parser.add_argument(
      '--model',
      help='Path of the object detection model.',
      required=False,
      default='efficientdet_lite0.tflite')
  parser.add_argument(
      '--cameraId', help='Id of camera.', required=False, type=int, default=0)
  parser.add_argument(
      '--frameWidth',
      help='Width of frame to capture from camera.',
      required=False,
      type=int,
      default=640)
  parser.add_argument(
      '--frameHeight',
      help='Height of frame to capture from camera.',
      required=False,
      type=int,
      default=480)
  parser.add_argument(
      '--numThreads',
      help='Number of CPU threads to run the model.',
      required=False,
      type=int,
      default=4)
  parser.add_argument(
      '--enableEdgeTPU',
      help='Whether to run the model on EdgeTPU.',
      action='store_true',
      required=False,
      default=False)

  args = parser.parse_args()

  run(args.model, int(args.cameraId), args.frameWidth, args.frameHeight,
      int(args.numThreads), bool(args.enableEdgeTPU))


if __name__ == '__main__':
  main()

utils.py • Beute-Erkennung & PWM-Servo-Sperre

⤓ DOWNLOAD

import cv2
import numpy as np
from tflite_support.task import processor

# Import necessary modules for accessing the GPIO pins and controlling the servo
import RPi.GPIO as GPIO
import time

_MARGIN = 10  # pixels
_ROW_SIZE = 10  # pixels
_FONT_SIZE = 1
_FONT_THICKNESS = 1
_TEXT_COLOR = (0, 0, 255)  # red

# Set the pin numbering mode
GPIO.setmode(GPIO.BCM)

# Set the GPIO pin that the servo is connected to
servo_pin = 23

# Set the servo pin as output
GPIO.setup(servo_pin, GPIO.OUT)

# Create a PWM instance with a frequency of 50 Hz
pwm = GPIO.PWM(servo_pin, 50)

# Start the PWM with a duty cycle of 7.5% (close position)
pwm.start(7.5)

def open_servo():
    # Change duty cycle to 12.5% to open the servo
    pwm.ChangeDutyCycle(12.5)
    # Delay for a short time
    time.sleep(2)

def close_servo():
    # Change duty cycle to 7.5% to close the servo
    pwm.ChangeDutyCycle(7.5)
    # Delay for a short time
    time.sleep(0.2)
    pwm.ChangeDutyCycle(0)

servo_state = False

def visualize(
    image: np.ndarray,
    detection_result: processor.DetectionResult,
) -> np.ndarray:
  """Draws bounding boxes on the input image and return it.

  Args:
    image: The input RGB image.
    detection_result: The list of all "Detection" entities to be visualize.

  Returns:
    Image with bounding boxes.
  """
  global servo_state
  detection_made = False
  for detection in detection_result.detections:
    detection_made = True
    # Draw bounding_box
    bbox = detection.bounding_box
    start_point = bbox.origin_x, bbox.origin_y
    end_point = bbox.origin_x + bbox.width, bbox.origin_y + bbox.height
    cv2.rectangle(image, start_point, end_point, _TEXT_COLOR, 3)

    # Draw label and score
    category = detection.categories[0]
    category_name = category.category_name # zuständig für name anzeigen
    if category_name == "cat+mouse":
        # Close the servo if it is open
        if servo_state:
            close_servo()
            servo_state = False
    elif category_name == "cat":
        probability = round(category.score, 2)
        if probability > 0.5:
            # Open the servo if it is closed
            if not servo_state:
                open_servo()
                servo_state = True
    else:
        # Close the servo if it is open
        if servo_state:
            close_servo()
            servo_state = False
    probability = round(category.score, 2)
    result_text = category_name + ' (' + str(probability) + ')'
    text_location = (_MARGIN + bbox.origin_x,
                     _MARGIN + _ROW_SIZE + bbox.origin_y)
    cv2.putText(image, result_text, text_location, cv2.FONT_HERSHEY_PLAIN,
                _FONT_SIZE, _TEXT_COLOR, _FONT_THICKNESS)
  if not detection_made:
      if servo_state:
            close_servo()
            servo_state = False
  return image

Katzenklappe mit Gesichtserkennung (Longversion) TFLITE

Katzenklappe Prototyp & Test TENSORFLOW

Raspberry Pi Projekt Teil 20 UPDATE

MEIN CODE & 3D-MODELLE

ROBOTIK ARCHITEKTUR

ASTRO CAR KONSTRUKTION

ASTRO CAR VON OBEN / UNTERBAU

ASTRO CAR VON UNTEN / OBERBAU

CODE ÜBERSICHT

KI KATZENKLAPPE: DATEIEN & VIDEOS