Arduino-robotarm: servokeuze, koppel, PCA9685 en Bluetooth
Bouw stap voor stap een Arduino-robotarm: frame van MDF of 3D-print, koppelberekening voor de MG996R, besturing met potmeters en joystick, opnemen en afspelen, PCA9685- en Bluetooth-code.
Een Arduino-robotarm is een robot ter grootte van een bureau, waarvan de servogestuurde gewrichten een voorwerp kunnen pakken, optillen, draaien en ergens anders neerzetten. Hij bestaat uit een basis, schouder, elleboog, pols en grijper en leert je in één project mechanisch ontwerp, motorkeuze, voedingsbeheer en programmeren. Nog beter: je kunt er thuis een bouwen met een Arduino Uno, een paar servo's en onderdelen van MDF of uit de 3D-printer, en zo een kleine versie van een fabrieksrobotarm op je bureau laten werken.
In deze gids behandelen we robotarmen met 4 en 6 assen van begin tot eind: een frame-materiaal kiezen, een koppelberekening om te kiezen tussen de SG90, MG90S en MG996R, een externe 5 V-voeding, besturing met potmeters en joysticks, bewegingen opnemen en afspelen, de servodriver PCA9685 met 16 kanalen, Bluetooth-besturing vanaf je telefoon en de oplossingen voor de twee meest voorkomende problemen: jitter en resets. Weet je nog niet precies hoe een servo werkt? Begin dan eerst met Wat is een servomotor?



Hoe werkt een robotarm en hoeveel assen heb je nodig?
Zie een robotarm als een menselijke arm. Elk gewricht heeft een servomotor en de Arduino zegt tegen elke servo: "ga naar deze hoek". Dankzij de potmeter in de servo weet die waar zijn as staat en houdt hij die hoek zelfs onder belasting vast. Door de gewrichtshoeken samen te veranderen, breng je de grijper naar het punt dat je wilt. Het aantal onafhankelijke bewegingen dat een arm kan maken heet het aantal vrijheidsgraden (DOF), of kortweg het aantal assen.
| Gewricht | Beweging | Belasting | Aanbevolen servo |
|---|---|---|---|
| Basis (middel) | Zwenkt de arm naar links en rechts | Tilt niets, maar draagt de hele arm | MG996R + lager |
| Schouder | Tilt de arm naar voren en naar achteren | Het zwaarst belaste gewricht | MG996R of een servo uit de klasse van 20 kg·cm |
| Elleboog | Buigt de onderarm | Gemiddeld tot hoog | MG996R |
| Pols (kantelen) | Stelt de hoek van de grijper in | Laag | MG90S |
| Polsdraaiing | Draait de grijper om zijn as | Zeer laag | MG90S of SG90 |
| Grijper | Pakt het voorwerp vast en laat het los | Klemkracht | SG90 of MG90S |
De meeste "robotarm met 6 assen"-kits in de handel hebben 6 servo's; omdat de grijper niet als as telt, zijn het technisch gezien een arm met 5 vrijheidsgraden plus een grijper. Voor je eerste arm is een ontwerp met 4 assen (basis, schouder, elleboog, grijper) de beste start: 4 servo's, 4 potmeters en een Arduino Uno zijn genoeg, de bedrading blijft simpel en koppelproblemen komen zelden voor. Polsgewrichten helpen als je de grijper waterpas wilt houden of voorwerpen vanuit verschillende hoeken wilt pakken; zodra je 5–6 servo's gebruikt, is een PCA9685-driver bijna onmisbaar.
Onderdelenlijst
| Onderdeel | Arm met 4 assen | Arm met 6 servo's | Opmerking |
|---|---|---|---|
| Controller | Arduino Uno of Nano | Arduino Uno, Nano of ESP32 | Door de extra ingangen A6 en A7 van de Nano kun je meer potmeters gebruiken |
| Servomotoren | 4× SG90 of MG90S | 3× MG996R + 3× MG90S | Controleer je keuze met de koppelberekening hieronder |
| Servodriver | Niet nodig | PCA9685-module met 16 kanalen | Slechts 2 signaaldraden via I2C |
| Voeding | 5 V 3 A-adapter | 5–6 V-adapter, minimaal 5 A | Servo's voed je nooit via de Arduino |
| Condensator | 470–1000 µF, 16 V | 1000–2200 µF, 16 V | Op de voedingsrail van de servo's, let op de polariteit |
| Bediening | 4× potmeter van 10 kΩ | 2× joystickmodule of een HC-05 | Je kunt ook beide gebruiken |
| Knoppen | 2 (opnemen, afspelen) | De joystickknoppen zijn genoeg | Geen extra weerstanden nodig met INPUT_PULLUP |
| Mechaniek | 3 mm MDF of 3D-geprinte onderdelen | 4 mm MDF, 3D-printen of aluminium beugels | 608-lager, M3-bouten en borgmoeren |
Mechanisch ontwerp: MDF of 3D-printen?
| Materiaal | Voordelen | Nadelen | Het beste voor |
|---|---|---|---|
| 3–4 mm MDF (lasergesneden) | Goedkoop, licht, makkelijk te schroeven en te lijmen | Gevoelig voor vocht, schroefgaten worden na verloop van tijd groter | Eerste armen in MeArm-stijl, schoolprojecten |
| 3 mm acryl | Ziet er mooi uit, geen last van vocht | Broos; kan barsten als je schroeven aandraait | Display- en showmodellen |
| 3D-printen (PLA / PETG) | Complexe onderdelen, servo-uitsparingen op exacte maat | Lange printtijden; PLA kruipt bij warmte en onder constante belasting | Eigen ontwerpen; PETG voor dragende onderdelen |
| Kit met aluminium beugels | Zeer stijf, kant-en-klare onderdelen voor de MG996R | Zwaar en duur, belast de schouder extra | Armen met 6 servo's die zwaardere voorwerpen moeten tillen |
| Karton, ijslollystokjes | Bijna gratis, snel prototypes maken | Slap, gewrichten krijgen speling | Afmetingen testen, eerste bouwsels met kinderen |
- Houd de arm kort en licht: De belasting op de schouder groeit recht evenredig met de afstand. Een arm van 24 cm in plaats van 30 cm verlaagt het schoudermoment met ongeveer een vijfde.
- Plaats de zware servo's dicht bij de basis: De elleboogservo naar beneden verplaatsen naar de schouder en de elleboog aandrijven met een duwstang (parallelle koppeling) is een slimme truc die armen als de MeArm gebruiken; de schouder hoeft die servo dan niet meer te tillen.
- Gebruik een lager in de basis: Laat niet het hele gewicht van de arm aan de as van de basisservo hangen. Een 608-lager (boring 8 mm, buitendiameter 22 mm, dikte 7 mm; het klassieke skateboardlager) of een draaikranslager draagt de belasting en de servo draait het alleen rond.
- Ondersteun gewrichten aan beide kanten: Terwijl de servo het gewricht aan de kant van de servohoorn vasthoudt, voeg je aan de tegenovergestelde kant een draaipunt toe met een M3-bout en een borgmoer. Zo krijgt de servoas geen buigbelasting en gaan de tandwielen veel langer mee.
- Gebruik metalen servohoorns: Monteer op elke MG996R een ronde metalen servohoorn met 25 tanden (25T) en zet hem vast op de as met de middelste schroef. Kunststof servohoorns slippen en slijten hun vertanding bij zwaar belaste gewrichten.
- Voeg rubber toe aan de grijpvingers: Een dun strookje rubber op de vingertoppen laat de grijper voorwerpen vasthouden zonder te slippen en met minder klemkracht.
Servo's kiezen: SG90, MG90S of MG996R?
| Model | Koppel | Snelheid (per 60°) | Gewicht | Tandwielen | Blokkeerstroom | Rol in een robotarm |
|---|---|---|---|---|---|---|
| SG90 | 1,8 kg·cm (4,8 V) | 0,10 s (4,8 V) | 9 g | Kunststof | Ongeveer 0,6–0,75 A | Grijper, lichte pols, kleine arm met 4 assen |
| MG90S | 1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V) | 0,10 s (4,8 V) | 13,4 g | Metal | Ongeveer 0,7–1 A | Pols, polsdraaiing, grijper |
| MG996R | 9,4 kg·cm (4,8 V), 11 kg·cm (6 V) | 0,17 s (4,8 V) | 55 g | Metal | 2,5 A (6 V) | Basis, schouder, elleboog |
| DS3218 | 19 kg·cm (5 V), 21,5 kg·cm (6,8 V) | 0,16 s (5 V) | 60 g | Metal | Ongeveer 2–3 A | Schouder van lange of zware armen |
Het koppel in de tabel is het blokkeerkoppel: de maximale kracht die de servo kan leveren voordat zijn as stilvalt, geen waarde waarmee hij continu kan werken. Als een servo die grens nadert, stijgt zijn stroom richting de blokkeerstroom, hij wordt warm en gaat jitteren. De praktische regel is dat het koppel dat een gewricht nodig heeft niet meer dan de helft van het blokkeerkoppel van de servo mag zijn. Ook de spanning telt: de MG996R levert 9,4 kg·cm bij 4,8 V en 11 kg·cm bij 6 V, dus dezelfde servo wordt door de voedingsspanning alleen al ongeveer 17% sterker. Daarom is een voeding van 6 V zinvol voor MG996R-armen, maar 6 V is de bovengrens voor de SG90 en MG90S. Voor bedrading en limieten van de MG996R, zie ook de gids MG996R-servomotor.

