Servomotoren besturen met Arduino - Complete gids

Arduino servomotorbesturing

Laten we het bovenstaande testen en een praktisch voorbeeld maken van het besturen van een hobbyservo met behulp van Arduino. Ik zal de MG996R gebruiken, een servo met hoog koppel en metalen tandwielen met een koppel van 10 kg-cm. Het hoge koppel heeft een prijs en dat is de blokkeerstroom van de servo die 2,5 A is. De bedrijfsstroom is van 500mA tot 900mA en de bedrijfsspanning is van 4,8 tot 7,2V.

De huidige beoordelingen geven aan dat we deze servo niet rechtstreeks op de Arduino kunnen aansluiten, maar dat we er een aparte voeding voor moeten gebruiken.

Circuitdiagram

Hier is het schakelschema voor dit voorbeeld.

We hoeven alleen maar de besturingspin van de servo aan te sluiten op een digitale pin van het Arduino-bord, de aarde en de positieve draden op de externe 5V-voeding aan te sluiten en ook de Arduino-aarde met de servo-aarde te verbinden.

Als we een kleinere hobbyservo gebruiken, de S90 Micro Servo, is het mogelijk om deze rechtstreeks vanaf de 5V Arduino-pin van stroom te voorzien.

De S90 Micro Servo heeft een lager stroomverbruik, ongeveer 100-200mA nullaststroom, maar ongeveer 500-700mA blokkeerstroom. Aan de andere kant kan de Arduino 5V-pin slechts ongeveer 500 mA uitvoeren als hij wordt gevoed via USB, of tot 1 A via de barrelconnector.

Hoewel het mogelijk is om deze 9g-servomotoren rechtstreeks naar Arduino te sturen, raad ik aan om voor stabieler werk altijd een externe voeding voor ze te gebruiken.

U kunt de benodigde componenten voor dit voorbeeld vinden via de onderstaande links:

• MG996R servomotor ……………………….
• of S90 Micro Servo ………..……………………
• Arduino-bord …………………………………….
• 5V 2A DC-voeding …………………..…..

Servomotorbesturing Arduino-code

Laten we nu eens kijken naar de Arduino-code voor het besturen van de servomotor. De code is heel eenvoudig. We moeten alleen de pin definiëren waarop de servo is aangesloten, die pin definiëren als een uitgang en in de lussectie pulsen genereren met de specifieke duur en frequentie zoals we eerder hebben uitgelegd.

/*
     Servo Motor Control - 50Hz Pulse Train Generator
           by Dejan, https://howtomechatronics.com
*/

#define servoPin 9

void setup() {
  pinMode(servoPin, OUTPUT);
}

void loop() {
   // A pulse each 20ms
    digitalWrite(servoPin, HIGH);
    delayMicroseconds(1450); // Duration of the pusle in microseconds
    digitalWrite(servoPin, LOW);
    delayMicroseconds(18550); // 20ms - duration of the pusle
    // Pulses duration: 600 - 0deg; 1450 - 90deg; 2300 - 180deg
}Code language: Arduino (arduino)

Na wat testen kwam ik tot de volgende waarden voor de duur van de pulsen die met mijn servo werken. Pulsen met een duur van 0,6 ms kwamen overeen met een positie van 0 graden, 1,45 ms tot 90 graden en 2,3 ms tot 180 graden.

Ik heb een multimeter in serie met de servo aangesloten om de stroomafname te controleren. De maximale stroomafname die ik opmerkte, was tot 0,63 A bij stal. Nou, dat komt omdat dit niet de originele TowerPro MG996R-servo is, maar een goedkopere replica, die duidelijk slechtere prestaties heeft.

Laten we echter eens kijken naar een handiger manier om servo's te besturen met Arduino. Dat is met behulp van de Arduino-servobibliotheek.

/*
     Servo Motor Control using the Arduino Servo Library
           by Dejan, https://howtomechatronics.com
*/

#include <Servo.h>

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

void setup() {
  myservo.attach(9,600,2300);  // (pin, min, max)
}

void loop() {
  myservo.write(0);  // tell servo to go to a particular angle
  delay(1000);
  
  myservo.write(90);              
  delay(500); 
  
  myservo.write(135);              
  delay(500);
  
  myservo.write(180);              
  delay(1500);                     
}Code language: Arduino (arduino)

