Gidsen · 19 min leestijd

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?

SG90
SG90
MG90S
MG90S
MG996R
MG996R

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.

GewrichtBewegingBelastingAanbevolen servo
Basis (middel)Zwenkt de arm naar links en rechtsTilt niets, maar draagt de hele armMG996R + lager
SchouderTilt de arm naar voren en naar achterenHet zwaarst belaste gewrichtMG996R of een servo uit de klasse van 20 kg·cm
ElleboogBuigt de onderarmGemiddeld tot hoogMG996R
Pols (kantelen)Stelt de hoek van de grijper inLaagMG90S
PolsdraaiingDraait de grijper om zijn asZeer laagMG90S of SG90
GrijperPakt het voorwerp vast en laat het losKlemkrachtSG90 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

OnderdeelArm met 4 assenArm met 6 servo'sOpmerking
ControllerArduino Uno of NanoArduino Uno, Nano of ESP32Door de extra ingangen A6 en A7 van de Nano kun je meer potmeters gebruiken
Servomotoren4× SG90 of MG90S3× MG996R + 3× MG90SControleer je keuze met de koppelberekening hieronder
ServodriverNiet nodigPCA9685-module met 16 kanalenSlechts 2 signaaldraden via I2C
Voeding5 V 3 A-adapter5–6 V-adapter, minimaal 5 AServo's voed je nooit via de Arduino
Condensator470–1000 µF, 16 V1000–2200 µF, 16 VOp de voedingsrail van de servo's, let op de polariteit
Bediening4× potmeter van 10 kΩ2× joystickmodule of een HC-05Je kunt ook beide gebruiken
Knoppen2 (opnemen, afspelen)De joystickknoppen zijn genoegGeen extra weerstanden nodig met INPUT_PULLUP
Mechaniek3 mm MDF of 3D-geprinte onderdelen4 mm MDF, 3D-printen of aluminium beugels608-lager, M3-bouten en borgmoeren

Mechanisch ontwerp: MDF of 3D-printen?

MateriaalVoordelenNadelenHet beste voor
3–4 mm MDF (lasergesneden)Goedkoop, licht, makkelijk te schroeven en te lijmenGevoelig voor vocht, schroefgaten worden na verloop van tijd groterEerste armen in MeArm-stijl, schoolprojecten
3 mm acrylZiet er mooi uit, geen last van vochtBroos; kan barsten als je schroeven aandraaitDisplay- en showmodellen
3D-printen (PLA / PETG)Complexe onderdelen, servo-uitsparingen op exacte maatLange printtijden; PLA kruipt bij warmte en onder constante belastingEigen ontwerpen; PETG voor dragende onderdelen
Kit met aluminium beugelsZeer stijf, kant-en-klare onderdelen voor de MG996RZwaar en duur, belast de schouder extraArmen met 6 servo's die zwaardere voorwerpen moeten tillen
Karton, ijslollystokjesBijna gratis, snel prototypes makenSlap, gewrichten krijgen spelingAfmetingen 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?

ModelKoppelSnelheid (per 60°)GewichtTandwielenBlokkeerstroomRol in een robotarm
SG901,8 kg·cm (4,8 V)0,10 s (4,8 V)9 gKunststofOngeveer 0,6–0,75 AGrijper, lichte pols, kleine arm met 4 assen
MG90S1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V)0,10 s (4,8 V)13,4 gMetalOngeveer 0,7–1 APols, polsdraaiing, grijper
MG996R9,4 kg·cm (4,8 V), 11 kg·cm (6 V)0,17 s (4,8 V)55 gMetal2,5 A (6 V)Basis, schouder, elleboog
DS321819 kg·cm (5 V), 21,5 kg·cm (6,8 V)0,16 s (5 V)60 gMetalOngeveer 2–3 ASchouder 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.

MG996R-servomotor met metalen tandwielen
MG996R: metalen tandwielen, 11 kg·cm koppel bij 6 V en een uitgaande as met 25 tanden; de standaardkeuze voor de basis, schouder en elleboog van een robotarm.

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:

OnderdeelMassaAfstand tot schouderasKoppel
Onderdelen bovenarm (MDF en bouten)40 g6 cm (zwaartepunt)0,04 × 6 = 0,24 kg·cm
Elleboogservo (MG996R)55 g12 cm0,055 × 12 = 0,66 kg·cm
Onderdelen onderarm30 g18 cm0,03 × 18 = 0,54 kg·cm
Polsservo + grijper (MG90S, SG90 en onderdelen)50 g25 cm0,05 × 25 = 1,25 kg·cm
Vastgehouden voorwerp50 g30 cm0,05 × 30 = 1,50 kg·cm
Totaal225 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.