Koppelberekening: kan de schouderservo deze arm tillen?
Het koppel dat een servo moet leveren is de som van de massa van elk onderdeel vermenigvuldigd met zijn horizontale afstand tot de gewrichtsas: koppel (kg·cm) = Σ massa (kg) × afstand (cm). Het ongunstigste geval is wanneer de arm horizontaal gestrekt is, omdat elke afstand dan maximaal is; als de arm recht omhoog wijst, zakt die hefboomarm bijna naar nul. Om om te rekenen naar newtonmeter vermenigvuldig je met 0,098 (1 kg·cm ≈ 0,098 N·m). Als voorbeeld berekenen we de schouderbelasting van een bureauarm met 12 cm van schouder tot elleboog, 12 cm van elleboog tot pols, 6 cm van de pols tot de punt van de grijper en een MG996R bij de elleboog, waarbij de grijper een voorwerp van 50 g vasthoudt:
| Onderdeel | Massa | Afstand tot schouderas | Koppel |
|---|---|---|---|
| Onderdelen bovenarm (MDF en bouten) | 40 g | 6 cm (zwaartepunt) | 0,04 × 6 = 0,24 kg·cm |
| Elleboogservo (MG996R) | 55 g | 12 cm | 0,055 × 12 = 0,66 kg·cm |
| Onderdelen onderarm | 30 g | 18 cm | 0,03 × 18 = 0,54 kg·cm |
| Polsservo + grijper (MG90S, SG90 en onderdelen) | 50 g | 25 cm | 0,05 × 25 = 1,25 kg·cm |
| Vastgehouden voorwerp | 50 g | 30 cm | 0,05 × 30 = 1,50 kg·cm |
| Totaal | 225 g | — | 4,19 kg·cm (≈ 0,41 N·m) |
Stilstaand heeft deze arm 4,19 kg·cm nodig bij de schouder. Om de extra belasting door versnellen en afremmen op te vangen en de servo ver van de blokkering te houden, vermenigvuldig je met 2: 8,4 kg·cm. De schouder heeft dus minimaal een MG996R nodig (9,4 kg·cm bij 4,8 V, 11 kg·cm bij 6 V); de 1,8–2,2 kg·cm van een SG90 of MG90S krijgt deze arm niet eens in beweging. Doe je hetzelfde voor de elleboog, dan komen de onderarm (0,03 × 6), pols en grijper (0,05 × 13) en het voorwerp (0,05 × 18) samen op 1,73 kg·cm, oftewel 3,5 kg·cm met de veiligheidsmarge, dus ook de elleboog heeft een MG996R nodig. Bij de pols blijven alleen de grijper en het voorwerp over, dus de belasting is ongeveer 0,4 kg·cm en een MG90S is ruim voldoende. Dezelfde berekening vertelt je ook het zwaarste voorwerp dat de arm kan dragen: verhoog de massa van het voorwerp, bereken het totaal opnieuw en blijf onder de helft van het koppel van de servo.
Voeding: waarom voed je servo's niet via de Arduino?
De meeste problemen met robotarmen komen door de voeding. Een MG996R trekt 0,5–0,9 A tijdens het bewegen en tot 2,5 A wanneer hij geblokkeerd is; zelfs een kleine SG90 kan bij blokkering meer dan 0,6 A halen. Als een Arduino Uno op USB draait, is de totale stroom die beschikbaar is op zijn 5V-pin ongeveer 500 mA, de USB-limiet, en het board zelf gebruikt daar een deel van. Als drie grote servo's tegelijk beginnen te bewegen, zakt de spanning in, reset de microcontroller en springt de arm terug naar zijn beginpose. De oplossing is de servo's te voeden uit een aparte 5–6 V-bron en alle massa's met elkaar te verbinden; de Arduino kun je blijven voeden via USB of met een eigen adapter. Voor voedingsopties zie de gids Arduino-voeding, en om in te schatten hoe lang een arm op batterijen werkt, probeer je de batterijduurcalculator.
| Type arm | Geschatte stroom | Aanbevolen voeding |
|---|---|---|
| Kleine arm met 4× SG90 of MG90S | 0,5–1 A tijdens het bewegen, 2–3 A piek | 5 V 3 A-adapter of een LM2596-module (max. 3 A, ongeveer 2 A zonder koelplaat) |
| Arm met 6 servo's: 3× MG996R + 3× MG90S | 2–3 A tijdens het bewegen, 8–10 A als alles blokkeert | 5–6 V-schakelende adapter, minimaal 5 A (10 A voor ruime marge) |
| Draagbare arm | Hangt af van de arm | 2S-LiPo (7,4 V) + een step-down-module van 5 A of meer (UBEC) ingesteld op 6 V |
| Voedingen die je moet vermijden | — | 9 V-blokbatterij (kan de stroom niet leveren), de 5V-pin van de Arduino, 4× AA-alkalinebatterijen bij een arm met MG996R |
De arm met 4 assen bedraden
De tabel hieronder toont de bedrading van Arduino Uno en Raspberry Pi Pico voor de arm met 4 assen en potmeterbesturing; de code in deze gids gebruikt deze pins. Op de Uno kan de Servo-bibliotheek een servo aansturen vanaf elke digitale pin, maar omdat die Timer1 gebruikt, werkt analogWrite niet meer op pin 9 en 10 zolang er servo's zijn aangesloten. Je kunt de pinindeling van je board bekijken in de tool Pinout.
| Aansluiting | Arduino Uno | Raspberry Pi Pico |
|---|---|---|
| Signaal basisservo (oranje draad) | D3 | GP10 |
| Signaal schouderservo | D5 | GP11 |
| Signaal elleboogservo | D6 | GP12 |
| Signaal grijperservo | D9 | GP13 |
| Loper potmeter 1–3 (basis, schouder, elleboog) | A0, A1, A2 | GP26, GP27, GP28 |
| Loper potmeter 4 (grijper) | A3 | Geen; de grijper gebruikt de knop op GP14 |
| Buitenste pootjes van de potmeters | 5V en GND | 3V3 en GND |
| Knoppen voor opnemen en afspelen (andere kant naar GND) | D7 en D8 | — |
| Rode servodraad (+) | Plus van externe 5–6 V | Plus van externe 5–6 V |
| Bruine servodraad (−) | Min van externe voeding + GND van Arduino | Min van externe voeding + GND van Pico |

