Met de Grab-it de wereld van de robotica in – Deel 1

Met de “Grab-it” 5-assige robotarm van de fabrikant JOY-IT kunnen hobbyisten, scholieren en studenten een eenvoudige start maken in de wereld van elektronica, mechanica en programmering. Omdat alle gangbare single-board computers (SBC’s) en microcontrollers kunnen worden gebruikt, bent u niet gebonden aan een bepaald platform en kunt u snel aan de slag. In dit voorbeeld beperken we ons tot de Raspberry Pi, model 4 in combinatie met een Moto Pi en een Arduino Uno in combinatie met een Motorino. Met de krachtige servomotoren en de krachtige grijper kunnen bijvoorbeeld kleine lasten probleemloos worden vastgepakt en van A naar B worden verplaatst.

Opbouw, kalibratie van de motoren en aanwijzingen

• aluminium robotarm, serienummer: Robot02
• Raspberry Pi Model 4, 2 GB incl. voeding
• Moto Pi voor het aansturen van de servo’s
• 20 W-voeding voor de voeding van de besturingskaart
• geheugenkaart met Noobs, tools en handleiding
• 1,5 m HDMI-kabel (HDMI Micro > HDMI) voor 4K-weergave

De robotarm werkt met de volgende motoren:

• koppel: 21,5 kg·cm bij 7,4 V
• spanning: 5 tot 7,4 V DC
• 360° mechanische hoek, 180° werkbereik
• metalen tandwieloverbrenging
• besturing via pulsbreedtemodulatie (PWM)

Aanbevolen extra accessoires:

• Arduino UNO R3
• JOY-IT Motorino: motorbesturing voor Arduino
• HDMI-kabel
• Raspberry Pi USB-C naar USB-kabel met schakelaar
• kabelset voor stekkerborden

De robotarm van aluminium wordt aangedreven door zes afzonderlijk aan te sturen motoren en is bovendien gemonteerd op een gelagerde draaitafel (360°). De basisplaat is gemaakt van 4,5 mm dik acryl en voorzien van bevestigingsgaten voor alle gangbare SBC’s en microcontrollers. Afstandhouders maken een eenvoudige bevestiging van de basisplaat mogelijk, bijvoorbeeld op een werkbank of een bureau.

Stapsgewijze montage en kalibratie van de motoren

Voor de montage is het volgende nodig:

• Montagemateriaal: kruiskopschroevendraaier, platte tang, inbussleutel (meegeleverd), eventueel pincet
• laptop en Raspberry Pi met Moto Pi of Arduino met Motorino voor het kalibreren van de motoren
• Montagehandleiding van JOY-IT

Uitvoering van de montage:

• Verwijder de folie van de basisplaat.
• Bevestig een van de ronde servohendels met vier schroeven op een van de ronde platen.
• Vervolgens wordt een servomotor op de ronde plaat gemonteerd. Hiervoor wordt de plaat op de servo gelegd en met vier schroeven en moeren bevestigd. Hierbij moet erop worden gelet dat het servotandwiel precies in het midden is uitgelijnd.
• In de vierde stap wordt het lager gemonteerd. Hiervoor worden de vier lange schroeven door de eerste ring gestoken en vervolgens wordt het lager erop geplaatst. Nu wordt de tweede ring erop geplaatst en met de vier lange messing hulzen vastgeschroefd.
• Vervolgens plaatst u de ronde plaat uit stap 2 met de servobevestiging op de servokop uit stap 3 en bevestigt u deze in het midden met een schroef.
• Plaats de plaat met de servo op de lagerhouder en schroef deze vast met vier moeren (afbeelding 03).

• Bevestig een lager in de eerste hoekplaat.
• Schroef de hoekplaat vast aan de ronde plaat.
• Schroef deze nu vast aan het lager.
• Nu kan het op de basisplaat worden gemonteerd en aan de onderkant met messing hulzen worden bevestigd. Let op! Zorg ervoor dat de schroefdraad niet uit de hulzen steekt en dat er eerst moeren op de schroefdraadpennen worden bevestigd. Deze worden vervolgens aan de bovenkant vastgedraaid. Nu kunnen ook de kunststof afstandhouders aan de onderkant worden bevestigd (afbeelding 04).
• Steek de servohendels op de overige servo’s (afbeelding 05).