Er zijn drie goedkope manieren om het schoudermoment te verlagen: de arm inkorten, de elleboogservo naar de schouder verplaatsen en de elleboog aandrijven met een duwstang, en een tegengewicht achter de schouder of een veer die de arm omhoogtrekt toevoegen. Een gewicht van 400 g op 5 cm achter de schouderas geeft bijvoorbeeld 0,4 × 5 = 2 kg·cm tegenkoppel en halveert de belasting van de arm hierboven bijna; het lager van de basis draagt daardoor wat meer gewicht.

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 armGeschatte stroomAanbevolen voeding
Kleine arm met 4× SG90 of MG90S0,5–1 A tijdens het bewegen, 2–3 A piek5 V 3 A-adapter of een LM2596-module (max. 3 A, ongeveer 2 A zonder koelplaat)
Arm met 6 servo's: 3× MG996R + 3× MG90S2–3 A tijdens het bewegen, 8–10 A als alles blokkeert5–6 V-schakelende adapter, minimaal 5 A (10 A voor ruime marge)
Draagbare armHangt af van de arm2S-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
Voed servo's nooit via de 5V-pin van de Arduino en verbind de min van de externe voeding altijd met de GND van de Arduino; zonder een gemeenschappelijke massa kunnen de servo's het signaal niet lezen en bewegen ze willekeurig. Plaats een elektrolytische condensator op de voedingsrail van de servo's, vlak naast de servo's, van minimaal 100 µF per servo (1000–2200 µF, 16 V of meer voor een arm met 6 servo's), met het lange pootje op de plus; een verkeerd om geplaatste elco kan opzwellen en barsten. De voedingsrails van een breadboard zijn ontworpen voor ongeveer 1 A, dus leg bij een arm met MG996R de voedingsdraden rechtstreeks naar een schroefklem of naar de V+-ingang van de PCA9685.

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.

AansluitingArduino UnoRaspberry Pi Pico
Signaal basisservo (oranje draad)D3GP10
Signaal schouderservoD5GP11
Signaal elleboogservoD6GP12
Signaal grijperservoD9GP13
Loper potmeter 1–3 (basis, schouder, elleboog)A0, A1, A2GP26, GP27, GP28
Loper potmeter 4 (grijper)A3Geen; de grijper gebruikt de knop op GP14
Buitenste pootjes van de potmeters5V en GND3V3 en GND
Knoppen voor opnemen en afspelen (andere kant naar GND)D7 en D8—
Rode servodraad (+)Plus van externe 5–6 VPlus van externe 5–6 V
Bruine servodraad (−)Min van externe voeding + GND van ArduinoMin van externe voeding + GND van Pico
Draaipotmeter van 10 kΩ
Potmeter van 10 kΩ: de buitenste pootjes gaan naar 5V en GND, het middelste pootje (loper) naar een analoge ingang; als je aan de as draait, draait het gewricht in dezelfde verhouding mee.

Kalibreer vóór de montage: centreer de servo's

  1. Upload de onderstaande code voordat je de servohoorns monteert; alle vier de servo's bewegen na elkaar naar 90 graden en blijven daar staan.
  2. 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.
  3. Zet CENTER_ONLY in de code op false, kies een gewricht met TEST en draai langzaam aan de potmeter op A0.
  4. 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.
  5. 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.
  6. Vul de waarden die je hebt gevonden in bij de arrays MIN_A en MAX_A van de volgende sketches.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
ActieWat jij doetWat de arm doet
Een pose opslaanKort drukken op de opneemknop (D7)De led knippert één keer, de pose wordt naar het EEPROM geschreven
Opnames wissenHoud de opneemknop 2 seconden ingedruktDe led knippert vijf keer, het aantal stappen wordt teruggezet
AfspelenDruk op de afspeelknop en laat los (D8)De led gaat branden, de poses worden op volgorde afgespeeld met vloeiende overgangen
Afspelen stoppenHoud de afspeelknop ingedrukt tijdens het afspelenDe arm maakt de huidige pose af en stopt
Terug naar de normale modusDoe niets zodra het afspelen klaar isDe 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.

Elke EEPROM-cel kan ongeveer 100.000 keer worden beschreven. Omdat de code EEPROM.update() gebruikt, worden alleen cellen geschreven waarvan de waarde is veranderd, dus in de praktijk slijt hij nooit op. Voor langere bewegingsreeksen kun je opnames opslaan op een SD-kaart of het EEPROM van 4 KB van de Arduino Mega gebruiken.

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-pinArduino UnoESP32Raspberry Pi Pico
GNDGNDGNDGND
VCC (alleen chipvoeding)5V3V33V3
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
V+-klem (servovoeding)Externe 5–6 VExterne 5–6 VExterne 5–6 V
OENiet aansluitenNiet aansluitenNiet aansluiten
Servo-aansluitingen 0–5Basis, schouder, elleboog, pols, polsdraaiing, grijperZelfde volgordeZelfde volgorde
De PCA9685 heeft twee aparte voedingen: VCC voedt alleen de chip, terwijl de servo's worden gevoed via de V+-ingang op de schroefklem. Als V+ onbekrachtigd blijft, verschijnt het board wel op I2C, maar bewegen de servo's niet. Op de Arduino Uno worden A4 en A5 gebruikt voor I2C, dus met een aangesloten PCA9685 blijven alleen A0–A3 over als analoge ingangen; heb je meer potmeters nodig, gebruik dan een Arduino Nano met de extra ingangen A6 en A7.

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.

Analoge joystickmodule met twee assen
Joystickmodule: de uitgangen VRx en VRy lezen in rust ongeveer 512 en de SW-knop trekt naar GND als je erop drukt. Twee modules kunnen vier gewrichten van een robotarm aansturen.
C++ (Arduino IDE)
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.

HC-05 Bluetooth-seriële module
HC-05: een seriële module die via klassiek Bluetooth met je telefoon koppelt; VCC werkt op 5 V, maar de RXD-ingang werkt op 3,3 V-logica.
CommandoBetekenisVoorbeeld
B + hoekBasisB90
S + hoekSchouderS120
E + hoekElleboogE45
W + hoekPols (kantelen)W100
R + hoekPolsdraaiingR0
G + hoekGrijperG110 (dicht), G40 (open)
HTerug naar thuisposeH
K / P / X / CPose opslaan / in een lus afspelen / stoppen / poses wissenK
C++ (Arduino IDE)
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.

Op je telefoon heb je alleen een kant-en-klare app nodig: installeer op Android een Bluetooth-seriële terminal of een Bluetooth-controllerapp met schuifregelaars en geef elke schuifregelaar een voorvoegsel zoals "S" plus een regeleinde. Wil je zelf een interface met knoppen en schuifregelaars bouwen, dan loopt de gids Bluetooth-app met MIT App Inventor je er stap voor stap doorheen. Omdat de HC-05 klassiek Bluetooth gebruikt, werkt hij niet met iPhones; voor een iPhone heb je een Bluetooth Low Energy-oplossing nodig, zoals ESP32 BLE.

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.

C++ (Arduino IDE)
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.

MicroPython
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 loop

Verder 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

SymptoomWaarschijnlijke oorzaakOplossing
Servo's jitteren en zoemen terwijl de arm stilstaatRuis in de potmetermetingen of een zwakke voedingVoeg 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 verbindingDe aanloopstroom van de servo's trekt de spanning omlaagVoed 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 binnenkomtInterrupts van SoftwareSerial verstoren de pulsen van de Servo-bibliotheekVerplaats de servo's naar een PCA9685 of gebruik het ingebouwde Bluetooth van de ESP32
De arm schiet bij het opstarten ergens heenServo's onthouden hun laatste positie niet en bewegen bij het eerste commando op volle snelheidZet 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 doorTe weinig koppelDoe de koppelberekening; gebruik een MG996R, een kortere arm, een tegengewicht of een veer
Een gewricht blokkeert aan één kant en wordt heetDe servo duwt tegen een mechanische aanslagZet de limieten MIN_A en MAX_A uit de kalibratie in de code
De grijperservo wordt warm terwijl hij een voorwerp vasthoudtDe grijper blijft proberen te sluiten en de servo blijft geblokkeerdStel 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 beweegtGeen spanning op de V+-klem of geen gemeenschappelijke massaGeef V+ 5–6 V en controleer het I2C-adres (0x40)
Een gewricht slipt onder belastingEen kunststof servohoorn is uitgeslepen of de middelste schroef ontbreektGebruik een metalen servohoorn en zet hem met de middelste schroef vast op de as
Een snelle manier om te zien of het probleem de voeding of de code is: draai de kalibratiesketch (CENTER_ONLY = false) zonder aangesloten servo's en bekijk de hoeken in de Serial Monitor terwijl je aan de potmeter draait. Zien de waarden er goed uit, dan ligt het probleem bij de voeding; meet de spanning van de servorail met een multimeter terwijl de arm beweegt, en als die onder 4,5 V zakt, is je voeding of bedrading niet toereikend. Voor alle oorzaken van resets, zie Waarom blijft mijn Arduino resetten?.

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.

Alle projecten bekijken
Servomotor aansturen met een potentiometer
AR-36Beginner
Premium

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.

4.6(37)
53
Servo's bedienen met joystick
AR-60Gemiddeld
Premium

Servo's bedienen met joystick

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

4.7(42)
58
Een servomotor gebruiken
AR-35Beginner
Premium

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.

4.7(48)
67
ESP32-servomotor (bediening met potentiometer)
ES-16Gemiddeld
Premium

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.

4.3(29)
42
LED bedienen met je telefoon via Bluetooth
AR-34Beginner
Premium

LED bedienen met je telefoon via Bluetooth

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

4.8(69)
91
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

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…

5.0(39)
66
Servocirkelchoreografie: geanimeerde patronen met 32 servo's
AR-97Gevorderd
Premium

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.

4.5(40)
62