ROBO PICO von Cytron Technologies: Perfekt für deine Roboterideen

Posted on by Stefan Draeger

In diesem Beitrag möchte ich dir den ROBO PICO von der Firma Cytron Technologies vorstellen und aufzeigen, wie dieser dir bei deinen Roboterideen behilflich sein kann.

Disclaimer: Dieser Beitrag wurde in Zusammenarbeit mit Cytron Technologies erstellt, und ich habe das Produkt ROBO PICO sowie den Raspberry Pi Pico WH kostenfrei erhalten. Die Meinungen und Ansichten in diesem Beitrag sind jedoch meine eigenen und wurden nicht von Cytron Technologies beeinflusst. Ich empfehle nur Produkte und Dienstleistungen, von denen ich überzeugt bin und die für meine Leser von Interesse sein könnten.

Den Raspberry Pi Pico WH habe ich dir bereits in einigen Beiträgen auf meinem Blog vorgestellt:

Inhaltsverzeichnis

Aufbau des ROBO PICO von Cytron Technologies

Die Platine des ROBO PICO verfügt über diverse Schnittstellen an welche die Motoren sowie Sensoren & Aktoren angeschlossen werden können. Hier findest du die derzeit sehr weit verbreiteten Grove Schnittstellen, welche den Vorteil bieten, dass die zum einen nur in eine Richtung gewaltfrei eingesteckt werden können und zum anderen eine fehlerhafte Verkabelung minimiert wird. Du musst hier lediglich drauf achten, dass du einen analogen Sensor auch an analoge Pins anschließt.

Schnittstellen und Klemmen

  • sieben Grove Schnittstellen,
  • zwei Schraubklemmen für Motoren,
  • eine Schraubklemme für eine externe Stromversorgung (3.6V bis 6V),
  • eine 4 x 3fach Stiftleiste für Servomotoren,
  • einen Maker Port, kompatibel mit QWIIC, Stemma QT Module (I2C)

An den Schraubklemmen für die Motoren findest du jeweils auch Taster um diese auch ohne Code auf dem Raspberry Pi Pico zu testen.

Zusätzliche Features

  • zwei NeoPixel,
  • zwei frei programmierbare Taster,
  • einen Piezo Buzzer,
  • ein Anschluss für eine LiPo Batterie (inkl. laden) mit LED Anzeige,

Lieferumfang zum ROBO PICO

Zum Lieferumfang des ROBO PICO gehört neben der Platine noch eine kleine Tüte mit Anschlusskabel und für die Schraubklemmen ein passender Schraubendreher.

Bezugsquellen

Wenn du dir diese nützliche Platine für deine Roboterideen zulegen möchtest, dann bekommst du dieses entweder im Onlineshop von Cytron Technologies für derzeit 14,9 $ (ca. 13,98 €, stand 14.09.2023) zzgl. Versandkosten.

Etwas günstiger bekommst du diesen im Raspishop für derzeit 13,98 € zzgl. Versandkosten.

Aufbauen und programmieren des Hungry Robot mit dem ROBO PICO und Raspberry Pi Pico

Auf der Seite https://www.cytron.io/p-robo-pico findest du einige lustige Projekte zum Nachbauen. Hier habe ich mir den Hungry Robot ausgesucht, der klingt recht lustig.

Hungry Robot with Raspberry Pi Pico WH & ROBO Pico
Dieses Video auf YouTube ansehen.

Zum Aufbau des Hungry Robot benötigst du einen 3D-Drucker. In meinem Fall nutze ich einen Anycubic Pro Mega und das Drucken aller Teile hat dabei 22h Stunden in normaler Qualität gedauert.

Auf Thingiverse bekommst du die benötigten Dateien kostenfrei zum Download:

Ansonsten benötigst du zum Zusammenbauen noch:

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Die Schrauben wähle ich von der Firma Spax und habe ich aus dem örtlichen Toom Baumarkt erworben. Sicherlich sind diese deutlich teurer als die günstigen Noname Schrauben. Jedoch haben die Schrauben von Spax ein scharfes Gewinde, welches besonders für 3D gedruckte Teile super funktionieren und nichts kaputt machen.

Zusätzlich benötigst du noch etwas Werkzeug:

  • einen mittleren Kreuzschraubendreher,
  • einen kleinen Krezuschraubendreher,
  • einen kleinen Seitenschneider,
  • ein Cuttermesser, sowie
  • einen Satz kleine Schlüsselfeilen