Hier hoeven we alleen de bibliotheek op te nemen, het servo-object te definiëren en met behulp van de functie attach() de pin te definiëren waarmee de servo is verbonden, evenals de minimale en maximale waarden van de duur van de pulsen. Vervolgens gebruiken we de functie write() om de positie van de servo eenvoudig in te stellen van 0 tot 180 graden.

Meerdere servomotoren besturen met Arduino

De Arduino-servobibliotheek ondersteunt het besturen van maximaal 12 servo's tegelijk met de meeste Arduino-borden en 48 servo's met behulp van het Arduino Mega-bord. Bovendien is het besturen van meerdere servomotoren met Arduino net zo eenvoudig als het besturen van slechts één.

Hier is een voorbeeldcode voor het besturen van meerdere servo's:

/*
     Controlling multiple servo motors with Arduino
     by Dejan, https://howtomechatronics.com
*/

#include <Servo.h>

Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;

void setup() {
  servo1.attach(8);
  servo2.attach(9);
  servo3.attach(10);
  servo4.attach(11);
  servo5.attach(12);
}

void loop() {
  // move all servos to position 0
  servo1.write(0);
  servo2.write(0);
  servo3.write(0);
  servo4.write(0);
  servo5.write(0);
  delay(2000);

  // move all servos to position 90
  servo1.write(90);
  servo2.write(90);
  servo3.write(90);
  servo4.write(90);
  servo5.write(90);
  delay(2000);

  // move all servos to position 180
  servo1.write(180);
  servo2.write(180);
  servo3.write(180);
  servo4.write(180);
  servo5.write(180);
  delay(2000);
}Code language: Arduino (arduino)

We hoeven dus alleen maar objecten uit de Servo-klasse te maken voor elke servomotor en te definiëren op welke Arduino-pin is aangesloten. Natuurlijk kunnen we elke servo zo instellen dat deze op elk moment naar elke positie gaat.

Als voorbeeld kun je ook mijn Arduino Ant Hexapod Robot-project bekijken, waar ik een Arduino MEGA-bord heb gebruikt om 22 servomotoren te besturen.

Arduino en PCA9685 PWM/servo-stuurprogramma

Er is ook een andere manier om servo's met Arduino te besturen, en dat is met behulp van de PCA9685-servodriver. Dit is een 16-kanaals 12-bits PWM- en servodriver die communiceert met Arduino via de I2C-bus. Het heeft een ingebouwde klok, zodat het 16 servo's kan aansturen, vrijlopend of onafhankelijk van Arduino.

Wat nog cooler is, we kunnen tot 62 van deze stuurprogramma's in serie schakelen op een enkele I2C-bus. Dus theoretisch kunnen we tot 992 servo's besturen met alleen de twee I2C-pinnen van het Arduino-bord. De 6 adresselectiepinnen worden gebruikt om voor elke extra driver een ander I2C-adres in te stellen. We hoeven alleen de soldeerpads volgens deze tabel aan te sluiten.

Hier is het schakelschema en we kunnen opnieuw merken dat we een aparte voeding nodig hebben voor de servo's.

U kunt de benodigde componenten voor dit voorbeeld vinden via de onderstaande links:

• MG996R servomotor ……………………….
• PCA9685 PWM-servostuurprogramma  ……………….
• Arduino-bord …………………………………….
• 5V 6A DC-voeding ………………..…..

Laten we nu eens kijken naar de Arduino-code. Voor het besturen van deze servodriver zullen we de PCA9685-bibliotheek gebruiken die kan worden gedownload van GitHub.

Arduino- en PCA9685-code

/*
     Servo Motor Control using Arduino and PCA9685 Driver
           by Dejan, https://howtomechatronics.com
           
     Library: https://github.com/NachtRaveVL/PCA9685-Arduino
*/

#include <Wire.h>
#include "PCA9685.h"

PCA9685 driver;

// PCA9685 outputs = 12-bit = 4096 steps
// 2.5% of 20ms = 0.5ms ; 12.5% of 20ms = 2.5ms
// 2.5% of 4096 = 102 steps; 12.5% of 4096 = 512 steps
PCA9685_ServoEvaluator pwmServo(102, 470); // (-90deg, +90deg)