Kalibreer vóór de montage: centreer de servo's
- Upload de onderstaande code voordat je de servohoorns monteert; alle vier de servo's bewegen na elkaar naar 90 graden en blijven daar staan.
- Houd de arm in een neutrale pose (bijvoorbeeld bovenarm verticaal, onderarm horizontaal, grijper half open), monteer elke servohoorn op de vertandingstand die het dichtst bij die pose ligt en zet hem vast met de middelste schroef.
- Zet CENTER_ONLY in de code op false, kies een gewricht met TEST en draai langzaam aan de potmeter op A0.
- Bekijk de hoek in de Serial Monitor en noteer de kleinste en grootste hoek die het gewricht kan bereiken zonder ergens tegenaan te lopen of de kabels te spannen.
- Stel de gesloten hoek van de grijper in op het punt waar de vingers elkaar net raken; een servo die steeds harder probeert te knijpen, blijft geblokkeerd en wordt warm.
- Vul de waarden die je hebt gevonden in bij de arrays MIN_A en MAX_A van de volgende sketches.
1#include <Servo.h>
2
3const byte SERVO_PIN[4] = {3, 5, 6, 9}; // taban, omuz, dirsek, kıskaç / base, shoulder, elbow, gripper
4const byte TEST = 1; // denenecek servo (0–3) / servo under test (0–3)
5const bool CENTER_ONLY = true; // true: hepsi 90°'de bekler / true: all wait at 90°
6
7Servo servo[4];
8
9void setup() {
10 Serial.begin(9600);
11 for (byte i = 0; i < 4; i++) {
12 servo[i].write(90); // önce açıyı ver / set the angle first
13 servo[i].attach(SERVO_PIN[i]); // sonra bağla: zıplamaz / then attach: no jump
14 delay(300); // akım darbelerini ayır / spread the current surges
15 }
16}
17
18void loop() {
19 if (CENTER_ONLY) return; // korna takarken burada kal / stay here while fitting horns
20 int angle = map(analogRead(A0), 0, 1023, 0, 180); // A0'daki pot / pot on A0
21 servo[TEST].write(angle);
22 Serial.print(F("Servo "));
23 Serial.print(TEST);
24 Serial.print(F(" aci / angle: "));
25 Serial.println(angle); // sınırları buradan oku / read the limits here
26 delay(50);
27}Er zit een klein maar belangrijk detail in deze code: omdat servo.write(90) vóór attach() wordt aangeroepen, krijgt de servo de gevraagde hoek al met zijn allereerste puls. Draai je de volgorde om, dan stuurt de bibliotheek eerst zijn standaardpuls van 1500 µs (ongeveer 90°); als je starthoek niet 90 is, springt de arm bij het opstarten eerst naar het midden en dan naar het doel. De servo's één voor één starten met 300 ms ertussen spreidt bovendien de stroompiek bij het opstarten.
De robotarm besturen met potmeters
De meest intuïtieve besturing is één potmeter per gewricht: onder welke hoek de as van de potmeter ook staat, het gewricht gaat naar dezelfde hoek, dus je doet positiebesturing. Monteer je de potmeters in een kleine schaalmodel van de arm (karton of 3D-geprint, dezelfde verhoudingen), dan kopieert de grote arm de beweging van het model één op één als je dat met de hand beweegt. Analoge metingen schommelen echter vanzelf een paar stappen en die schommeling zie je terug als servojitter; de code heeft twee maatregelen daartegen.
1#include <Servo.h>
2
3const byte SERVO_PIN[4] = {3, 5, 6, 9}; // taban, omuz, dirsek, kıskaç / base, shoulder, elbow, gripper
4const byte POT_PIN[4] = {A0, A1, A2, A3}; // her eklem için bir pot / one pot per joint
5const byte MIN_A[4] = {0, 15, 20, 40}; // kalibrasyonda bulduğun alt sınırlar / lower limits from calibration
6const byte MAX_A[4] = {180, 165, 160, 110}; // üst sınırlar / upper limits
7
8Servo servo[4];
9float smooth[4]; // süzülmüş pot değeri / filtered pot value
10int lastAngle[4]; // son yazılan açı / last written angle
11
12void setup() {
13 for (byte i = 0; i < 4; i++) {
14 smooth[i] = analogRead(POT_PIN[i]);
15 lastAngle[i] = map((int)smooth[i], 0, 1023, MIN_A[i], MAX_A[i]);
16 servo[i].write(lastAngle[i]); // önce açı, sonra attach / angle first, then attach
17 servo[i].attach(SERVO_PIN[i]);
18 delay(300); // servolar sırayla uyansın / wake the servos one by one
19 }
20}
21
22void loop() {
23 for (byte i = 0; i < 4; i++) {
24 smooth[i] += (analogRead(POT_PIN[i]) - smooth[i]) * 0.2; // yumuşatma filtresi / low-pass filter
25 int angle = map((int)smooth[i], 0, 1023, MIN_A[i], MAX_A[i]);
26 if (abs(angle - lastAngle[i]) >= 2) { // ölü bant: küçük gürültüyü yok say / deadband: ignore small noise
27 servo[i].write(angle);
28 lastAngle[i] = angle;
29 }
30 }
31 delay(15);
32}De array smooth is een eenvoudig laagdoorlaatfilter: elke lus telt maar 20% van de nieuwe meting mee, zodat plotselinge sprongen worden afgevlakt terwijl de arm toch snel reageert. Verander 0.2 in 0.1 en de beweging wordt vloeiender maar trager. De tweede maatregel is een dode zone: tenzij de nieuwe hoek minstens 2 graden verschilt van de laatst geschreven hoek, wordt er niets naar de servo gestuurd, waardoor de jitter stopt zolang de arm stilstaat. Omdat map() het bereik van de potmeter direct omzet naar de veilige grenzen van elk gewricht, loopt het gewricht nooit tegen zijn mechanische aanslag aan, ook niet als de potmeter helemaal is doorgedraaid.
Bewegingen opnemen en afspelen
Wat een robotarm echt een robot maakt, is dat hij zelfstandig een beweging herhaalt die je hem hebt voorgedaan. De methode is simpel: je beweegt de arm met de potmeters naar een pose en drukt op de opneemknop, en de Arduino bewaart de hoeken van alle vier de gewrichten. Na het opnemen van een paar poses druk je op afspelen en de arm herhaalt ze op volgorde, met vloeiende overgangen ertussen. De poses worden weggeschreven naar het EEPROM van 1024 bytes van de Arduino Uno, zodat ze een stroomonderbreking overleven; elke pose neemt 4 bytes in, dus een opname van 100 poses gebruikt maar 401 bytes.
1#include <Servo.h>
2#include <EEPROM.h>
3
4const byte SERVO_PIN[4] = {3, 5, 6, 9}; // taban, omuz, dirsek, kıskaç / base, shoulder, elbow, gripper
5const byte POT_PIN[4] = {A0, A1, A2, A3};
6const byte MIN_A[4] = {0, 15, 20, 40}; // güvenli sınırlar / safe limits
7const byte MAX_A[4] = {180, 165, 160, 110};
8const byte BTN_REC = 7, BTN_PLAY = 8, LED = 13; // butonların diğer ucu GND'de / buttons go to GND
9const byte MAX_STEPS = 100; // 100 adım x 4 bayt = 400 bayt / 100 steps x 4 bytes
10
11Servo servo[4];
12float smooth[4]; // süzülmüş pot değeri / filtered pot value
13byte pos[4]; // servoların şu anki açısı / current servo angles
14byte stepCount; // kayıtlı adım sayısı / number of saved steps
15
16bool pressed(byte pin) { // basılıyken true / true while pressed
17 return digitalRead(pin) == LOW;
18}
19
20byte potAngle(byte i) {
21 smooth[i] += (analogRead(POT_PIN[i]) - smooth[i]) * 0.2; // yumuşatma / smoothing
22 return map((int)smooth[i], 0, 1023, MIN_A[i], MAX_A[i]);
23}
24
25void blink(byte n) {
26 for (byte k = 0; k < n; k++) {
27 digitalWrite(LED, HIGH); delay(80);
28 digitalWrite(LED, LOW); delay(80);
29 }
30}
31
32// Tüm eklemleri aynı anda hedefe götürür / moves all joints to the target together
33void moveTo(const byte target[4], byte msPerDegree) {
34 byte start[4];
35 int steps = 0;
36 for (byte i = 0; i < 4; i++) {
37 start[i] = pos[i];
38 int d = abs((int)target[i] - (int)start[i]);
39 if (d > steps) steps = d; // en uzun hareket / longest move
40 }
41 for (int s = 1; s <= steps; s++) {
42 for (byte i = 0; i < 4; i++) {
43 pos[i] = start[i] + (long)((int)target[i] - (int)start[i]) * s / steps; // ara açı / in-between angle
44 servo[i].write(pos[i]);
45 }
46 delay(msPerDegree);
47 }
48}
49
50void saveStep() {
51 if (stepCount >= MAX_STEPS) { blink(3); return; } // hafıza dolu / memory full
52 for (byte i = 0; i < 4; i++) EEPROM.update(1 + stepCount * 4 + i, pos[i]);
53 stepCount++;
54 EEPROM.update(0, stepCount); // 0. bayt adım sayısını tutar / byte 0 holds the step count
55 blink(1);
56}
57
58void playBack() {
59 byte target[4];
60 for (byte s = 0; s < stepCount; s++) {
61 for (byte i = 0; i < 4; i++) target[i] = EEPROM.read(1 + s * 4 + i);
62 moveTo(target, 12); // derece başına 12 ms / 12 ms per degree
63 delay(400); // her pozda kısa bekleme / short pause at each pose
64 if (pressed(BTN_PLAY)) break; // oynatırken basınca durur / press again to stop
65 }
66}
67
68void syncToPots() { // potların konumuna yumuşakça dön / ease back to the pots
69 byte target[4];
70 for (byte i = 0; i < 4; i++) {
71 smooth[i] = analogRead(POT_PIN[i]);
72 target[i] = map((int)smooth[i], 0, 1023, MIN_A[i], MAX_A[i]);
73 }
74 moveTo(target, 12);
75}
76
77void setup() {
78 pinMode(BTN_REC, INPUT_PULLUP);
79 pinMode(BTN_PLAY, INPUT_PULLUP);
80 pinMode(LED, OUTPUT);
81 stepCount = EEPROM.read(0);
82 if (stepCount > MAX_STEPS) stepCount = 0; // boş EEPROM 255 okur / a blank EEPROM reads 255
83 for (byte i = 0; i < 4; i++) {
84 smooth[i] = analogRead(POT_PIN[i]);
85 pos[i] = potAngle(i);
86 servo[i].write(pos[i]); // önce açı, sonra attach / angle first, then attach
87 servo[i].attach(SERVO_PIN[i]);
88 delay(300);
89 }
90}
91
92void loop() {
93 // Kayıt: kısa bas = pozu kaydet, 2 sn basılı tut = hepsini sil / Record: short press = save pose, hold 2 s = erase all
94 if (pressed(BTN_REC)) {
95 unsigned long t0 = millis();
96 while (pressed(BTN_REC) && millis() - t0 < 2000) {}
97 if (millis() - t0 >= 2000) {
98 stepCount = 0;
99 EEPROM.update(0, 0);
100 blink(5);
101 } else {
102 saveStep();
103 }
104 while (pressed(BTN_REC)) {} // bırakılmasını bekle / wait for release
105 delay(50); // buton arkı / debounce
106 }
107
108 // Oynat: kaydedilen pozları sırayla tekrarla / play: repeat the saved poses in order
109 if (pressed(BTN_PLAY) && stepCount > 0) {
110 while (pressed(BTN_PLAY)) {}
111 delay(50);
112 digitalWrite(LED, HIGH);
113 playBack();
114 while (pressed(BTN_PLAY)) {}
115 syncToPots();
116 digitalWrite(LED, LOW);
117 }
118
119 // Normal mod: kolu potlarla sür / normal mode: drive the arm with the pots
120 for (byte i = 0; i < 4; i++) {
121 byte a = potAngle(i);
122 if (abs((int)a - (int)pos[i]) >= 2) {
123 pos[i] = a;
124 servo[i].write(a);
125 }
126 }
127 delay(15);
128}| Actie | Wat jij doet | Wat de arm doet |
|---|---|---|
| Een pose opslaan | Kort drukken op de opneemknop (D7) | De led knippert één keer, de pose wordt naar het EEPROM geschreven |
| Opnames wissen | Houd de opneemknop 2 seconden ingedrukt | De led knippert vijf keer, het aantal stappen wordt teruggezet |
| Afspelen | Druk op de afspeelknop en laat los (D8) | De led gaat branden, de poses worden op volgorde afgespeeld met vloeiende overgangen |
| Afspelen stoppen | Houd de afspeelknop ingedrukt tijdens het afspelen | De arm maakt de huidige pose af en stopt |
| Terug naar de normale modus | Doe niets zodra het afspelen klaar is | De arm keert langzaam terug naar de stand waar de potmeters naar wijzen, de led gaat uit |
De functie moveTo() is het hart van de sketch: ze zoekt het gewricht met de langste weg te gaan, verdeelt de beweging in zoveel stappen en laat bij elke stap alle gewrichten evenredig opschuiven. Zo komt elk gewricht tegelijk bij het doel aan en beweegt de arm vloeiend, in plaats van als een robot die één gewricht tegelijk schokkerig verplaatst. Bij 12 ms per graad duurt een beweging van 90 graden ongeveer 1,1 seconden. Je kunt deze waarde verlagen voor sneller afspelen, maar een onbelaste MG996R draait al 60 graden in 0,17 seconde, ongeveer 3 ms per graad; ga je daaronder, dan kunnen de servo's de opdrachten niet bijhouden en wordt de beweging schokkerig.
PCA9685-servodriver: 6 servo's en een jitterloos signaal
Zodra je overstapt op 5–6 servo's of extra modules zoals Bluetooth toevoegt, maakt een PCA9685-module het leven veel makkelijker. Dit board is een PWM-generator met 16 kanalen en 12 bits; het praat met de Arduino via maar twee draden met I2C en maakt de servopulsen met zijn eigen klok, onafhankelijk van de processor. Het standaardadres is 0x40; door het adres te wijzigen met de soldeerbruggen A0–A5 kun je tot 62 boards koppelen, oftewel 992 servo's. Bij 50 Hz wordt de periode van 20 ms verdeeld in 4096 stappen, dus één stap is ongeveer 4,9 µs; het bereik van 544–2400 µs beslaat ongeveer 380 stappen, wat een resolutie van ruwweg een halve graad betekent.
| PCA9685-pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND | GND | GND | GND |
| VCC (alleen chipvoeding) | 5V | 3V3 | 3V3 |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| V+-klem (servovoeding) | Externe 5–6 V | Externe 5–6 V | Externe 5–6 V |
| OE | Niet aansluiten | Niet aansluiten | Niet aansluiten |
| Servo-aansluitingen 0–5 | Basis, schouder, elleboog, pols, polsdraaiing, grijper | Zelfde volgorde | Zelfde volgorde |
De robotarm besturen met joysticks
Een joystick werkt anders dan een potmeter: hij veert terug naar het midden als je hem loslaat. Koppel je de hoek rechtstreeks aan de joystickstand, dan springt het gewricht naar 90 graden zodra je loslaat. De juiste aanpak is snelheidsbesturing: hoe verder je de joystick duwt, hoe sneller het gewricht draait, en als je loslaat, blijft het gewricht staan waar het is. In de onderstaande code sturen twee joysticks vier gewrichten aan (linkerjoystick voor basis en schouder, rechterjoystick voor elleboog en pols); de knop van de linkerjoystick opent en sluit de grijper en die van de rechter stuurt de arm naar zijn thuispose. Sluit de uitgangen VRx en VRy van de linkerjoystick aan op A0 en A1, de uitgangen VRy en VRx van de rechterjoystick op A2 en A3 en de SW-pins op D2 en D4; de joysticks kunnen worden gevoed vanaf de 5V-pin van de Arduino. Installeer om de code te compileren Adafruit PWM Servo Driver Library via de Library Manager en accepteer de afhankelijkheid Adafruit BusIO.

