Ein Grundkonzept der Roboter, die ich bauen will ist, dass es eine Aufteilung der Bereiche Sensorik, Motorsteuerung, Kameraauswertung oder KI geben soll. Für die Motorsteuerung habe ich mich auf den Raspberry Zero festgelegt. Die Sensorik übernehmen kleine auf Input – Output spezialisierte Boards. Als erstes hatte ich mir dafür den Raspberry Pico zugelegt und damit die Ultraschallsensoren ausgewertet und per UART Schnittstelle an den Zero gesendet.
Ich hatte dabei ein etwas ungutes Gefühl, da die Kommunikation mit 115000 baud seriell laufen würde und nur eine Schnittstelle verfügbar ist.
Da kommt das ESP32 Board von espressif für knapp über 5.- Euro mit Bluetooth und WLan schon besser weg. Der Datenaustauch mit den anderen Boards per REST Service ist schon um einiges flexibler.
Die Installation und Konfiguration des ESP32 NODEMCU war mit etwas Recherche und Probieren relativ schnell geschafft.
Beim Start der REPL (Read Eval Print Loop) von Micropython (https://micropython.org/download/) gibt die Software direkt eine step by step Anleitung aus, wie der ESP32 im WLAN registriert werden kann. Ich prüfe also zum Start des Moduls, ob eine WLAN Verbindung besteht und wenn nicht verbinde ich:
import network
station = network.WLAN(network.STA_IF)
if (not station.isconnected()):
station.active(True)
station.connect("WLAN Routername", "Geheimes Passwort")
print("Connected to WLAN")
Mit einer sogenannten webrepl kann man sogar im Browser Befehle an den ESP32 senden:
import webrepl
webrepl.start()
Ein kleines Projekt habe ich dann auch direkt umgesetzt.
Zwei Infrarot Sensoren sollen Hindernisse außerhalb des Blickfelds der Kamera an die Fahrzeugsteuerung melden (links und rechts).
Damit man das auch optisch am Fahrzeug sehen kann soll jeweils eine rote oder eine gelbe LED Birne leuchten.
Die Sensoren Klasse:
# sensor.py
from machine import Pin
class Sensor():
def __init__(self, pin_sensor, pin_led):
self._pin_sensor = pin_sensor
self._pin_led = pin_led
self.blink_led(0)
self._sensor_value = self.read_sensor()
def set_collision(self, sensor_value: bool):
self._sensor_value = sensor_value
def get_collision(self) -> bool:
return self._sensor_value
def blink_led(self, on_off: bool):
led=Pin(self._pin_led,Pin.OUT) #create LED object from self._pin_led,Set Pin to output
led.value(int(on_off)) #Set led turn to: on_off
if on_off:
print("blink")
def read_sensor(self):
sensor = Pin(self._pin_sensor, Pin.IN)
sensor_value = bool(abs(sensor.value()-1))
self.blink_led(sensor_value)
self.set_collision(sensor_value)
und die Collision Klasse:
# collision.py
import time
from sensor import Sensor
class Collision():
def __init__(self):
self._sensors = {}
def add_sensor(self, sensor_name, pin_sensor, pin_led):
sensor = Sensor(pin_sensor, pin_led)
self._sensors[sensor_name] = sensor
def read_sensor(self, sensor):
sensor.read_sensor()
def read_loop(self, intervall: float):
while True:
for sensor_name in self._sensors:
self.read_sensor(self._sensors[sensor_name])
time.sleep(intervall)
Dann braucht man es nur noch in der boot.py einzubauen oder man erstellt eine kleine Ladedatei (bei mir liegt so etwas immer in lib), da ja die boot.py nicht so überfrachtet werden sollte:
# blink.py
import time
from lib.collision import Collision
c = Collision()
c.add_sensor("links", 35, 32)
c.add_sensor("rechts", 34, 33)
Jetzt aber:
# boot.py
webrepl.start()
import blink
from lib.collision import Collision
blink.c.read_loop(0.1)
Auch für den ESP32 gilt, dass man solche Dinge nicht in einer while Schleife lösen sollte, sondern mit einem Timer. Das spart zum Einen Strom und zum Anderen kann man auch noch weitere Prozesse laufen lassen und nicht nur diesen Einen.
Das mache ich dann wohl demnächst.
Kleiner Tipp zum Schluss. Sollte das ESP32 Entwicklungsboard nicht mehr über die REPL erreichbar sein hilft meist die Verbindung direkt mit Putty auf den COM Port. Das erspart einem dann das Komplett Reset des Boards.