LET OP: Voor de montage moeten de servomotoren in hun basispositie worden gekalibreerd! (Instructies verderop)

• Schroef de twee U-platen vast met elk vier schroeven en moeren.
• Plaats de servo en bevestig deze met elk vier schroeven en moeren en verbind de servoarm met de robotarm met vier schroeven (afbeelding 06).

• Schroef nog een U-plaat met een hoek vast en bevestig deze aan een servohouder.
• Bevestig vervolgens weer een lager op de bekende plaats.
• Plaats een servomotor en bevestig deze zoals bekend met vier schroeven en moeren. Bevestig deze vervolgens met vier schroeven aan de robotarm.
• Leg twee servohouders op elkaar en verbind ze met schroeven en moeren.
• Installeer zoals gewoonlijk het lager en de servo.
• Bevestig met vier schroeven aan de robotarm en bevestig de laatste servo zoals gewoonlijk aan de grijper (afbeelding 07).

• Tot slot moet de robotklauw nog worden gemonteerd. Hiervoor worden vier klauwvingers afwisselend met de korte messing afstandhouders vastgeschroefd. Als afsluiting worden aan de ene kant moeren en aan de andere kant schroeven gebruikt.
• Vervolgens worden vier messing afstandhouders aan de servo bevestigd. Er moet op worden gelet dat er telkens een sluitring onder en boven de afstandhouder komt. Vervolgens wordt een schroef door de plaat gestoken en deze vervolgens met de servo vastgeschroefd. Hierbij worden twee sluitringen op de schroef geplaatst.
• Vervolgens wordt een lager in de grijper geplaatst.
• De eerste klauw wordt met een sluitring en moer op de servo bevestigd.
• Bevestig bij de tweede klauw een servohendel met vier schroeven.
• Bevestig de tweede klauw en schroef deze vast.
• Bevestig een servohendel aan de hoek en zet deze met een schroef vast aan de grijparm.
• Als laatste stap schroeft u de klauw vast aan de hoek (afbeelding 8).

Kalibreren van de motoren

Voordat de servomotoren worden gebruikt en gemonteerd, moeten ze in hun positie worden gekalibreerd voordat ze op de robotarm worden gemonteerd. Alleen zo kan het volledige werkbereik van de robotarm worden benut en de juiste uitgangspositie van de Grab-it worden behouden. Voor een optimale instelling moeten de motoren op een waarde van 1500 worden ingesteld. Alleen de motor van de klauw wordt op de waarde 1600 geprogrammeerd. Voor het kalibreren wordt de betreffende motor aangesloten op de besturingseenheid, zoals de MotoPi in combinatie met de Raspberry Pi of Motorino met Arduino.

• De Raspberry Pi met aangesloten MotoPi-printplaat wordt aangesloten op de stroomvoorziening (of als alternatief de Arduino met Motorino).
• Vervolgens wordt de externe 5V-voeding voor de stroomvoorziening van de servomotoren aangesloten op de MotoPi.
• Het “kalibratiescript” wordt gestart zoals hieronder beschreven. (Let op! Let op de inspringingen bij Python)
• Nu moeten voor elke te installeren servomotor de volgende stappen worden uitgevoerd:
• De servomotor die momenteel moet worden geïnstalleerd, wordt op zijn respectieve positie op de MotoPi aangesloten (afbeelding 09).

De gewijzigde bibliotheek wordt naar de Raspberry Pi gekopieerd en de volgende commando’s worden uitgevoerd:

sudo apt-get install python3-pip
sudo apt install python3-smbus

Navigeer in de terminal naar de map en installeer de bibliotheek met de volgende opdracht:

sudo python3 setup.py install

Nu wordt het nieuwe bestand aangemaakt met de volgende opdracht:

sudo nano calibrate.py

De volgende code wordt in het bestand geschreven:

from __future__ import division 
import time 
import Adafruit_PCA9685 
# Initialisierung mit alternativer Adresse 
pwm = Adafruit_PCA9685.PCA9685(address=0x41) 
# Einstellen der Minimal- und Maximal-Pulslaengen 
servo_min = 150 # Minimale Pulslaenge 
servo_max = 600 # Maximale Pulslaenge 
# Hilfsfunktion 
def set_servo_pulse(channel, pulse): 
pulse_length = 1000000 
pulse_length /= 50 
print('{0}us per period'.format(pulse_length)) 
pulse_length /= 4096 
print('{0}us per bit'.format(pulse_length)) 
pulse *= 1000 
print(pulse_length) 
pulse /= pulse_length 
print(pulse) 
pulse = round(pulse) 
print(pulse) 
pulse = int(pulse) 
print (pulse) 
pwm.set_pwm(channel, 0, pulse) 
# Frequenz auf 50Hz setzen 
pwm.set_pwm_freq(50) 
# Bewege Servo 0-4 auf Position 1500 
# Bewege Servo 5 auf Position 1600 
set_servo_pulse(0,1.5) 
time.sleep(1.5) 
set_servo_pulse(1,1.5) 
time.sleep(1.5) 
set_servo_pulse(2,1.5) 
time.sleep(1.5) 
set_servo_pulse(3,1.5) 
time.sleep(1.5) 
set_servo_pulse(4,1.5) 
time.sleep(1.5) 
set_servo_pulse(5,1.6) 
time.sleep(1.5)

Sla het bestand op met CTRL+O en sluit de editor met CTRL+X. Start nu de kalibratie met de volgende opdracht:

sudo python3 calibrate.py

Eerste bewegingen uitvoeren met de Raspberry Pi en Moto Pi

Installatie van het Raspberry Pi OS

• Raspberry Pi OS installeren
  • installeer het gewenste besturingssysteem (bijv. OS Lite 64 bit)
  • kopieer wifi met naam en wachtwoord naar SD-kaart
  • kopieer route-bestand naar SD-kaart
  • plaats SD-kaart in Pi
  • start Pi en voer OS uit (start automatisch)

• kopieer bibliotheek naar Raspberry Pi
• een Bestand aanmaken
• voer code voor kalibratie in (zoals hierboven beschreven)

Pulsbreedtemodulatie (PWM)

Pulsbreedtemodulatie (PWM) is een methode waarbij de breedte van een elektrische puls wordt gewijzigd om analoge waarden zoals positie, snelheid of helderheid digitaal te regelen. Een Arduino kan alleen 0 V (LOW) of 5 V (HIGH) uitvoeren, geen echte tussenwaarden. Met PWM simuleert men tussenwaarden door zeer snel tussen HIGH en LOW te schakelen.

Servomotoren, zoals die in de Grab-it zijn ingebouwd, begrijpen geen analoge signalen, maar speciale PWM-signalen met 50 Hz (om de 20 ms). Dat betekent dat er om de 20 ms een stuurimpuls wordt verzonden en dat de lengte van de puls de positie aangeeft. De servo meet hoe lang de puls HIGH is, niet hoe vaak. Er zijn verschillende manieren om een PWM-signaal te genereren. Voor de Grab-it zijn de varianten RPi.GPIO en pigpio geschikt.

Variant 1:

import RPi.GPIO as GPIO
import time

# Pin-Nummer (z. B. GPIO 17)
servo_pin = 17

GPIO.setmode(GPIO.BCM)
GPIO.setup(servo_pin, GPIO.OUT)

# PWM mit 50 Hz (für Servos)
pwm = GPIO.PWM(servo_pin, 50)
pwm.start(0)

def set_angle(angle):
    # Umrechnen von Winkel (0–180) auf Duty-Cycle (2–12 %)
    duty = 2 + (angle / 18)
    GPIO.output(servo_pin, True)
    pwm.ChangeDutyCycle(duty)
    time.sleep(0.5)
    GPIO.output(servo_pin, False)
    pwm.ChangeDutyCycle(0)