1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40); // varsayılan adres / default address
5
6// Kanal: 0 taban, 1 omuz, 2 dirsek, 3 bilek, 4 bilek dönüşü, 5 kıskaç / Channel: 0 base, 1 shoulder, 2 elbow, 3 wrist, 4 wrist roll, 5 gripper
7const byte N = 6;
8const float MIN_A[N] = {0, 15, 20, 10, 0, 40}; // güvenli sınırlar / safe limits
9const float MAX_A[N] = {180, 165, 160, 170, 180, 110};
10const float HOME[N] = {90, 90, 90, 90, 90, 40}; // başlangıç pozu, kıskaç açık / home pose, gripper open
11const byte JOY[4] = {A0, A1, A2, A3}; // J1 X, J1 Y, J2 Y, J2 X → kanal / channel 0, 1, 2, 3
12const int8_t DIR[4] = {1, -1, 1, 1}; // ters giden ekseni -1 yap / set -1 to invert an axis
13const byte BTN_GRIP = 2, BTN_HOME = 4; // joystick SW pinleri / joystick SW pins
14const float MAX_SPEED = 90; // en yüksek hız, derece/sn / top speed, degrees/s
15const float DT = 0.02; // 20 ms döngü / 20 ms loop
16const int DEADZONE = 60; // ortadaki ölü bölge / dead zone around center
17
18float target[N], current[N];
19bool gripClosed = false;
20
21void writeServo(byte ch, float a) {
22 // Servo.h ile aynı 544–2400 µs aralığı / same 544–2400 µs range as Servo.h
23 pca.writeMicroseconds(ch, (uint16_t)(544 + a * (2400 - 544) / 180.0));
24}
25
26bool newPress(byte pin, byte k) { // her basışta bir kez true / true once per press
27 static bool prev[2] = {HIGH, HIGH};
28 bool now = digitalRead(pin);
29 bool edge = (prev[k] == HIGH && now == LOW);
30 prev[k] = now;
31 return edge;
32}
33
34void setup() {
35 pinMode(BTN_GRIP, INPUT_PULLUP);
36 pinMode(BTN_HOME, INPUT_PULLUP);
37 pca.begin();
38 pca.setOscillatorFrequency(27000000); // çoğu modülde ~27 MHz / ~27 MHz on most boards
39 pca.setPWMFreq(50); // servolar için 50 Hz / 50 Hz for servos
40 Wire.setClock(400000); // hızlı I2C / fast I2C
41 for (byte i = 0; i < N; i++) {
42 target[i] = current[i] = HOME[i];
43 writeServo(i, HOME[i]);
44 delay(300); // servolar sırayla uyansın / wake servos one by one
45 }
46}
47
48void loop() {
49 static unsigned long last = 0;
50 if (millis() - last < 20) return; // 50 Hz güncelleme / 50 Hz update
51 last = millis();
52
53 // Joystick hızı belirler, konumu değil / the joystick sets speed, not position
54 for (byte i = 0; i < 4; i++) {
55 int v = analogRead(JOY[i]) - 512;
56 if (abs(v) > DEADZONE) {
57 target[i] += DIR[i] * (v / 512.0) * MAX_SPEED * DT;
58 target[i] = constrain(target[i], MIN_A[i], MAX_A[i]);
59 }
60 }
61 if (newPress(BTN_GRIP, 0)) { // kıskaç aç/kapa / toggle gripper
62 gripClosed = !gripClosed;
63 target[5] = gripClosed ? MAX_A[5] : MIN_A[5];
64 }
65 if (newPress(BTN_HOME, 1)) { // başlangıç pozuna dön / go to home pose
66 for (byte i = 0; i < N; i++) target[i] = HOME[i];
67 gripClosed = false;
68 }
69
70 // Her eklem hedefe hız sınırıyla gider / each joint follows its target with a speed limit
71 for (byte i = 0; i < N; i++) {
72 float d = constrain(target[i] - current[i], -MAX_SPEED * DT, MAX_SPEED * DT);
73 if (d != 0) {
74 current[i] += d;
75 writeServo(i, current[i]);
76 }
77 }
78}DEADZONE voorkomt dat kleine afwijkingen, zoals 490–530 gemeten in het midden, de arm uit zichzelf laten kruipen. MAX_SPEED stelt de snelheid in, in graden per seconde, als de joystick helemaal wordt ingedrukt; 90 graden per seconde is een veilige beginwaarde. Beweegt een gewricht tegengesteld aan de joystick, wissel dan geen draden om, maar zet de bijbehorende waarde in de array DIR op -1. De code houdt voor elk gewricht een doel (target) en een werkelijke positie (current) bij; omdat de werkelijke positie het doel met een snelheidslimiet benadert, glijdt de arm soepel terug, ook als je op de thuisknop drukt. De polsdraaiing blijft in deze sketch vast op 90 graden; je kunt hem bedienen met het commando R in het Bluetooth-gedeelte. Deze niet-blokkerende timingtechniek wordt uitgebreid uitgelegd in millis() versus delay().
Bluetooth-besturing vanaf je telefoon (HC-05)
De HC-05-module maakt een draadloze seriële verbinding tussen je telefoon en de Arduino. De TXD-pin gaat naar D10 van de Arduino en de RXD-pin gaat via een spanningsdeler naar D11: D11 → 1 kΩ → RXD → 2 kΩ → GND. De deler brengt het 5 V-signaal van de Arduino omlaag naar de ongeveer 3,3 V die de HC-05 verwacht. De standaard datasnelheid van de module is 9600 baud en de koppelcode (PIN) is meestal 1234. De telefoon stuurt eenvoudige tekstcommando's: een letter kiest het gewricht, het getal erna geeft de hoek en een nieuwe regel of puntkomma sluit het commando af.