Das Cuttermesser sowie die Schlüsselfeilen benötigen wir für die gedruckten Teile. In meinem Fall musste ich das Supportmaterial mit dem Cuttermesser herausbrechen und mit den Feilen ein paar Überstände abfeilen.

Hinweis – Verbindungen mit Kabelbinder

Die meisten Verbindungen an diesem Roboter werden mit zwei Kabelbinder gelöst. Diese Art eine Verbindung aufzubauen ist wirklich cool und reicht für solche Verbindungen locker aus.

Herstellen einer Verbindung mit zwei Kabelbinder am Hungry Robot
Dieses Video auf YouTube ansehen.

Du darfst diese jedoch nicht zu stramm anziehen, da diese sich noch etwas bewegen müssen!

Schritt 1 – verbinden des ROBO PICO mit dem Gehäuse

Verbinden wir zunächst die Platine des ROBO PICO mit der Mounting Plate, dazu nutzen wir vier Schrauben 3,0 x 12 mm. Um diese Platte wiederum mit dem Gehäuse zu verbinden, nutzen wir die vier 3,5 x 12 mm Schrauben.

Schritt 2 – Servomotor einsetzen

Der Servomotor wird rechts in die große Öffnung gesteckt, sodass die Aufnahme des Ruderhorns nach oben zeigt und wird ebenso mit zwei Schrauben 3,0 x 12 mm montiert. An diesen Servomotor wird die Schaufel und diese wiederum die Verbindung zum Kopf montiert.

Für die Montage des Ruderhorns benötigst du zwei Schrauben, welche beim Servomotor beiliegen.

Den Servomotor verbinde ich am Ende mit dem GPIO12 (unten rechts).

Schritt 3 – Montage des Ultraschallabstandssensors

Ich habe dir oben in der Liste der benötigten Bauteile auch einen Ultraschallabstandssensor mit Grove Schnittstelle verlinkt. Es gibt auf dem Markt auch welche mit einfacher Stiftleiste, jedoch passen diese nicht in das Loch. (Der Abstand zwischen Sender & Empfänger ist zu weit.)

Ein weiterer Vorteil ist beim Modell mit der Grove Schnittstelle die einfache Verkabelung mit einem vorkonfektioniertem Kabel, welches eine fehlerhafte Verkabelung quasi schon fast ausschließt.

Das Grove Kabel führe ich durch das Loch vom Servomotor und schließe dieses an den GPIO3 an.

Schritt 4 – Montage der Schaufel

Die Schaufel wird links mit einem Kabelbinder verbunden und rechts an den Servomotor mit zwei Schrauben über ein Ruderhorn angeschraubt.

Das Ruderhorn ist jetzt noch nicht final mit dem Servomotor festgeschraubt, da wir unsere Schaufel mit Pythoncode noch ausrichten müssen.

Schritt 5 – Montage des Kopfes und der Verbindung zur Schaufel

Der Kopf wird wiederum mit einem Kabelbinder mit dem Körper verbunden und über den Link mit der Schaufel verbunden.

Mit diesem letzten Schritt haben wir nun den Hungry Robot fertig aufgebaut, nun können wir mit der Programmierung beginnen.

Programmieren des Hungry Robot in Micropython

Den hier verwendeten Raspberry Pi Pico WH kannst du in Circuitpython oder Micropython programmieren und natürlich auch in der Arduino IDE. Nachfolgend zeige ich dir, wie du diesen in Micropython in der Thonny IDE programmierst. Die Thonny IDE kannst du dir kostenfrei unter https://thonny.org/ für Window, macOS und Linux herunterladen.

Ggf. musst du deinen Pi Pico noch für Micropython flashen, wie du das machst, habe ich dir im Beitrag Raspberry PI Pico #1 – Vorstellung ausführlich erläutert.

Schritt 1 – Programmieren des Servomotors und Ausrichten der Schaufel

Im ersten Schritt wollen wir jetzt die Schaufel ausrichten, dazu müssen wir zunächst den Servomotor in die Position 0° bringen. Ich empfehle dir hier den Hungry Robot auf etwas zu stellen, sodass sich ggf. die Schaufel auch ohne Kraft nach unten bewegen kann.

# Bibliotheken laden
from machine import Pin, PWM
from time import sleep