# Beispielbewegung
try:
    set_angle(0)
    set_angle(90)
    set_angle(180)
finally:
    pwm.stop()
    GPIO.cleanup()

Variant 2:

import pigpio
import time

pi = pigpio.pi()
servo_pin = 17

# Servo auf 90° (1.5 ms)
pi.set_servo_pulsewidth(servo_pin, 1500)
time.sleep(1)

# Servo auf 0°
pi.set_servo_pulsewidth(servo_pin, 1000)
time.sleep(1)

# Servo auf 180°
pi.set_servo_pulsewidth(servo_pin, 2000)
time.sleep(1)

# Servo stoppen
pi.set_servo_pulsewidth(servo_pin, 0)
pi.stop()

Codevoorbeeld: eenvoudige bewegingen, grijpen, draaien

Nadat alle motoren in de juiste positie zijn gekalibreerd, de robotarm is opgebouwd en alle onderdelen correct zijn aangesloten, kunnen de eerste bewegingen van de arm worden uitgevoerd. Hiervoor hoeft alleen de juiste code op de Raspberry Pi te worden uitgevoerd. De bibliotheek moet al tijdens het kalibreren zijn gekopieerd. Een code voor de eerste bewegingen kan bijvoorbeeld hier worden gedownload (afbeelding 12).

Met deze opdracht kan de code worden uitgevoerd en beweegt de arm:

sudo python3 RoboterArm.py 

Een fragment van de code is hier te zien:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import division
import time
import RPi.GPIO as GPIO
import Adafruit_PCA9685
import spidev
import time
import sys
import signal
import logging

# Standardadresse: (0x40).
#pwm = Adafruit_PCA9685.PCA9685()

# Initalisierung mit alternativer Adresse
pwm = Adafruit_PCA9685.PCA9685(address=0x41)

# Einstellen der Minimal- und Maximal-Pulslängen
servo_min = 150  # Minimale Pulslänge
servo_max = 600  # Maximale Pulslänge

# Hilfsfunktion
def set_servo_pulse(channel, pulse):
    pulse_length = 1000000
    pulse_length /= 50
    pulse_length /= 4096
    pulse *= 1000
    pulse /= pulse_length
    pulse = round(pulse)
    pulse = int(pulse)
    pwm.set_pwm(channel, 0, pulse)

Alternatieve besturing met Arduino

Aansluiting & bekabeling met de Motorino

Het JOY-IT Motorino Shield is een opsteekkaart (“Shield”) voor de Arduino Uno. Deze dient als alternatief voor de combinatie van Raspberry Pi en Moto Pi en omvat:

• 6 servo-aansluitingen (voor je robotarm)
• extra stroomvoorziening voor servo’s (tot 12 A)
• Knop-, LED- en sensoraansluitingen

Procedure:

• Shield aansluiten
• Servo’s aansluiten
• Stroomvoorziening aansluiten
• Arduino met pc verbinden
• Optioneel: LED- en knopaansluitingen verbinden

Voorbeeldcode met Servo.h-bibliotheek:

Met de volgende code kunnen we de Grab-it – vergelijkbaar met het codevoorbeeld voor de Pi – eerste bewegingen laten uitvoeren.

#include <Servo.h>  // Standardbibliothek zur Ansteuerung von Servomotoren

// === Servo-Objekte für die 6 Motoren des Grab-it Roboterarms ===
Servo baseServo;       // Dreht den Arm (Basis)
Servo shoulderServo;   // Schultergelenk
Servo elbowServo;      // Ellbogengelenk
Servo wristServo;      // Handgelenk
Servo clawServo;       // Greifklaue
Servo wristRotateServo;// Drehung des Handgelenks