| Commando | Betekenis | Voorbeeld |
|---|---|---|
| B + hoek | Basis | B90 |
| S + hoek | Schouder | S120 |
| E + hoek | Elleboog | E45 |
| W + hoek | Pols (kantelen) | W100 |
| R + hoek | Polsdraaiing | R0 |
| G + hoek | Grijper | G110 (dicht), G40 (open) |
| H | Terug naar thuispose | H |
| K / P / X / C | Pose opslaan / in een lus afspelen / stoppen / poses wissen | K |
1#include <Wire.h>
2#include <SoftwareSerial.h>
3#include <Adafruit_PWMServoDriver.h>
4
5SoftwareSerial bt(10, 11); // D10 ← HC-05 TXD, D11 → bölücü / divider → HC-05 RXD
6Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40);
7
8const byte N = 6;
9const char NAME[N] = {'B', 'S', 'E', 'W', 'R', 'G'}; // taban, omuz, dirsek, bilek, dönüş, kıskaç / base, shoulder, elbow, wrist, roll, gripper
10const byte MIN_A[N] = {0, 15, 20, 10, 0, 40}; // güvenli sınırlar / safe limits
11const byte MAX_A[N] = {180, 165, 160, 170, 180, 110};
12const byte HOME[N] = {90, 90, 90, 90, 90, 40};
13const byte MAX_POSES = 30;
14const float SPEED = 1.5; // 20 ms'de en fazla 1,5° (75°/sn) / max 1.5° per 20 ms (75°/s)
15
16float current[N];
17byte target[N];
18byte poses[MAX_POSES][N]; // kaydedilen pozlar (RAM) / recorded poses (RAM)
19byte poseCount = 0, playIndex = 0;
20bool playing = false;
21char buf[12];
22byte len = 0;
23
24void writeServo(byte ch, float a) {
25 pca.writeMicroseconds(ch, (uint16_t)(544 + a * (2400 - 544) / 180.0)); // 544–2400 µs
26}
27
28void handle(char *cmd) { // ör. / e.g. "S120", "H", "K", "P"
29 char c = toupper(cmd[0]);
30 if (c == 'H') { // başlangıç pozu / home pose
31 for (byte i = 0; i < N; i++) target[i] = HOME[i];
32 playing = false;
33 } else if (c == 'K') { // pozu kaydet / save pose
34 if (poseCount < MAX_POSES) {
35 for (byte i = 0; i < N; i++) poses[poseCount][i] = target[i];
36 poseCount++;
37 }
38 bt.print(F("Poz / pose: "));
39 bt.println(poseCount);
40 } else if (c == 'P') { // döngüyle oynat / play in a loop
41 if (poseCount > 0) { playing = true; playIndex = 0; }
42 } else if (c == 'X') { // durdur / stop
43 playing = false;
44 } else if (c == 'C') { // kayıtları sil / clear poses
45 poseCount = 0;
46 playing = false;
47 } else {
48 for (byte i = 0; i < N; i++) {
49 if (c == NAME[i]) {
50 target[i] = constrain(atoi(cmd + 1), MIN_A[i], MAX_A[i]);
51 playing = false; // elle komut oynatmayı keser / a manual command stops playback
52 }
53 }
54 }
55}
56
57bool arrived() {
58 for (byte i = 0; i < N; i++)
59 if (fabs(target[i] - current[i]) > 0.5) return false;
60 return true;
61}
62
63void setup() {
64 bt.begin(9600); // HC-05 varsayılan hızı / HC-05 default baud
65 pca.begin();
66 pca.setOscillatorFrequency(27000000);
67 pca.setPWMFreq(50);
68 for (byte i = 0; i < N; i++) {
69 target[i] = HOME[i];
70 current[i] = HOME[i];
71 writeServo(i, HOME[i]);
72 delay(300); // servolar sırayla uyansın / wake servos one by one
73 }
74}
75
76void loop() {
77 // Komutları satır satır topla / collect commands line by line
78 while (bt.available()) {
79 char ch = bt.read();
80 if (ch == '\n' || ch == '\r' || ch == ';') {
81 if (len > 0) { buf[len] = '\0'; handle(buf); len = 0; }
82 } else if (len < sizeof(buf) - 1) {
83 buf[len++] = ch;
84 }
85 }
86
87 static unsigned long last = 0, arrivedAt = 0;
88 if (millis() - last < 20) return; // 50 Hz güncelleme / 50 Hz update
89 last = millis();
90
91 if (playing) {
92 if (!arrived()) arrivedAt = millis(); // hareket sürüyor / still moving
93 else if (millis() - arrivedAt > 300) { // her pozda 300 ms bekle / hold each pose 300 ms
94 for (byte i = 0; i < N; i++) target[i] = poses[playIndex][i];
95 playIndex = (playIndex + 1) % poseCount; // sona gelince başa dön / wrap around
96 arrivedAt = millis();
97 }
98 }
99
100 for (byte i = 0; i < N; i++) {
101 float d = constrain(target[i] - current[i], -SPEED, SPEED); // hız sınırı / speed limit
102 if (d != 0) {
103 current[i] += d;
104 writeServo(i, current[i]);
105 }
106 }
107}In deze sketch zijn de servo's aangesloten op de PCA9685 in plaats van rechtstreeks op de Arduino, en dat is bewust. SoftwareSerial schakelt interrupts ongeveer 1 ms uit tijdens het ontvangen van elke byte; als de servo's met de Servo-bibliotheek vanaf Arduino-pins werden aangestuurd, zouden hun pulsen in die tijd worden uitgerekt en zou de arm bij elk commando trillen. Omdat de PCA9685 de pulsen zelf genereert, blijft het signaal rotsvast, hoe druk de Bluetooth-verbinding ook is. Ook opnemen en afspelen gebeuren nu vanaf de telefoon: beweeg de arm met de schuifregelaars naar een pose en stuur K; na een paar poses laat P de arm ze in een lus herhalen en stopt X dat. In deze versie staan de poses in RAM en gaan ze verloren als het board wordt uitgeschakeld; wil je ze bewaren, voeg dan de EEPROM-methode uit de vorige sketch toe.
Draadloze robotarm met een ESP32
Omdat de ESP32 klassiek Bluetooth ingebouwd heeft, heb je geen HC-05 nodig: met de bibliotheek BluetoothSerial verschijnt het board op je telefoon als "BlueGrays-RobotKol" en begrijpt het dezelfde commando's. Sluit de PCA9685 aan op GPIO 21 (SDA) en GPIO 22 (SCL) en voed zijn VCC vanaf 3V3; de servosignalen komen dan op 3,3 V uit, wat veruit de meeste servo's zonder problemen lezen. BluetoothSerial werkt alleen op de klassieke ESP32 (ESP32-WROOM-32, DevKit); de ESP32-S2, S3 en C3 ondersteunen geen klassiek Bluetooth.
1#include <Wire.h>
2#include <BluetoothSerial.h>
3#include <Adafruit_PWMServoDriver.h>
4
5BluetoothSerial bt; // klasik Bluetooth SPP / classic Bluetooth SPP
6Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40);
7
8const int N = 6;
9const char NAME[N] = {'B', 'S', 'E', 'W', 'R', 'G'}; // taban, omuz, dirsek, bilek, dönüş, kıskaç / base, shoulder, elbow, wrist, roll, gripper
10const int MIN_A[N] = {0, 15, 20, 10, 0, 40};
11const int MAX_A[N] = {180, 165, 160, 170, 180, 110};
12const int HOME[N] = {90, 90, 90, 90, 90, 40};
13float current[N], target[N];
14String line;
15
16void writeServo(int ch, float a) {
17 pca.writeMicroseconds(ch, (uint16_t)(544 + a * (2400 - 544) / 180.0)); // 544–2400 µs
18}
19
20void handle(String cmd) { // ör. / e.g. "E45", "H"
21 cmd.trim();
22 if (cmd.length() == 0) return;
23 char c = toupper(cmd[0]);
24 if (c == 'H') {
25 for (int i = 0; i < N; i++) target[i] = HOME[i];
26 return;
27 }
28 int value = cmd.substring(1).toInt();
29 for (int i = 0; i < N; i++)
30 if (c == NAME[i]) target[i] = constrain(value, MIN_A[i], MAX_A[i]);
31}
32
33void setup() {
34 Serial.begin(115200);
35 bt.begin("BlueGrays-RobotKol"); // telefonda görünen ad / name shown on the phone
36 Wire.begin(21, 22); // SDA = GPIO 21, SCL = GPIO 22
37 pca.begin();
38 pca.setOscillatorFrequency(27000000);
39 pca.setPWMFreq(50);
40 for (int i = 0; i < N; i++) {
41 current[i] = target[i] = HOME[i];
42 writeServo(i, HOME[i]);
43 delay(300);
44 }
45 Serial.println("Bluetooth hazir / ready");
46}
47
48void loop() {
49 while (bt.available()) {
50 char ch = bt.read();
51 if (ch == '\n' || ch == ';') { handle(line); line = ""; }
52 else if (line.length() < 12) line += ch;
53 }
54
55 static unsigned long last = 0;
56 if (millis() - last < 20) return; // 50 Hz güncelleme / 50 Hz update
57 last = millis();
58 for (int i = 0; i < N; i++) {
59 float d = constrain(target[i] - current[i], -1.5f, 1.5f); // yumuşak hareket / smooth motion
60 if (d != 0) {
61 current[i] += d;
62 writeServo(i, current[i]);
63 }
64 }
65}Robotarm met een Raspberry Pi Pico (MicroPython)
Om servo's aan te sturen op de Raspberry Pi Pico heb je geen extra bibliotheek nodig: stel de PWM in op 50 Hz en geef de pulsbreedte in nanoseconden op met duty_ns(). Met 16 PWM-kanalen kan de Pico 6 servo's rechtstreeks aansturen; pinparen die dezelfde slice delen, delen ook een frequentie, maar omdat elke servo 50 Hz gebruikt, is dat geen probleem. De beperking zit aan de analoge kant: de Pico heeft maar drie bruikbare ADC-pins (GP26, GP27, GP28). Daarom worden in de onderstaande code drie gewrichten met potmeters bestuurd en gaat de grijper open en dicht met een knop op GP14. Omdat de Pico op 3,3 V draait, sluit je de potmeters aan op 3V3; voed de servo's zoals eerder uit een externe 5 V-voeding.
1from machine import Pin, PWM, ADC
2import time
3
4# Servo pinleri: taban, omuz, dirsek, kıskaç / servo pins: base, shoulder, elbow, gripper
5servos = [PWM(Pin(p)) for p in (10, 11, 12, 13)]
6for s in servos:
7 s.freq(50) # 50 Hz servo sinyali / 50 Hz servo signal
8
9pots = [ADC(26), ADC(27), ADC(28)] # Pico'da 3 ADC pini var / the Pico has 3 ADC pins
10button = Pin(14, Pin.IN, Pin.PULL_UP) # kıskaç butonu GND'ye / gripper button to GND
11
12MIN_A = (0, 15, 20, 40) # güvenli sınırlar / safe limits
13MAX_A = (180, 165, 160, 110)
14
15def write(i, angle):
16 angle = max(MIN_A[i], min(MAX_A[i], angle))
17 servos[i].duty_ns(544000 + int(angle * 10311)) # 544–2400 µs aralığı / 544–2400 µs range
18
19smooth = [p.read_u16() for p in pots]
20grip_closed = False
21last_btn = 1
22write(3, MIN_A[3]) # kıskaç açık başlar / gripper starts open
23
24while True:
25 for i in range(3):
26 smooth[i] += (pots[i].read_u16() - smooth[i]) * 0.2 # yumuşatma / smoothing
27 write(i, MIN_A[i] + (MAX_A[i] - MIN_A[i]) * smooth[i] / 65535)
28 b = button.value()
29 if b == 0 and last_btn == 1: # yeni basış / new press
30 grip_closed = not grip_closed
31 write(3, MAX_A[3] if grip_closed else MIN_A[3])
32 last_btn = b
33 time.sleep_ms(20) # 50 Hz döngü / 50 Hz loopVerder gaan: inverse kinematica
Tot nu toe hebben we de hoek van elk gewricht één voor één ingesteld; dat heet voorwaartse kinematica. Inverse kinematica doet het omgekeerde: jij geeft het punt (x, y) op dat de grijper moet bereiken en de code berekent de benodigde gewrichtshoeken. Voor een arm met twee segmenten, met lengte L1 van schouder tot elleboog en L2 van elleboog tot pols, bereken je eerst D = (x² + y² − L1² − L2²) / (2·L1·L2). De ellebooghoek is θ2 = acos(D) en de schouderhoek is θ1 = atan2(y, x) + atan2(L2·sin θ2, L1 + L2·cos θ2) (de oplossing met elleboog omhoog). Met L1 = L2 = 12 cm en een punt 15 cm voor en 5 cm boven de schouder krijg je bijvoorbeeld D ≈ −0,13, θ2 ≈ 97,6° en θ1 ≈ 67,2°: de bovenarm wijst 67 graden boven de horizontaal en de onderarm buigt 97,6 graden naar beneden ten opzichte daarvan. Als de absolute waarde van D groter is dan 1, ligt het punt buiten het bereik van de arm. De basishoek wordt apart berekend uit de positie van het doel gezien van bovenaf. Houd bij het omzetten van de resultaten naar servohoeken rekening met de montagerichting en het middelpunt van elke servo.
Jitter en resets: veelgemaakte fouten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Servo's jitteren en zoemen terwijl de arm stilstaat | Ruis in de potmetermetingen of een zwakke voeding | Voeg een afvlakfilter en een dode zone van 2° toe, gebruik een externe voeding en een condensator van 1000 µF |
| De Arduino reset als de arm beweegt, de HC-05 verliest zijn verbinding | De aanloopstroom van de servo's trekt de spanning omlaag | Voed de servo's uit een aparte 5–6 V-voeding, verbind de massa's en start de servo's bij het opstarten één voor één |
| Servo's trillen telkens als er een Bluetooth-commando binnenkomt | Interrupts van SoftwareSerial verstoren de pulsen van de Servo-bibliotheek | Verplaats de servo's naar een PCA9685 of gebruik het ingebouwde Bluetooth van de ESP32 |
| De arm schiet bij het opstarten ergens heen | Servo's onthouden hun laatste positie niet en bewegen bij het eerste commando op volle snelheid | Zet de arm in de thuispose voordat je uitschakelt en roep write() aan vóór attach() |
| De schouder kan de arm niet tillen of zakt langzaam door | Te weinig koppel | Doe de koppelberekening; gebruik een MG996R, een kortere arm, een tegengewicht of een veer |
| Een gewricht blokkeert aan één kant en wordt heet | De servo duwt tegen een mechanische aanslag | Zet de limieten MIN_A en MAX_A uit de kalibratie in de code |
| De grijperservo wordt warm terwijl hij een voorwerp vasthoudt | De grijper blijft proberen te sluiten en de servo blijft geblokkeerd | Stel de gesloten hoek in op het punt waar hij het voorwerp net raakt, voeg rubber toe aan de vingers |
| De PCA9685 is aangesloten maar geen enkele servo beweegt | Geen spanning op de V+-klem of geen gemeenschappelijke massa | Geef V+ 5–6 V en controleer het I2C-adres (0x40) |
| Een gewricht slipt onder belasting | Een kunststof servohoorn is uitgeslepen of de middelste schroef ontbreekt | Gebruik een metalen servohoorn en zet hem met de middelste schroef vast op de as |
Projectideeën voor een robotarm
- Arm die kleuren sorteert: Lees de kleur van blokjes af met een TCS3200-kleurensensor en laat de arm elke kleur in een eigen bakje leggen.
- Gebarenbesturing: Met een MPU6050 op een handschoen kantelt de robotarm op dezelfde manier als je pols.
- Draadloze afstandsbediening: Sluit twee joysticks aan op een aparte Arduino en stuur de commando's met een nRF24L01; zo krijg je een afstandsbediening die geen telefoon nodig heeft.
- Besturing via de browser: Maak met een ESP32 schuifregelaars op een webpagina en bestuur de arm vanaf elk apparaat op hetzelfde wifinetwerk; een ESP32-WebSocket houdt de vertraging minimaal.
- Pakken van een lopende band: Bouw een kleine lopende band met een stappenmotor; zodra een TCRT5000 een voorwerp ziet, pakt de arm het van de band.
- Wedstrijd en schoolproject: Een arm die opneemt en afspeelt is een sterke keuze onder de ideeën voor wetenschapsprojecten, want hij toont mechanica, elektronica en software samen.
Een Arduino-robotarm is een project dat je tegelijk mechanisch ontwerp, koppelberekening, voedingsbeheer en het programmeren van vloeiende bewegingen leert, en het groeit mee met de moeite die je erin steekt. Begin met een arm met 4 servo's die je met potmeters bestuurt, voeg opnemen en afspelen toe en stap dan over op 6 servo's met een PCA9685 en Bluetooth. In de BlueGrays-app vind je projecten zoals servobesturing met een potmeter en een joystick, Bluetooth-besturing vanaf je telefoon en een choreografie met 32 servo's, compleet met schakelschema's en code stap voor stap, zodat je eerst elk gewricht van je arm afzonderlijk kunt uitproberen.
Veelgestelde vragen
Welke servomotor moet ik gebruiken voor een Arduino-robotarm?
Voor dragende gewrichten zoals de basis, schouder en elleboog is de MG996R met metalen tandwielen en 9–11 kg·cm koppel een goede keuze. Voor lichte gewrichten zoals de pols en grijper is een MG90S of SG90 genoeg. Kleine armen die alleen met SG90's zijn gebouwd, werken als je ze kort en licht houdt, maar ze kunnen alleen voorwerpen van een paar tientallen grammen tillen.
Welke voeding heeft een robotarm nodig?
Voor een kleine arm met 4 SG90- of MG90S-servo's is een 5 V 3 A-adapter genoeg. Gebruik voor een arm met 6 servo's, met 3 MG996R's en 3 kleine servo's, een schakelende 5–6 V-adapter van minimaal 5 A, of 10 A voor ruime marge. Vergeet niet de min van de adapter te verbinden met de GND van de Arduino.
Hoeveel servo's kan een Arduino aansturen?
De Servo-bibliotheek kan tot 12 servo's aansturen op een Arduino Uno en 48 op een Mega. De echte beperking is echter de stroom: alle servo's moeten worden gevoed uit een externe voeding. Een PCA9685-module stuurt 16 servo's aan met slechts twee I2C-pins en kan tot 62 modules worden gekoppeld.
Waarom jitteren de servo's van mijn robotarm?
De meest voorkomende oorzaken zijn een zwakke voeding, een ontbrekende gemeenschappelijke massa en ruis in de potmetermetingen. Gebruik een externe voeding met een condensator van 1000 µF op de servorail en voeg in de code een afvlakfilter en een dode zone toe. Als SoftwareSerial en de Servo-bibliotheek samen worden gebruikt, haalt het verplaatsen van de servo's naar een PCA9685 de jitter volledig weg.
Hoeveel gewicht kan een robotarm met SG90 tillen?
Het blokkeerkoppel van de SG90 is ongeveer 1,8 kg·cm; reken voor veilig gebruik met de helft daarvan, 0,9 kg·cm. Omdat de arm en de servo's een deel van dat budget opmaken met hun eigen gewicht, kan een SG90-arm van ongeveer 15 cm lang in de praktijk alleen lichte voorwerpen van 20–30 g dragen, zoals een flessendop of een klein schuimblokje.
Hoe bestuur ik een robotarm vanaf mijn telefoon?
Sluit een HC-05 Bluetooth-module aan op de Arduino en gebruik op je telefoon een Bluetooth-seriële terminal of een controllerapp met schuifregelaars om tekstcommando's zoals "S120" te sturen. Met een ESP32 heb je dankzij het ingebouwde Bluetooth geen extra module nodig. De HC-05 werkt niet met iPhones, dus voor een iPhone heb je een BLE-module of ESP32 BLE nodig.
Projecten om hierna te bouwen
Alle projecten bekijken
Servomotor aansturen met een potentiometer
Als je aan de knop van de potentiometer draait, draait de arm van de servomotor mee: het ene uiteinde van de knop staat voor nul graden, het andere voor een halve slag.