#Servomotor am GPIO12 angeschlossen
servoPin = 12

#konfigurieren der PWM Kanäle für den Servomotor
pwm = PWM(Pin(servoPin))
#der Servomotor Typ SG90 arbeitet mit 50Hz
pwm.freq(50)

#ermittelte Positionen für die Schaufel
valUnten = 1580000
valOben = 500000

#Konstante für die Pause zwischen den Aktionen
PAUSE = 2

#Funktion zum öffnen des Mundes
def oeffneMund():
    global valOben
    print("oeffneMund")
    pwm.duty_ns(valOben)
    sleep(PAUSE)

#Funktion zum öffnen des Mundes
def schliesseMund():
    global valUnten
    print("schliesseMund")
    pwm.duty_ns(valUnten)
    sleep(PAUSE)

#Funktion zum deinitialisieren der PWM Kanäle
def ende():
    pwm.deinit()

#Damit das Programm sauber über das STOPP Symbol aus der Toolbar
#beendet werden kann und die Funktion ende ausgeführt wird,
#bauen wir um die Schleife ein Try/Except
try:
    #initial soll der Mund geschlossen sein
    schliesseMund()
    #Schleife von 1..5
    for i in range(1,5):
        #Mund öffnen
        oeffneMund()
        #Mund schließen
        schliesseMund()
    #Programm beenden
    ende()
#Wenn ein Fehler aufgetreten ist, dann....
except:
    print("Programm beendet!")
    ende()

Schritt 2 – Erkennen eines Signals vom Ultraschallabstandssensors

Im nächsten Schritt müssen wir jetzt ein Signal vom Ultraschallabstandssensor empfangen und auswerten. Die Funktionsweise des Hungry Robot ist ja, dass wir einen kleinen Gegenstand auf die Schaufel legen und dann dieser Gegenstand im Körper des Robots mithilfe eben dieser Schaufel befördert wird. Dazu nehmen wir den Abstand des Ultraschallabstandssensors und reagieren, wenn dieser kleiner als 8 cm ist.

Wie du einen Ultraschallabstandssensor in Micropython programmierst habe ich dir bereits im Beitrag Programmieren mit MicroPython #8: Ultraschall Abstandssensor HC-SR04 am ESP32 betreiben am ESP32 erläutert, dieses funktioniert auch fast 1:1 mit dem Raspberry Pi Pico WH.

Der hier verwendete Ultraschallabstandssensor von Seeed Studio hat nur einen digitalen Pin. Wir müssen also im Code jeweils immer umschalten.

##Import der benötigten Bibliotheken
import machine
from utime import sleep_us, ticks_us
from time import sleep
  
#Starten der Endlosschleife
while True:
  #definieren das der Pin als Ausgang dient
  pin=machine.Pin(3, machine.Pin.OUT)
  #Pin aktivieren
  pin.on()
  #zwei Microsekunden warten
  sleep_us(2)
  #Pin deaktivieren
  pin.off()
  #zehn Microsekunden warten
  sleep_us(10)
  #Pin aktivieren
  pin.on()
  #definieren das der Pin als Eingang
  pin=machine.Pin(3, machine.Pin.IN)
  #Endlosschleife solange der Pin LOW/0 ist
  while pin.value() == 0:
    pass
  #zwischenspeichern der vergangenen Microsekunden
  ticks1 = ticks_us()
  #Endlosschleife solange der Pin HIGH/1 ist
  while pin.value() == 1:
    pass
  #zwischenspeichern der vergangenen Microsekunden
  ticks2 = ticks_us()
  #die differenz zwischen den beiden Werten geteilt durch 58 sind
  #die Zentimer zum Objekt
  cm = (ticks2 - ticks1)  /  58.0
  #Ausgeben des berechenenten Wertes
  print(cm, " cm")
  #einlegen einer Pause von 0.5 Sekunden
  sleep(0.5)

Wenn wir uns nun die Werte anschauen, dann sehen wir, dass der Ultraschallabstandssensor die vordere Spitze der Schaufel erfasst, somit haben wir den maximalen Abstand ermittelt und müssen später nur prüfen, ob dieser um x Zentimeter unterschritten wurde.

Zusammenfassen der Codes

Nun haben wir beide Codefragmente fertiggestellt und können diese zu einem zusammenfassen. Zusätzlich habe ich hier noch eine kleine Funktion eingebaut, sodass eine Tonfolge auf dem Piezo Buzzer wiedergeben wird, wenn eine Aktion ausgeführt werden soll.