// === Pinbelegung (Motorino Shield oder direkt am Arduino) ===
// Passen Sie die Pins ggf. an Ihre Verkabelung an
const int BASE_PIN        = 2;
const int SHOULDER_PIN    = 3;
const int ELBOW_PIN       = 4;
const int WRIST_PIN       = 5;
const int CLAW_PIN        = 6;
const int WRIST_ROT_PIN   = 7;

// === Anfangspositionen (in Grad) ===
int basePos        = 90;
int shoulderPos    = 90;
int elbowPos       = 90;
int wristPos       = 90;
int clawPos        = 90;
int wristRotatePos = 90;

// === Setup ===
void setup() {
  // Servos mit Pins verbinden
  baseServo.attach(BASE_PIN);
  shoulderServo.attach(SHOULDER_PIN);
  elbowServo.attach(ELBOW_PIN);
  wristServo.attach(WRIST_PIN);
  clawServo.attach(CLAW_PIN);
  wristRotateServo.attach(WRIST_ROT_PIN);

  // Servos auf Ausgangsposition fahren
  baseServo.write(basePos);
  shoulderServo.write(shoulderPos);
  elbowServo.write(elbowPos);
  wristServo.write(wristPos);
  clawServo.write(clawPos);
  wristRotateServo.write(wristRotatePos);

  delay(1000); // kurze Pause zum Stabilisieren
}

// === Hauptprogramm ===
void loop() {
  // Beispielbewegung 1: Objekt greifen und bewegen
  moveClaw(60);     // Klaue öffnen
  delay(500);
  
  moveBase(120);    // Arm nach rechts drehen
  delay(500);
  
  moveShoulder(70); // Arm absenken
  delay(500);
  
  moveClaw(100);    // Klaue schließen (Objekt greifen)
  delay(1000);
  
  moveShoulder(90); // Arm anheben
  delay(500);
  
  moveBase(60);     // Arm nach links drehen
  delay(500);
  
  moveClaw(60);     // Klaue öffnen (Objekt ablegen)
  delay(1000);
}

// === Hilfsfunktionen ===
void moveBase(int pos) {
  pos = constrain(pos, 0, 180);
  baseServo.write(pos);
}

void moveShoulder(int pos) {
  pos = constrain(pos, 0, 180);
  shoulderServo.write(pos);
}

void moveElbow(int pos) {
  pos = constrain(pos, 0, 180);
  elbowServo.write(pos);
}

void moveWrist(int pos) {
  pos = constrain(pos, 0, 180);
  wristServo.write(pos);
}

void moveWristRotate(int pos) {
  pos = constrain(pos, 0, 180);
  wristRotateServo.write(pos);
}

void moveClaw(int pos) {
  pos = constrain(pos, 50, 120); // Begrenzung, um Überlast zu vermeiden
  clawServo.write(pos);
}
Potentiometersteuerung oder einfache Buttonsteuerung
Servo über Potentiometer steuern:
#include <Servo.h>

Servo servo1;

const int potPin = A0;   // Potentiometer an analogem Pin A0
const int servoPin = 2;  // Servo-Signal an D2

void setup() {
  servo1.attach(servoPin);
}

void loop() {
  int sensorValue = analogRead(potPin);           // 0–1023 lesen
  int angle = map(sensorValue, 0, 1023, 0, 180);  // in 0–180° umrechnen
  servo1.write(angle);                            // Servo auf Winkel setzen
  delay(10);
}

Servos über 2 Buttons steuern:
#include <Servo.h>

Servo servo1;

const int buttonLeft = 7;
const int buttonRight = 8;
const int servoPin = 2;

int angle = 90; // Startposition

void setup() {
  servo1.attach(servoPin);
  servo1.write(angle);

  pinMode(buttonLeft, INPUT_PULLUP);
  pinMode(buttonRight, INPUT_PULLUP);
}

void loop() {
  // Button gedrückt = LOW (wegen INPUT_PULLUP)
  if (digitalRead(buttonLeft) == LOW) {
    angle--; // Winkel verringern
    angle = constrain(angle, 0, 180);
    servo1.write(angle);
    delay(100);
  }

  if (digitalRead(buttonRight) == LOW) {
    angle++; // Winkel erhöhen
    angle = constrain(angle, 0, 180);
    servo1.write(angle);
    delay(100);
  }
}

Eenvoudige bediening via potmeters of knoppen

Potmeters of knoppen zijn een mooie manier om de robotarm eenvoudig en nauwkeurig te bedienen:

Knoppen

Elke knop activeert een afzonderlijke actie:

• Servo naar links/rechts bewegen
• Grijper openen/sluiten
• Positie opslaan/oproepen
• Automatische routine starten

Potmeters

Een potentiometer levert een analoge waarde die proportioneel wordt omgerekend naar een servohoek:

• Potentiometer links → kleine servohoek
• Potentiometer rechts → grote servohoek

Potentiometers maken een fijne handmatige besturing van elke as mogelijk.

Voor de knopbediening hebt u twee tot zes drukknoppen nodig, afhankelijk van de gewenste asbesturing, pull-down-weerstanden, kabels en een breadboard om de knoppen aan te sluiten.

Voor de potentiometers kunt u bijvoorbeeld eenvoudige draaipotentiometers gebruiken, één per servo-as. Aangezien de Raspberry Pi geen analoge ingangen kan verwerken, moet u bovendien een ADC-omzetter gebruiken om de ingangssignalen dienovereenkomstig te kunnen omzetten.

Een fragment van een code voor een eenvoudige knopbesturing zou er als volgt uit kunnen zien:

import RPi.GPIO as GPIO
import time
from adafruit_pca9685 import PCA9685
import busio, board

# PCA9685 Setup
i2c = busio.I2C(board.SCL, board.SDA)
pca = PCA9685(i2c)
pca.frequency = 50

def set_servo(channel, angle):
    pulse = int(150 + (angle / 180) * 450)
    pca.channels[channel].duty_cycle = pulse

GPIO.setmode(GPIO.BCM)

BTN_LEFT = 17
BTN_RIGHT = 27

GPIO.setup(BTN_LEFT, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(BTN_RIGHT, GPIO.IN, pull_up_down=GPIO.PUD_UP)

angle = 90

while True:
    if GPIO.input(BTN_LEFT) == 0:
        angle = max(0, angle - 5)
        set_servo(0, angle)
        time.sleep(0.1)

    if GPIO.input(BTN_RIGHT) == 0:
        angle = min(180, angle + 5)
        set_servo(0, angle)
        time.sleep(0.1)

Verschillen met de Pi-variant

• De Arduino werkt rechtstreeks met PWM-hardware: hij genereert zelf de servobesturingssignalen en reageert in realtime, wat ideaal is voor nauwkeurige bewegingen.
• De Raspberry Pi is een volwaardige computer en genereert de PWM-signalen via software of een externe module zoals de PCA9685.
• De Arduino werkt “stand-alone” zonder besturingssysteem, de code start onmiddellijk bij het inschakelen.
• De Raspberry Pi maakt complexere programma’s mogelijk via Python, AI, camerabesturing enz., maar heeft exacte timingondersteuning nodig.
• Het Motorino-shield past direct op de Arduino, terwijl de Pi meestal via I²C (PCA9685) met de servo’s wordt verbonden.

Van opbouw tot besturing: de volgende stap

Met de Grab-it-robotarmen kunnen de eerste projecten met de Raspberry Pi of de Arduino worden gerealiseerd. Bijzonder spannend daarbij is het aansturen en bedienen van de servomotoren, waaraan in dit project speciale aandacht wordt besteed. Nadat we in het eerste deel de Grab-it de eerste bewegingen hebben laten uitvoeren, presenteren we in het tweede deel van het artikel spannende projectideeën en programmeren we een webinterface voor het aansturen van de robotarm via de pc of smartphone.

Afbeeldingen: reichelt elektronik, JOY-IT, Adobe Stock

Naar het tweede deel van dit artikel:
Vorbeelden & Uitbreiding: Met de Grab-it de wereld van de robotica in – Deel 2