Les 86: Positie van een servomotor regelen met behulp van een potentiometer

Les 86: Positie van een servomotor regelen met behulp van een potentiometer

Stel je voor dat je aan een eenvoudige knop draait en een mechanische arm nauwkeurig al je bewegingen volgt. Dat is de magie van het combineren van een potentiometer met een servomotor. Dit project, onderdeel van de Arduino Step by Step Course van Robojax, demonstreert een fundamenteel en ongelooflijk nuttig concept in de elektronica: het vertalen van een analoge invoer naar nauwkeurige fysieke beweging. Je leert hoe je een variabele spanning van een potentiometer leest, die waarde omzet naar een bereik van hoeken en een servomotor opdracht geeft om naar die exacte positie te draaien. Dit is je toegangspoort tot het bouwen van intuïtieve en interactieve projecten waar handmatige bediening automatisering ontmoet.

De toepassingen voor deze vaardigheid zijn enorm en praktisch. Hier zijn een paar ideeën om je te inspireren:

• Robotarmbesturing: Gebruik een potentiometer om elk gewricht van een robotarm handmatig te positioneren voor nauwkeurige pick-and-place-operaties.
• Camera-pan- en tiltsysteem: Bouw een op afstand bedienbare cameramontage voor time-lapses of bewaking, die soepel kantelt en draait met een draai aan een knop.
• Analoog meterreplica: Maak een fysiek dashboardinstrument (zoals een snelheidsmeter of temperatuurknop) dat beweegt op basis van sensorgegevens, met de potentiometer als handmatige override of kalibratietool.
• Interactieve kunstinstallaties: Maak kinetische sculpturen die reageren op invoer van kijkers, waarbij het draaien aan een knop de positie van bewegende delen verandert.
• Besturing van modelvoertuigen: Bedien de stuurhoek van een modelauto of -boot op afstand, voor een intuïtiever en analoog gevoel dan digitale knoppen.

Deze gids is gebaseerd op de video-tutorial Les 86: Positie van een servomotor besturen met potentiometer van Robojax (in video op 00:00). Het leidt je door het hele proces, van het begrijpen van de bedrading tot het uitleggen van de code die het allemaal laat werken. Laten we beginnen.

Hardware en componenten

Om dit project te volgen, heb je de volgende componenten nodig:

• Een Arduino-bord (bijv. Uno, Nano)
• Een standaard servomotor (bijv. SG90 of MG996R)
• Een potentiometer (variabele weerstand, meestal 10kΩ)
• Jumperdraden
• Een breadboard (optioneel, voor eenvoudigere verbindingen)

De bedrading begrijpen

De bedrading voor dit project is eenvoudig. De sleutel is het leveren van de juiste stroom- en signaalverbindingen voor zowel de servo als de potentiometer. De servo is een stroomvretend apparaat, dus hij krijgt zijn stroom rechtstreeks van de 5V-pin van de Arduino. De potentiometer fungeert als een spanningsdeler, en we lezen de spanning op de loper (de middelste pin) om de positie te bepalen. (in video op 01:05)

Een slimme truc die dit project gebruikt, is het creëren van een extra 5V-bron op een digitale pin om de potentiometer van stroom te voorzien, omdat sommige Arduino-borden slechts één speciale 5V-pin hebben. Dit wordt in de code gedaan door een digitale pin (pin 8) op HIGH te zetten, die 5V uitvoert. (in video op 00:39)

Hier is het bedradingsschema dat in de video wordt genoemd:

Laten we de verbindingen opsplitsen:

• Servomotor:
  • Stroom (rode draad) → Arduino 5V-pin
  • Aarde (bruine/zwarte draad) → Arduino GND-pin
  • Signaal (oranje/gele draad) → Arduino-pin 3 (een PWM-capabele pin)
• Potentiometer:
  • Linkerpin → Arduino GND-pin
  • Middelste pin (loper) → Arduino analoge pin A0
  • Rechterpin → Arduino-pin 8 (gedefinieerd als VCC2 in de code)

Code-uitleg

De code voor dit project is elegant eenvoudig. Het maakt gebruik van een paar belangrijke Arduino-functies om de potentiometer te lezen en de servo te besturen. Laten we ons richten op de door de gebruiker configureerbare delen die je kunt aanpassen voor je eigen projecten. (in video op 03:00)

Bovenaan de sketch definieer je de pinnen en maak je het servo-object. Dit zijn de primaire variabelen die je zult wijzigen op basis van je bedrading:

#include <Servo.h>

Servo myservo;  // maak servo-object om een servo te besturen

int potpin = A0;  // analoge pin die wordt gebruikt om de potentiometer aan te sluiten
int servoPin = 3; // definieer een digitale pin (met PWM) voor servo. Kan alleen pin 3, 5, 6, 9, 10, 11 gebruiken
int VCC2 = 8;// definieer extra VCC voor potentiometer
int val;    // variabele om de waarde van de analoge pin te lezen

Hier is wat elk onderdeel doet:

• Servo myservo;: Deze regel maakt een object met de naam myservo dat we zullen gebruiken om onze specifieke servomotor te besturen. Je kunt het hernoemen, maar je moet dezelfde naam later in de code gebruiken.
• int potpin = A0;: Dit definieert welke analoge pin is verbonden met de loper van de potentiometer. Als je de draad naar een andere analoge pin verplaatst, moet je dit nummer bijwerken.
• int servoPin = 3;: Dit stelt de digitale pin in voor de signaaldraad van de servo. Het is cruciaal om een PWM-capabele pin te gebruiken (meestal gemarkeerd met een '~' op het bord). De opmerking vermeldt de geldige pinnen voor de meeste Arduino's.
• int VCC2 = 8;: Dit is de pin die we gebruiken als secundaire 5V-bron voor de potentiometer. Als je een bord hebt met meerdere 5V-pinnen, kun je deze rechtstreeks aansluiten en dit deel van de code verwijderen.

In de functie setup() initialiseert de code de servo en stelt de extra voedingspin in. De functie myservo.attach(servoPin) is essentieel omdat deze de Arduino vertelt welke pin is verbonden met de signaaldraad van de servo.

void setup() {
  Serial.begin(9600);          //  setup seriële communicatie
  myservo.attach(servoPin);  // bevestigt de servo op pin 3 aan het servo-object

  pinMode(VCC2, OUTPUT);// stel pin 8 in als uitgang
  digitalWrite(VCC2, HIGH);// zet pin 8 HOOG zodat deze fungeert als 5V-pin
}

De kernlogica bevindt zich in de functie loop(). Deze leest de waarde van de potentiometer, schaalt deze naar een hoek en geeft de servo opdracht om te bewegen. De twee cruciale functies hier zijn analogRead() en map(). (in video op 04:27)

void loop() {
  val = analogRead(potpin);            // leest de waarde van de potentiometer (waarde tussen 0 en 1023)
  val = map(val, 0, 1023, 0, 180);     // schaal deze om te gebruiken met de servo (waarde tussen 0 en 180)
  myservo.write(val);                  // stelt de servopositie in op basis van de geschaalde waarde
  Serial.print(val);
  Serial.println();
  delay(50);                           // wacht tot de servo daar is
}

Zo werkt het:

• analogRead(potpin): Deze functie leest de spanning van de loper van de potentiometer en retourneert een waarde tussen 0 (0V) en 1023 (5V).
• map(val, 0, 1023, 0, 180): Dit is de sleutel tot het hele project. Het neemt de ruwe waarde van de potentiometer (0 tot 1023) en converteert deze proportioneel naar een servohoek (0 tot 180 graden). Als de potentiometer bijvoorbeeld 511 leest (ongeveer de helft), retourneert de functie map() 90, waardoor de servo naar zijn middenpositie beweegt.
• myservo.write(val): Deze functie neemt de berekende hoek (nu opgeslagen in val) en geeft de servo opdracht om naar die positie te draaien.
• delay(50): Dit voegt een kleine pauze toe aan het einde van elke lus. Het regelt de updatesnelheid. Een grotere vertraging (zoals 200 ms) laat de servo in stappen bewegen, terwijl een kleinere vertraging (zoals 50 ms) de beweging zeer vloeiend maakt. Je kunt dit aanpassen om de responsiviteit te wijzigen. (in video op 07:26)

Live projectdemonstratie

In de video zie je het project in actie. Wanneer de knop van de potentiometer wordt gedraaid, volgt de arm van de servomotor zijn positie proportioneel. De seriële monitor print de huidige hoek, wat bevestigt dat de mapping correct werkt. Wanneer de potentiometer op zijn minimale positie staat, bevindt de servo zich op 0 graden. Wanneer je de knop naar zijn maximum draait, draait de servo soepel naar 180 graden. (in video op 06:33)

Deze realtime feedbacklus demonstreert de naadloze integratie van een analoge sensor met een digitale actuator, waardoor een responsief en intuïtief besturingssysteem ontstaat.

Hoofdstukken

• [00:00] Introductie en projectoverzicht
• [01:05] Schema en bedradingsdiagram
• [02:07] Fysieke bedradingsdemonstratie
• [03:00] Uitleg van de code
• [06:33] Live demonstratie en testen
• [07:26] Aanpassen van de servoresponssnelheid

Afbeeldingen

Arduino wiring or servo motor with pot

SG90_servo_motor-1

SG90_servo_motor-0

Arduino wiring or servo motor with pot

SG90_servo_motor-1

SG90_servo_motor-0

/*
 * Lesson 88: Controlling Servo motor a with Potentiometer
 * 📚⬇️ Download and resource page https://robojax.com/RJT763
 watch full video tutroial: https://www.youtube.com/watch?v=ntRW77mNFFk
 
 Controlling a servo position using a potentiometer (variable resistor)
 by Michal Rinott <http://people.interaction-ivrea.it/m.rinott>

 modified on 8 Nov 2013
 by Scott Fitzgerald
 http://www.arduino.cc/en/Tutorial/Knob

 Update by Ahmad Shamshiri on Jan 01, 2019  in Ajax, Ontario, Canada


*/

#include <Servo.h>

Servo myservo;  // create servo object to control a servo

int potpin = A0;  // analog pin used to connect the potentiometer
int servoPin = 3; // define a digital pin (with PWM) for servo. Can use only pin 3, 5, 6,9, 10, 11
int VCC2 = 8;// define extra VCC for potentiometer
int val;    // variable to read the value from the analog pin

void setup() {
  //
  Serial.begin(9600);          //  setup serial
  myservo.attach(servoPin);  // attaches the servo on pin 3 to the servo object

  pinMode(VCC2, OUTPUT);// set pin 8 as output
  digitalWrite(VCC2, HIGH);// set pin 8 HIGH so it acts as 5V pin
}

void loop() {
  
  val = analogRead(potpin);            // reads the value of the potentiometer (value between 0 and 1023)
  val = map(val, 0, 1023, 0, 180);     // scale it to use it with the servo (value between 0 and 180)
  myservo.write(val);                  // sets the servo position according to the scaled value
  Serial.print(val);
  Serial.println();
  delay(50);                           // waits for the servo to get there
}