##Import der benötigten Bibliotheken
from utime import sleep_us, ticks_us
from machine import Pin, PWM
from time import sleep

#Servomotor am GPIO12 angeschlossen
servoPin = 12

#konfigurieren der PWM Kanäle für den Servomotor
pwm = PWM(Pin(servoPin))
#der Servomotor Typ SG90 arbeitet mit 50Hz
pwm.freq(50)

#ermittelte Positionen für die Schaufel
valUnten = 1580000
valOben = 500000

buzzer = PWM(Pin(22))

def makeBeep():
    buzzer.freq(350)
    buzzer.duty_u16(1000)
    sleep(0.1)
    buzzer.duty_u16(0)
    sleep(0.1)
    buzzer.freq(750)
    buzzer.duty_u16(1000)
    sleep(0.1)
    buzzer.duty_u16(0)
    sleep(0.1)
    buzzer.freq(350)
    buzzer.duty_u16(1000)
    sleep(0.1)
    buzzer.duty_u16(0)
    sleep(0.1)

def readUltrasonicSensor():
    #definieren das der Pin als Ausgang dient
    pin=machine.Pin(3, machine.Pin.OUT)
    #Pin aktivieren
    pin.on()
    #zwei Microsekunden warten
    sleep_us(2)
    #Pin deaktivieren
    pin.off()
    #zehn Microsekunden warten
    sleep_us(10)
    #Pin aktivieren
    pin.on()
    #definieren das der Pin als Eingang
    pin=machine.Pin(3, machine.Pin.IN)
    #Endlosschleife solange der Pin LOW/0 ist
    while pin.value() == 0:
      pass
    #zwischenspeichern der vergangenen Microsekunden
    ticks1 = ticks_us()
    #Endlosschleife solange der Pin HIGH/1 ist
    while pin.value() == 1:
      pass
    #zwischenspeichern der vergangenen Microsekunden
    ticks2 = ticks_us()
    #die differenz zwischen den beiden Werten geteilt durch 58 sind
    #die Zentimer zum Objekt
    return (ticks2 - ticks1)  /  58.0
  
#Funktion zum öffnen des Mundes
def oeffneMund():
    global valOben
    print("oeffneMund")
    pwm.duty_ns(valOben)
    sleep(1)

#Funktion zum öffnen des Mundes
def schliesseMund():
    global valUnten
    print("schliesseMund")
    pwm.duty_ns(valUnten)
    sleep(1)

#Funktion zum deinitialisieren der PWM Kanäle
def ende():
    pwm.deinit()

#initial soll der Mund geschlossen sein
schliesseMund()
while True:
    #lesen des Wertes vom Ultraschallabstandssensors
    value = readUltrasonicSensor()
    print(value)
    #Wenn der Wert kleiner als 4.5cm ist dann...
    if value < 4.5:
        #einen Ton ausgeben
        makeBeep()
        #eine Sekunde warten
        sleep(1)
        #Mund öffnen
        oeffneMund()
        #Mund schließen
        schliesseMund()
    #Warten von 0.2 Sekunden
    sleep(0.2)

#Beenden des Programmes
print("Programm beendet!")
ende()
fertiger Quellcode für den Hungry Robot in MicropythonHerunterladen

Betreiben des Hungry Robot an einer Powerbank

Damit das Programm auch ausgeführt wird, wenn dir den Hungry Robot an einer Powerbank betreiben, speichern wir diesen Code als boot.py Datei auf dem Raspberry Pi Pico WH.

Wenn du jetzt jedoch den Code ändern möchtest, dann musst du zuvor deinen Raspberry Pi Pico WH neu flashen, denn diese Datei boot.py wird sozusagen dauerhaft ausgeführt und führt dazu, dass du nur schwierig deinen Code neu aufspielen kannst!

Abschluss & Fazit zum ROBO PICO von Cytron Technologies

Mit dem ROBO PICO kannst du recht einfach Roboter Ideen umsetzen. Durch die viellzahl an Schnittstellen und die einfache Programmierung des Raspberry Pi Pico über Micropython konnte ich dir nun zeigen wie du deinen eigenen kleinen Hungry Robot aufbaust.

Was soll ich als nächstes damit umsetzen? Schreibe mir deine Idee in die Kommentare oder per Mail.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert