Rasenmäher Roboter selbstgebaut

Für unseren Garten kann ein Rasenmäher - Roboter eine schöne Erleichterung in der regelmässigen und mühevollen Kürzung des Rasenwuchs sein. Dies würde das Benzin für unseren bisherigen Rasenmäher sparen und viel nachhaltiger sein. Jedoch soll sich dies auch sinnvoll durch seine Bezahlbarkeit auch direkt ammortisieren. Dies ist mit dem Kauf eines handelsüblichen Mähroboters von der Stange allerdings zur Zeit durch die Preise und Qualität unmöglich. Ausserdem sind technische Modifikationen und Erweiterungen kaum realisierbar.

Hier ist meine vorläufige Bauanleitung für einen Rasenmäher-Roboter, der auf einem Mini-PC basiert und Lidar, Ultraschall-Sensoren, eine Kamera und geeignete Software zur Regelung verwendet. Diese Anleitung umfasst auch eine Einführung in die Integration von KI zur Verbesserung der Navigation und Objekterkennung, damit in unserem Garten die Vögel, unser Kater und alle Hindernisse und Unebenheiten auf zwei voneinender getrenten Rasenflächen zuverlässig und sicher bearbeitet werden können.

1. Materialien und Komponenten

  • Mini-PC: Mini PC oder Nvidia Jetson Nano für KI-Anwendungen
  • Motoren: DC-Motoren mit Rädern (idealerweise mit eingebautem Encoder)
  • Motorsteuerung: Motorsteuerungsmodul (z.B. L298N)
  • Lidar: Lidar-Sensor (z.B. RPLIDAR A1)
  • Ultraschall-Sensoren: HC-SR04 (mehrere Einheiten für Rundum-Erkennung)
  • Kamera: Raspberry Pi Kamera-Modul oder USB-Webcam
  • Batterie: Lithium-Ionen-Akku (mindestens 12V)
  • Rahmen: Roboter-Chassis (z.B. Kunststoff- oder Metallrahmen)
  • Stromversorgung: Spannungsregler für den Mini-PC und Sensoren
  • Kabel und Steckverbinder
  • Schalter: Zum Ein- und Ausschalten des Roboters

2. Aufbau des Roboters

2.1. Chassis und Mechanik

  1. Montiere die Motoren:
    • Befestige die DC-Motoren am Chassis. Die Räder sollten sicher an den Motoren angebracht sein.
  2. Installiere die Batterie:
    • Befestige die Batterie am Chassis, vorzugsweise an einer stabilen Position, um das Gleichgewicht des Roboters zu gewährleisten.
  3. Montiere den Mini-PC:
    • Befestige den Raspberry Pi oder Mini-PC sicher auf dem Chassis. Stelle sicher, dass die Anschlüsse zugänglich sind.
  4. Positioniere die Sensoren:
    • Lidar: Befestige den Lidar-Sensor an der Oberseite des Roboters für eine vollständige Rundumsicht.
    • Ultraschall-Sensoren: Installiere die Ultraschall-Sensoren an den Seiten des Roboters für die Hinderniserkennung.
    • Kamera: Montiere die Kamera an einer geeigneten Position, z.B. vorne am Chassis.

3. Elektronik und Verkabelung

3.1. Motorsteuerung

  1. Verbinde die Motoren mit dem Motorsteuerungsmodul:
    • Schließe die Motoren an die Ausgänge des L298N-Motorsteuerungsmoduls an.
  2. Verbinde das Motorsteuerungsmodul mit dem Raspberry Pi:
    • Die Steuerleitungen des L298N sollten an die GPIO-Pins des Raspberry Pi angeschlossen werden.
  3. Stromversorgung:
    • Verbinde den Motorsteuerungsmodul und den Raspberry Pi zur Stromversorgung. Stelle sicher, dass die Spannungen und Ströme korrekt sind.

3.2. Sensoren

  1. Lidar-Sensor:
    • Schließe den Lidar-Sensor über die serielle Schnittstelle (UART) oder USB an den Raspberry Pi an.
  2. Ultraschall-Sensoren:
    • Verbinde die Ultraschall-Sensoren an die GPIO-Pins des Raspberry Pi.
  3. Kamera:
    • Schließe das Kamera-Modul über die entsprechende Schnittstelle (CSI für Raspberry Pi Kamera, USB für Webcam) an.

4. Software und Programmierung

4.1. Software-Anforderungen

  • Betriebssystem: Raspbian (Raspberry Pi OS) oder Ubuntu für Nvidia Jetson
  • Programmiersprache: Python
  • Bibliotheken: OpenCV für Bildverarbeitung, RPLIDAR Python SDK, GPIO-Bibliothek, eventuell TensorFlow oder PyTorch für KI