// Second Servo
// PCA9685_ServoEvaluator pwmServo2(102, 310, 505); // (0deg, 90deg, 180deg)


void setup() {
  Wire.begin();                 // Wire must be started first
  Wire.setClock(400000);        // Supported baud rates are 100kHz, 400kHz, and 1000kHz
  driver.resetDevices();        // Software resets all PCA9685 devices on Wire line

  driver.init(B000000);         // Address pins A5-A0 set to B000000
  driver.setPWMFrequency(50);   // Set frequency to 50Hz
}
void loop() {
  driver.setChannelPWM(0, pwmServo.pwmForAngle(-90));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(0));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(90));
  delay(1000);
}Code language: Arduino (arduino)

Dus eerst moeten we de bibliotheken opnemen en het object PCA9685 definiëren. Gebruik vervolgens de Servo_Evaluator-instantie om de duur van de pulsen of de PWM-uitgang van de driver te definiëren. Merk op dat de uitgangen 12-bits zijn, of dat is een resolutie van 4096 stappen. Dus de minimale pulsduur van 0,5 ms of 0 graden positie zou overeenkomen met 102 stappen, en de maximale pulsduur van 2,5 ms of 180 graden positie met 512 stappen. Maar zoals eerder uitgelegd, moeten deze waarden worden aangepast aan uw servomotor. Ik had een waarde van 102 tot 470, wat overeenkwam met een positie van 0 tot 180 graden.

In het setup-gedeelte moeten we de I2C-kloksnelheid definiëren, het driveradres instellen en de frequentie instellen op 50 Hz.

In de loop-sectie, met behulp van de setChannelPWM() en pwmForAngle() functies zetten we de servo eenvoudig in de gewenste hoek.

Ik heb een tweede servo op de driver aangesloten en zoals ik had verwacht, positioneerde deze niet hetzelfde als de eerste, en dat komt omdat de servo's die ik gebruik goedkope kopieën zijn en niet zo betrouwbaar. Dit is echter geen groot probleem omdat het gebruik van de Servo_Evaluator we kunnen bijvoorbeeld verschillende uitvoerinstellingen voor elke servo instellen. We kunnen ook de 90 graden positie aanpassen voor het geval het niet precies in het midden is. Op die manier zullen alle servo's hetzelfde werken en onder de exacte hoek worden geplaatst.

Veel servo's besturen met Arduino en de PCA9685-drivers

We zullen nog een voorbeeld bekijken en dat is het besturen van veel servo's met meerdere geketende PCA9685-stuurprogramma's.

Voor dat doel moeten we de drivers met elkaar verbinden en de juiste soldeerpads voor adresselectie aansluiten. Hier is het schakelschema:

Laten we nu eens kijken naar de Arduino-code.

/*
     Servo Motor Control using Arduino and PCA9685 Driver
           by Dejan, https://howtomechatronics.com
           
     Library: https://github.com/NachtRaveVL/PCA9685-Arduino
*/

#include <Wire.h>
#include "PCA9685.h"

PCA9685 driver;

// PCA9685 outputs = 12-bit = 4096 steps
// 2.5% of 20ms = 0.5ms ; 12.5% of 20ms = 2.5ms
// 2.5% of 4096 = 102 steps; 12.5% of 4096 = 512 steps
PCA9685_ServoEvaluator pwmServo(102, 470); // (-90deg, +90deg)

// Second Servo
PCA9685_ServoEvaluator pwmServo2(102, 310, 505); // (0deg, 90deg, 180deg)


void setup() {
  Wire.begin();                 // Wire must be started first
  Wire.setClock(400000);        // Supported baud rates are 100kHz, 400kHz, and 1000kHz
  driver.resetDevices();        // Software resets all PCA9685 devices on Wire line

  driver.init(B000000);         // Address pins A5-A0 set to B000000
  driver.setPWMFrequency(50);   // Set frequency to 50Hz
}
void loop() {
  driver.setChannelPWM(0, pwmServo.pwmForAngle(-90));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(0));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(90));
  delay(1000);
}Code language: Arduino (arduino)

