Met de ‘Grab-it’-robotarmen van JOY-IT kunnen hobbyisten, scholieren en studenten hun eerste ervaringen opdoen met programmeren in Python en eenvoudige projecten uitvoeren met de Raspberry Pi of Arduino.
In het eerste deel van het artikel ging het over de opbouw van de robotarm, het kalibreren van de servomotoren en de eerste bewegingen van de robotarm en de programmering daarvan. In het tweede deel vinden ontwikkelaars korte voorbeelden en ideeën voor uitbreidingen waarmee nog meer uit de Grab-it kan worden gehaald.
Creatieve projecten & toepassingen
Benodigde hardware:
- Grab-it robotarmkit van JOY-IT, inclusief accessoires zoals Raspberry Pi en Moto Pi.i
Empfohlenes weiteres Zubehör:
- Arduino UNO R3
- JOY-IT Motorino: motorbesturing voor Arduino
- HDMI-Kabel
- Raspberry Pi USB-C naar USB-kabel met schakelaar
- Kabelset voor stekkerborden
Creatief project – onderdelen stapelen
In het eerste creatieve project wordt de robotarm zo geprogrammeerd dat hij bouwblokken uit de 3D-printer pakt en deze in een daarvoor bestemde doos stapelt (afbeelding 1).
Hiervoor moeten eerst – zoals in deel 1 getoond – de volgende stappen worden uitgevoerd:
- Raspberry Pi met Moto Pi – of als alternatief met Arduino Uno en Motorino – installeren en verbinden met de robotarm.
- Raspberry Pi OS installeren.
- Bibliotheken installeren en servomotoren kalibreren.
Vervolgens kan het programma voor het stapelen van onderdelen op de Raspberry Pi worden uitgevoerd.
Hieronder volgt een fragment van de code waarmee de Grab-it de bewegingen via de Raspberry Pi in combinatie met de Moto Pi kan uitvoeren:
"programs": {
"Wuerfel stapeln": [
{
"M1": 1.5,
"M2": 1.35,
"M3": 1.486,
"M4": 1.45,
"M5": 1.5,
"M6": 1.1
},
{
"M1": 2.126,
"M2": 1.425,
"M3": 0.942,
"M4": 1.39,
"M5": 2.1,
"M6": 1.1
},
{
"M1": 2.123,
"M2": 0.774,
"M3": 0.942,
"M4": 1.122,
"M5": 2.1,
"M6": 1.1
},
{
"M1": 2.112,
"M2": 0.786,
"M3": 1.05,
"M4": 1.082,
"M5": 2.1,
"M6": 1.1
},
{
"M1": 2.112,
"M2": 0.663,
"M3": 1.05,
"M4": 1.082,
"M5": 2.1,
"M6": 1.1
},
{
"M1": 2.112,
"M2": 0.663,
"M3": 1.05,
"M4": 1.082,
"M5": 2.1,
"M6": 0.872
},
{
"M1": 2.112,
"M2": 0.876,
"M3": 1.05,
"M4": 1.082,
"M5": 2.1,
"M6": 0.872
},
{
"M1": 2.112,
"M2": 1.524,
"M3": 0.71,
"M4": 1.082,
"M5": 1.125,
"M6": 0.872
},
Grab-it goes IoT
Besturing via webinterface en app
In de volgende stap wordt de Grab-it voorbereid voor het IoT. Net als in een smart home moet de robotarm via een webinterface worden bestuurd. Hiervoor wordt de populaire Flask-webserver gebruikt als interface tussen de HTML-interface en de motorbesturing. Via de webinterface kan de robotarm vervolgens gemakkelijk worden bediend.
Naast de besturing via de pc werkt de besturing via HTML ook via een app en de smartphone. In combinatie met de Raspberry Pi kan de Grab-it dus heel eenvoudig via de smartphone worden bestuurd. Het idee hierachter is als volgt:
- De Raspberry Pi bestuurt de Grab-it via de PCA9685-servodriver. De PCA9685 is een bouwsteen die tot 16 servomotoren tegelijkertijd nauwkeurig bestuurt via slechts twee kabels van de Raspberry Pi, omdat hij zelf de benodigde PWM-signalen genereert en zo de Pi ontlast.
- Op de Raspberry Pi draait een Flask-webserver. Een Flask-server is een lichtgewicht webframework voor Python waarmee snel eenvoudige webapplicaties of interfaces kunnen worden gemaakt waarmee apparaten zoals de Grab-it via een browser kunnen worden aangestuurd.
- Via een interface in de browser (pc of smartphone-app) kan de arm gemakkelijk worden aangestuurd.
Hiervoor wordt eerst het systeem voorbereid voor de installatie. Vervolgens wordt de servobesturing in Python geïmplementeerd en worden de Flask-webserver en de HTML-interface gemaakt.
1. Systeem voorbereiden:
- I2C activeren:
sudo raspbi-config
sudo reboot- Stuurprogramma’s voor de SMBus installeren:
sudo apt update;
sudo apt install python3-flask python3-smbus i2c-tools- Controleren of de PCA9685 wordt gevonden:
sudo i2cdetect -y 12. Servobesturing voorbereiden:
- Maak een bestand met de naam
pca9685_control.py.- In dit bestand wordt de aansturing van de Grab-it ingekapseld (zie codefragment):
# pca9685_control.py
import smbus
import time
import math
PCA9685_ADDR = 0x40
bus = smbus.SMBus(1)
MODE1 = 0x00
PRESCALE = 0xFE
LED0_ON_L = 0x06
def set_pwm_freq(freq_hz=50):
prescaleval = 25000000.0 / (4096.0 * freq_hz) - 1.0
prescale = int(math.floor(prescaleval + 0.5))
oldmode = bus.read_byte_data(PCA9685_ADDR, MODE1)
newmode = (oldmode & 0x7F) | 0x10
bus.write_byte_data(PCA9685_ADDR, MODE1, newmode)
bus.write_byte_data(PCA9685_ADDR, PRESCALE, prescale)
bus.write_byte_data(PCA9685_ADDR, MODE1, oldmode)
time.sleep(0.005)
bus.write_byte_data(PCA9685_ADDR, MODE1, oldmode | 0xA1)
def set_pwm(channel, on, off):
bus.write_byte_data(PCA9685_ADDR, LED0_ON_L + 4 * channel, on & 0xFF)
bus.write_byte_data(PCA9685_ADDR, LED0_ON_L + 4 * channel + 1, on >> 8)
bus.write_byte_data(PCA9685_ADDR, LED0_ON_L + 4 * channel + 2, off & 0xFF)
bus.write_byte_data(PCA9685_ADDR, LED0_ON_L + 4 * channel + 3, off >> 8)
def angle_to_pwm(angle):
pulse_min = 150 # ggf. an deine Servos anpassen
pulse_max = 600
return int(pulse_min + (pulse_max - pulse_min) * angle / 180)
def set_servo_angle(channel, angle):
angle = max(0, min(180, angle))
pwm_val = angle_to_pwm(angle)
set_pwm(channel, 0, pwm_val)
# Beispiel-Kanäle (anpassen falls nötig)
BASE = 0
SHOULDER = 1
ELBOW = 2
WRIST = 3
GRIPPER = 4
# Startposition (optional)
def home_position():
set_servo_angle(BASE, 90)
set_servo_angle(SHOULDER, 90)
set_servo_angle(ELBOW, 90)
set_servo_angle(WRIST, 90)
set_servo_angle(GRIPPER, 60)
# Beim Import einmal Frequenz setzen
set_pwm_freq(50)
3. Flask-webserver aanmaken:
- Het bestand
app.pywordt aangemaakt om de aansturing van Flask mogelijk te maken (afbeelding 3).
4. HTML-webinterface aanmaken:
- Maak een map templates naast
app.pyaan en plaats daarin het bestand index.html (afbeelding 4).
5. Daarnaast wordt een JavaScript opgeslagen:
- het JavaScript activeert de functies van de knoppen (afbeelding 5).
Nu kan de server worden gestart en in de browser worden bediend. Hiervoor hoeft alleen maar deze opdracht in de map met app.py te worden uitgevoerd:
python3 app.pyVervolgens kan op een pc of smartphone in hetzelfde wifi-netwerk de browser worden geopend om toegang te krijgen tot de Raspberry Pi:
bijv.:
http://DEINE_PI_IP:5000
of:
http://192.168.0.23:5000De Grab-it kan dan net als een smart home-apparaat eenvoudig en comfortabel worden bediend via de webinterface op de pc of smartphone (afbeelding 6).
U kunt ook kiezen of u de Flask-app handmatig of met Autostart wilt starten. Dit wordt niet gespecificeerd in de code, maar in het Raspberry Pi-systeem.
1. Handmatig starten:
cd /home/pi/grab-it-web
Python3 app.py2. Autostart:
app.py Ausführungsrechte geben: sudo chmod +x app.py
Servicedatei erstellen: sudo nano /etc/systemd/system/roboterarm.service
Inhalt:
[Unit]
Description=Roboterarm Steuerung App
After=network.target
[Service]
ExecStart=/usr/bin/python3 /home/pi/V3/app.py
WorkingDirectory=/home/pi/V3/
User=root
# Setze Restart auf 'always', damit der Service bei einem Absturz neu startet
Restart=always
# Optional: Setze eine kleine Verzögerung vor dem ersten Neustart
RestartSec=5
[Install]
WantedBy=multi-user.target
===================
daemon-Dienst neu laden: sudo systemctl daemon-reload
Autostart aktivieren: sudo systemctl enable roboterarm.service
Bediening via controller
Naast bediening via smartphone of pc is het ook interessant om de robotarm met een joystick of controller te bedienen. Een Xbox-controller werd via een USB-interface met de Raspberry Pi verbonden. Via de reeds geïnstalleerde Flask-server kan de arm gemakkelijk via de controller worden bediend.
- Installeer de Xbox-controller met de volgende opdracht:
sudo apt install python3-evdev - Installeer Python Script:
XboxController.python(afbeelding 7)
Zo kan de Grab-it eenvoudig en snel met de controller in elke gewenste positie worden bewogen.
Een uittreksel van de code laat zien hoe u te werk moet gaan om de Xbox-controller te activeren:
import threading
import time
from evdev import InputDevice, categorize, ecodes, list_devices
# Robotersteuerung importieren - NEUE IMPORT-METHODE
try:
import roboter_arm_steuerung as RAS
ARM_CONTROLLER = RAS.ARM_CONTROLLER
MIN_MAX_PULSES = RAS.MIN_MAX_PULSES
except ImportError:
print("FEHLER: roboter_arm_steuerung.py konnte nicht importiert werden.")
ARM_CONTROLLER = None
# -------------------------------------------------
# Controller Maps & Einstellungen
# -------------------------------------------------
SENSITIVITY_FACTOR = 0.005 # Pulsänderung pro Tick für M1-M4
SENSITIVITY_FACTOR_M5_M6 = 0.025 # NEU: Pulsänderung pro Tick für M5-M6 (5x schneller)
DEADZONE = 0.15 # Stick Drift Filter
# Achsen
ABS_X_LEFT = ecodes.ABS_X
ABS_Y_LEFT = ecodes.ABS_Y
ABS_X_RIGHT = ecodes.ABS_RX
ABS_Y_RIGHT = ecodes.ABS_RY
ABS_LT_TRIGGER = ecodes.ABS_Z
ABS_RT_TRIGGER = ecodes.ABS_RZ
# Buttons
BTN_START = ecodes.BTN_START
BTN_BACK = ecodes.BTN_SELECT
BTN_X = ecodes.BTN_SOUTH
BTN_Y = ecodes.BTN_NORTH
BTN_LB = ecodes.BTN_TL # NEU
BTN_RB = ecodes.BTN_TR # NEU
# Motor-Mapping
AXIS_MAPPING = {
ABS_X_LEFT: 'Motor1',
ABS_Y_LEFT: 'Motor2',
ABS_Y_RIGHT: 'Motor3',
ABS_X_RIGHT: 'Motor4',
ABS_LT_TRIGGER: 'Motor6', # Greifer (Öffnen)
ABS_RT_TRIGGER: 'Motor6', # Greifer (Schließen)
}
Uitbreidingen & aanpassingen
Wie zich er verder in wil verdiepen en nog meer uit zijn Grab-it wil halen, kan de robotarm aanzienlijk verbeteren door gerichte mechanische en software-optimalisaties.
Mechanische upgrades voor de Grab-it van JOY-IT
De Grab-it-robotarmen kunnen met eenvoudige mechanische upgrades gericht worden aangepast en geoptimaliseerd. Bijzonder effectief zijn grijperopzetstukken, verlengde armen en camerahouders, die met een 3D-printer kunnen worden gemaakt.
Verschillende grijpervormen, zoals rubberen punten voor ronde objecten of brede bekken voor platte onderdelen, verbeteren de veelzijdigheid en precisie bij het grijpen. Verlengde armsegmenten vergroten het werkbereik, maar moeten worden ondersteund door stabielere servo’s of lichte materialen zoals koolstof om trillingen te voorkomen.
Een camerahouder boven de grijper maakt het gebruik van AI-visie of kleurherkenning via OpenCV mogelijk. Voor meer stabiliteit wordt aanbevolen om wankele kunststofverbindingen te vervangen door metalen scharnieren of kogellagers. Als u een camera op de Grab-it wilt aansluiten, kunt u met deze code controleren of de camera correct is aangesloten en deze vervolgens gebruiken voor kleur- of objectherkenning:
# camera_test.py
import cv2
# 0 = erste Kamera (USB-Webcam oder PiCam über /dev/video0)
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("Kamera konnte nicht geöffnet werden!")
exit()
while True:
ret, frame = cap.read()
if not ret:
print("Kein Kamerabild empfangen!")
break
# Bild anzeigen
cv2.imshow("Grab-it Kamera – Livebild", frame)
# ESC zum Beenden
if cv2.waitKey(1) == 27:
break
cap.release()
cv2.destroyAllWindows()
Ook de servo-opname kan worden versterkt of gedempt om trillingen te verminderen. Met deze aanpassingen kan de Grab-it nauwkeuriger, stabieler en veelzijdiger worden gebruikt – perfect voor ambitieuze makerprojecten.
Software-upgrades voor de Grab-it – meer intelligentie dankzij OpenCV
Met gerichte software-upgrades kan de Grab-it-robotarmen van JOY-IT aanzienlijk slimmer en autonomer worden gemaakt. Bijzonder effectief is de integratie van OpenCV om met behulp van een USB- of Raspberry Pi-camera kleur-, vorm- of objectherkenning te implementeren.
Met eenvoudige OpenCV-functies kan de robot live videogegevens analyseren, kleurgebieden filteren en de posities van objecten bepalen. In combinatie met een servodriver kunnen bijvoorbeeld herkende objecten automatisch worden benaderd en gegrepen. Voor het herkennen van kleuren volstaan eenvoudige filters, terwijl contourherkenning of AI-gebaseerde modellen met bijvoorbeeld TensorFlow Lite nauwkeurigere resultaten mogelijk maken.
Voorbeeld (objectherkenning met OpenCV):
import cv2
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, (100,150,0), (140,255,255))
cv2.imshow("Erkennung", mask)
if cv2.waitKey(1) == 27:
break
cap.release()
cv2.destroyAllWindows()
Een andere upgrade is bijvoorbeeld het invoegen van bewegingsprofielen die flexibel reageren op basis van de cameragegevens. Daarnaast kan een API of een Flask-webinterface worden gebruikt om commando’s van webapplicaties of smartphone-apps over te nemen. Deze software-uitbreidingen maken de Grab-it tot een lerend systeem dat taken niet alleen uitvoert, maar ook actief “waarnemt” en erop reageert.
Community & bronnen
Hoewel er maar weinig specifieke projecten op GitHub bestaan, biedt de maker-community rond de Grab-it-robotarmen van JOY-IT waardevolle bronnen die je kunt gebruiken. Op GitHub vind je een kleine selectie van repositories, bijvoorbeeld voorbeeldschetsen voor de integratie van OpenCV of Flask-webinterfaces.
Daarnaast is het de moeite waard om platforms zoals Thingiverse of MyMiniFactory te bekijken voor STL-bestanden voor aangepaste grijpers of kamerahouders. Maker-forums en DIY-blogs, bijvoorbeeld Reddit-threads of Insta-Stories, bieden meer ervaringen en tips, bijvoorbeeld voor het verbeteren van de mechanica, het nauwkeurig afstellen van de servo’s of het integreren van een camera.
Hoewel er momenteel geen grote centrale community speciaal voor de Grab-it bestaat, kun je door gericht te zoeken op trefwoorden zoals “JOY-IT Grab-it” individuele projecten en tutorials vinden. Gebruik deze bronnen als uitgangspunt, pas ze aan je setup aan en documenteer je eigen ontwikkeling om deel uit te maken van de groeiende community.
Grab-it in actie & perspectieven
In het tweede deel van het artikel over de Grab-it van JOY-IT wordt getoond hoe de eerste projecten met de robotarm kunnen worden gerealiseerd. Bovendien is de Grab-it “IoT-compatibel” gemaakt en kan hij worden bediend via een controller, smartphone of pc.
Aangezien de community voortdurend groeit, zijn er op GitHub en andere ontwikkelaarsforums talrijke projecten, upgrades en andere bronnen te vinden waarmee de Grab-it voortdurend kan worden uitgebreid, AI-compatibel kan worden gemaakt en verder kan worden ontwikkeld.
Afbeeldingen: Adobe Stock, reichelt elektronik
Naar het eerste deel van het artikel:
Setup en basics: Met de Grab-it de wereld van de robotica in – Deel 1