Servo's bedienen met joystick
Stuur twee motoren aan met een joystick, net als bij het draaien van een bewakingscamera.

Een servomotor gebruiken
De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.

ESP32-servomotor (bediening met potentiometer)
In dit project bedien je een SG90-servomotor met een potentiometer. De analoge waarde van de potentiometer zet je om naar het bereik van 0–180 graden en zo stel je de servohoek in. De ESP32Servo-bibliotheek maakt het servosignaal op geschikte GPIO-pinnen van de ESP32 die als uitgang kunnen dienen; dit project gebruikt GPIO 18. Dit is een basismethode voor robotarmen, cameragimbals en automatische deurmechanismen.

LED bedienen met je telefoon via Bluetooth
Een kleine oefening voor het aan- en uitzetten van de lampen in je kamer met je telefoon.

Auto met Bluetooth-besturing en L298N
Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

Servocirkelchoreografie: geanimeerde patronen met 32 servo's
Een visueel animatieproject met 32 servomotoren in een cirkel op een Arduino Mega. De servo's worden in één array beheerd, zijn aangesloten op pin 22–53 van de Mega en voeren vier bewegingsreeksen uit: een chaotische trilling met willekeurige hoeken, een gesynchroniseerde zwaai, een golf die rond de cirkel loopt en een kompasnaald die heen en weer zwaait.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