We moeten dus voor elke driver een apart PCA9685-object maken, de adressen voor elke driver definiëren en de frequentie instellen op 50 Hz. Door nu eenvoudigweg de functies setChannelPWM() en pwmForAngle() te gebruiken, kunnen we elke servo op elke driver instellen om elke gewenste hoek te positioneren.

Problemen oplossen

Servomotor schokt en reset mijn Arduino-bord

Dit is een veelvoorkomend probleem bij deze hobby servomotoren, de SG90 Micro Servo en de MG996R. De reden hiervoor is dat ze, zoals eerder vermeld, een behoorlijke hoeveelheid stroom kunnen trekken als ze belast zijn. Dit kan ertoe leiden dat het Arduino-bord opnieuw wordt ingesteld, vooral als u de servo rechtstreeks vanaf de Arduino 5V-pin van stroom voorziet.

Om dit probleem op te lossen, kunt u een condensator over de GND en de 5V-pin gebruiken. Het zal fungeren als een ontkoppelcondensator die extra stroom aan het systeem zal leveren bij het opstarten wanneer de gelijkstroommotor start.

Servomotor beweegt niet over het hele bereik van 0 tot 180 graden

Dit is een ander veelvoorkomend probleem met deze hobbyservo's. Zoals we eerder hebben uitgelegd, komt een pulsbreedte van 1 ms (0,5 ms) overeen met een positie van 0 graden, en 2 ms (2,5 ms) met 180 graden. Deze waarden kunnen echter variëren van servo tot servo en tussen verschillende fabrikanten.

Om dit probleem op te lossen, moeten we de pulsbreedte aanpassen die we met de Arduino naar de servomotor sturen. Gelukkig kunnen we met behulp van de Arduino Servo-bibliotheek eenvoudig de pulsbreedtewaarden aanpassen in de attach() functie.

De attach() functie kan twee extra parameters hebben, en dat is de minimale en maximale pulsduur in microseconden. De standaardwaarden zijn 544 microseconden (0,544 milliseconden) voor een minimale hoek (0 graden) en 2400 microseconden (2,4 ms). Dus door deze waarden aan te passen, kunnen we het momentbereik van de servo fijn afstemmen.

  myservo.attach(9,600,2300);  // (pin, min, max)Code language: Arduino (arduino)

Afmetingen en 3D-model

Ik heb 3D-modellen gemaakt van de twee meest populaire servomotoren, de SG90 Micro Servo en de MG996R servomotor. Je kunt ze downloaden via de onderstaande links.

SG90 microservo

3D-model:downloaden van Thangs.

Afmetingen:

MG996R servomotor

MG996R servomotor 3D-model:downloaden van Thangs.

Afmetingen:

Conclusie

We hebben dus bijna alles besproken wat we moeten weten over het gebruik van servomotoren met Arduino. Natuurlijk zijn er een aantal fabrikanten en modellen van dit soort hobby- of RC-servomotoren, en elk van hen heeft zijn eigen unieke kenmerken die kunnen verschillen van wat we hierboven hebben uitgelegd.

De mogelijkheden voor het maken van geweldige robotica-, automatiserings- en RC-projecten met behulp van motoren zijn eindeloos, maar het kiezen van het juiste model voor uw toepassing is erg belangrijk.

Ik hoop dat je deze tutorial leuk vond en iets nieuws hebt geleerd. Stel gerust een vraag in de opmerkingen hieronder, en zorg ervoor dat je mijn Arduino Projects Collection kunt bekijken.

Veelgestelde vragen (FAQ's)

Het gebruik van een servomotor met Arduino is vrij eenvoudig. De servomotor heeft slechts 3 draden, waarvan twee GND en 5V voor voeding, en de derde draad is de besturingslijn die naar het Arduino-bord gaat.

We kunnen servomotoren rechtstreeks vanuit Arduino laten draaien, maar we kunnen stroomproblemen hebben. Als de servomotor meer dan 500 mA stroom trekt, kan het Arduino-bord zijn vermogen verliezen en opnieuw worden ingesteld. Het is beter om altijd een aparte stroombron voor de servomotoren te gebruiken.

Met behulp van de Arduino Servo-bibliotheek kunnen we tot 12 servomotoren aansturen met de meeste Arduino-borden, en tot 48 servomotoren met het Arduino Mega-bord. Natuurlijk moeten we een speciale stroombron gebruiken voor de servomotoren.