4.2. Installation und Konfiguration

  1. Installiere Python und erforderliche Bibliotheken:
    • Aktualisiere dein System:
      sudo apt-get update
      sudo apt-get upgrade
    • Installiere Python 3 und pip (falls noch nicht installiert):
      sudo apt-get install python3 python3-pip
    • Installiere benötigte Python-Bibliotheken:
      pip3 install RPLCD
      pip3 install RPi.GPIO
      pip3 install pyserial
      pip3 install opencv-python
      pip3 install numpy
  2. Lidar-Software:
    • Lade das RPLIDAR Python SDK herunter und folge den Anweisungen zur Installation. Beispielcode zum Auslesen von Lidar-Daten:
      import serial
      import time
      def read_lidar():
          lidar = serial.Serial('/dev/ttyUSB0', baudrate=115200, timeout=1)
          while True:
              if lidar.in_waiting > 0:
                  data = lidar.readline()
                  print(data.decode('utf-8'))
      if __name__ == "__main__":
          read_lidar()
  3. Ultraschall-Sensoren:
    • Beispielcode zur Messung der Entfernung mit einem HC-SR04:
      import RPi.GPIO as GPIO
      import time
      TRIG = 23
      ECHO = 24
      GPIO.setmode(GPIO.BCM)
      GPIO.setup(TRIG, GPIO.OUT)
      GPIO.setup(ECHO, GPIO.IN)
      def distance():
          GPIO.output(TRIG, False)
          time.sleep(2)
          GPIO.output(TRIG, True)
          time.sleep(0.00001)
          GPIO.output(TRIG, False)
          while GPIO.input(ECHO) == 0:
              pulse_start = time.time()
          while GPIO.input(ECHO) == 1:
              pulse_end = time.time()
          pulse_duration = pulse_end - pulse_start
          distance = pulse_duration * 17150
          distance = round(distance, 2)
          return distance
      if __name__ == "__main__":
          try:
              while True:
                  dist = distance()
                  print(f"Distance: {dist} cm")
                  time.sleep(1)
          except KeyboardInterrupt:
              GPIO.cleanup()
  4. Kamera-Integration:
    • Beispielcode zur Bildaufnahme und -verarbeitung mit OpenCV:
      import cv2
      def capture_image():
          camera = cv2.VideoCapture(0)
          while True:
              ret, frame = camera.read()
              if ret:
                  cv2.imshow('Camera Feed', frame)
                  if cv2.waitKey(1) & 0xFF == ord('q'):
                      break
          camera.release()
          cv2.destroyAllWindows()
      if __name__ == "__main__":
          capture_image()
  5. Motorsteuerung:
    • Beispielcode zur Steuerung der Motoren über das L298N-Modul:
      import RPi.GPIO as GPIO
      from time import sleep
      MOTOR1A = 17
      MOTOR1B = 18
      ENA = 22
      GPIO.setmode(GPIO.BCM)
      GPIO.setup(MOTOR1A, GPIO.OUT)
      GPIO.setup(MOTOR1B, GPIO.OUT)
      GPIO.setup(ENA, GPIO.OUT)
      pwm = GPIO.PWM(ENA, 1000)
      pwm.start(0)
      def move_forward():
          GPIO.output(MOTOR1A, GPIO.HIGH)
          GPIO.output(MOTOR1B, GPIO.LOW)
          pwm.ChangeDutyCycle(100)
      def move_backward():
          GPIO.output(MOTOR1A, GPIO.LOW)
          GPIO.output(MOTOR1B, GPIO.HIGH)
          pwm.ChangeDutyCycle(100)
      def stop():
          pwm.ChangeDutyCycle(0)
      if __name__ == "__main__":
          try:
              while True:
                  move_forward()
                  sleep(2)
                  stop()
                  sleep(1)
                  move_backward()
                  sleep(2)
                  stop()
                  sleep(1)
          except KeyboardInterrupt:
              GPIO.cleanup()

4.3. KI-Integration

Für KI-gestützte Funktionen wie Hinderniserkennung oder automatische Mähstrategien kannst du ein KI-Modell trainieren oder vortrainierte Modelle verwenden. Hier ist ein grundlegender Ansatz zur Integration von KI:

  1. Installiere TensorFlow oder PyTorch:
    • TensorFlow:
      pip3 install tensorflow
    • PyTorch (empfohlen für Nvidia Jetson Nano):
      pip3 install torch torchvision
  2. Trainiere ein Modell oder verwende ein vortrainiertes Modell:
    • Trainiere ein Modell zur Erkennung von Hindernissen oder zur Planung von Mähstrategien. Du kannst auch vortrainierte Modelle verwenden, z.B. für die Erkennung von Objekten oder die Klassifizierung von Bildern.
  3. Integriere das KI-Modell in dein Programm:
    • Beispielcode zur Verwendung eines vortrainierten Modells für die Objekterkennung:
      import tensorflow as tf
      import cv2
      import numpy as np
      model = tf.keras.models.load_model('path_to_your_model.h5')
      def predict_image(image):
          image = cv2.resize(image, (224, 224))  # Beispiel für Modellgröße
          image = np.expand_dims(image, axis=0)  # Batch-Dimension hinzufügen
          prediction = model.predict(image)
          return prediction
      def capture_and_predict():
          camera = cv2.VideoCapture(0)
          while True:
              ret, frame = camera.read()
              if ret:
                  prediction = predict_image(frame)
                  print(f"Prediction: {prediction}")
                  cv2.imshow('Camera Feed', frame)
                  if cv2.waitKey(1) & 0xFF == ord('q'):
                      break
          camera.release()
          cv2.destroyAllWindows()
      if __name__ == "__main__":
          capture_and_predict()

5. Test und Kalibrierung

  1. Test der Sensoren und Motoren:
    • Überprüfe die Funktionalität von Lidar, Ultraschallsensoren, Kamera und Motorsteuerung in verschiedenen Szenarien.
  2. Kalibrierung der Sensoren:
    • Kalibriere die Sensoren für optimale Leistung und Genauigkeit.
  3. Integrationstest:
    • Teste die gesamte Systemintegration, einschließlich der KI-Modelle, und passe die Steuerlogik entsprechend an.
  4. Feinabstimmung:
    • Justiere die Parameter für die Sensoren, Motoren und KI-Modelle basierend auf den Testergebnissen, um die Leistung zu optimieren.

Diese Anleitung bietet eine grundlegende Struktur für den Bau meines fortschrittlichen Rasenmäher-Roboters. Je nach spezifischen Anforderungen und Komplexität des Projekts können zusätzliche Anpassungen und Erweiterungen erforderlich sein. - Zur Zeit befinde ich mich noch in der Montagephase. Sobald dieses Projekt komplett abgeschlossen ist wird dieser Berich mit allen Details und Photos erweitert.