Les 89: Gebruik van een continue of 360-servomotor| Arduino Stap voor Stap Cursus

Les 89: Gebruik van een continue of 360-servomotor| Arduino Stap voor Stap Cursus

Heb je ooit een motor in beide richtingen willen laten draaien zo lang je wilt, in plaats van alleen heen en weer te zwaaien zoals een standaard servo? Dit is precies wat een continue of 360-graden servomotor biedt. In tegenstelling tot een standaard servo die naar een specifieke hoek beweegt (meestal 0 tot 180 graden), draait een continue servo eindeloos in zowel de richting van de klok mee als tegen de klok in. Dit maakt hem perfect voor het bouwen van kleine robots, camerplatforms of elk project dat continue rotatiebesturing vereist.

In dit project bouwen we een besturingssysteem voor een 360-graden servo met slechts drie drukknoppen. Je kunt de servo opdracht geven om met de klok mee te draaien, tegen de klok in, of op elk moment te stoppen. Deze handleiding leidt je door de bedrading, legt de door de gebruiker instelbare delen van de code uit en toont een live demonstratie van het systeem in actie.

Hier zijn een paar praktische ideeën voor het gebruik van een continue servo in je eigen projecten:

• Bouw een kleine robot met twee wielen: Gebruik twee continue servo's om de wielen aan te drijven, zodat je vooruit, achteruit en draaiende bewegingen kunt maken.
• Maak een pan- en tilt-cameramontage: Gebruik één continue servo voor langzaam, eindeloos pannen van een beveiligings- of natuurobservatiecamera.
• Automatiseer een transportband: Bestuur een klein transportsysteem voor het sorteren of afgeven van items.
• Ontwerp een draaiende displaystandaard: Toon een 3D-model of product op een platform dat continu draait.

Benodigde hardware

• Arduino-board (Uno, Nano, enz.)
• Continue (360-graden) servomotor (bijv. FS90R, DS04-NFC)
• 3x drukknoppen
• Jumperdraden
• Breadboard

Bedradingshandleiding

De bedrading voor dit project is eenvoudig. De servomotor heeft drie draden: meestal een donkere voor aarde (GND), een middelste (vaak rood) voor stroom (5V) en een lichtere (oranje, geel of wit) voor het signaal. Zoals in de video wordt getoond, is de servo als volgt op de Arduino aangesloten:

• Servo-aarde (donkere draad): Verbind met Arduino GND.
• Servo-stroom (middelste/rode draad): Verbind met Arduino 5V.
• Servo-signaal (lichte draad): Verbind met Arduino-pin 9.

Voor de drie drukknoppen heeft elke knop twee zijden. Eén zijde van alle knoppen wordt met elkaar verbonden en vervolgens met de Arduino GND. De andere zijde van elke knop wordt verbonden met een aparte digitale pin, zoals hieronder beschreven (in de video op 03:40):

• Met de klok mee (CW)-knop: Verbind met Arduino-pin 2.
• Stop-knop: Verbind met Arduino-pin 3.
• Tegen de klok in (CCW)-knop: Verbind met Arduino-pin 4.

Code-uitleg

De code is ontworpen om gemakkelijk configureerbaar te zijn. Het belangrijkste onderdeel dat je moet aanpassen is de sc[]-array, die de specifieke PWM-waarden bevat die naar de servo worden gestuurd om de acties te besturen. Deze waarden zijn niet universeel en moeten worden gekalibreerd voor jouw specifieke servomotor (in de video op 12:23).

int sc[]={106, 58, 0};// servocommando's zijn in volgorde
        //CCW, STOP, CW

Deze array is het hart van de kalibratie. De waarden worden in deze volgorde gebruikt:

• sc[0] = 106: Deze waarde wordt verzonden om de servo tegen de klok in te laten draaien.
• sc[1] = 58: Dit is de "stop"-waarde. Door de interne schakeling varieert de exacte waarde die de motor laat stoppen. Je kunt merken dat je servo langzaam blijft draaien, zelfs wanneer dit commando wordt verzonden, en je moet dit getal iets aanpassen om de echte "dode stop"-waarde voor jouw motor te vinden.
• sc[2] = 0: Deze waarde laat de servo met de klok mee draaien op maximale snelheid.

Je kunt de waarden in de sc[]-array aanpassen om de rotatiesnelheid te veranderen. Bijvoorbeeld, het instellen van sc[0] op 70 maakt de rotatie tegen de klok in langzamer. Hoe dichter een waarde bij de "stop"-waarde (58) ligt, hoe langzamer de motor in die richting draait. Waarden verder van 58 verhogen de snelheid tot een maximumlimiet.

Er zijn ook een paar andere belangrijke variabelen die je mogelijk moet aanpassen. De servoPin is ingesteld op 9, wat een PWM-capabele pin op je Arduino moet zijn. De knop-pinnen zijn bovenaan de code gedefinieerd en kunnen indien nodig worden gewijzigd.

int servoPin = 9;// deze pin moet een van die met PWM ~ zijn

#define STOPpin 3 // drukknop-pin voor STOP
#define CWpin 2 // drukknop voor CW
#define CCWpin 4 // drukknop voor CCW

Tenslotte bevat de scText[]-array de strings die naar de Seriële Monitor worden afgedrukt voor debugging. Je kunt deze wijzigen als je andere berichten wilt weergeven.

Hoe de code te gebruiken

Upload de meegeleverde code naar je Arduino-board. Open de Seriële Monitor (ingesteld op 9600 baud) om de statusberichten te zien. Je kunt de servo nu besturen met de drie knoppen:

• Houd de CW-knop ingedrukt: De servo begint met de klok mee te draaien. De Seriële Monitor toont "CW" en de verzonden waarde.
• Houd de CCW-knop ingedrukt: De servo begint tegen de klok in te draaien. De Seriële Monitor toont "CCW" en de verzonden waarde.
• Druk op de Stop-knop: De servo probeert te stoppen. De Seriële Monitor toont "Stop".

Als uw servo niet volledig stopt wanneer de Stop-knop wordt ingedrukt, moet u de sc[1]-waarde in de sc[]-array kalibreren. Probeer de waarde iets te wijzigen (bijvoorbeeld van 58 naar 54 of 52) en upload de code opnieuw totdat de motor perfect stil blijft staan.

Live Demonstratie

In de video demonstreert de presentator het volledige systeem. U kunt zien hoe de servo in beide richtingen draait op basis van de knopdrukken. De Serial Monitor-uitvoer wordt ook getoond, met de huidige status ("CW", "Stop" of "CCW") en de specifieke waarde die naar de servo wordt gestuurd. Dit is een uitstekend hulpmiddel voor het debuggen en het vinden van de perfecte kalibratiewaarden voor uw specifieke motor. De demonstratie laat ook zien hoe het aanpassen van de waarden in de sc[]-array direct invloed heeft op de snelheid van de motor, van een langzame kruipgang tot de maximale rotatiesnelheid.

Conclusie

Dit project biedt een eenvoudige en effectieve manier om een continue servomotor te besturen. Door het kalibratieproces voor de "stop"-waarde te begrijpen, kunt u nauwkeurige controle garanderen in uw eigen robotica- en automatiseringsprojecten.

Video Hoofdstukken

• [00:05] Introductie tot de Continue Servomotor
• [02:02] Hardware Overzicht van de Servo
• [02:40] Bedradingsschema en Aansluitingen
• [05:07] Code Uitleg: Variabelen en Setup
• [08:03] Code Uitleg: Hoofdloop Logica
• [09:56] De servoCommand()-Functie
• [10:54] Live Demonstratie en Serial Monitor Uitvoer
• [12:23] Kalibreren van Servosnelheid en Stopwaarden

Afbeeldingen

360_Serrvo_3_push_button_wiring

360_Serrvo_3_push_button_wiring

++
/*
 *  S05-13 Servo with 3 push buttons
 *  Demonstration of Controlling a Continuous Servo (360 servo)
 *  This code allows you to control a 360-degree servo using push buttons
 *
 * Modified by Ahmad Shamshiri for Robojax Robojax.com
 * on Jan 17, 2019 at 22:42 in Ajax, Ontario, Canada
 Watch the video instruction for this sketch: https://youtu.be/hVe4TSRV4ww

 Watch Introduction to  360 Servo video with code: https://youtu.be/b_xvu6wWafA
 You can get the wiring diagram from my Arduino Course at Udemy.com
 Learn Arduino step by step with all libraries, codes, and wiring diagrams all in one place
 visit my course now http://robojax.com/L/?id=62

 If you found this tutorial helpful, please support me so I can continue creating
 content like this. 
 or make a donation using PayPal http://robojax.com/L/?id=64

 Original code by BARRAGAN <http://barraganstudio.com>
 *
 * Code is available at http://robojax.com/learn/arduino

 * This code is "AS IS" without warranty or liability. Free to be used as long as you keep this note intact.
 * This code has been downloaded from Robojax.com
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.

*/

#include <Servo.h>

Servo myservo;  // create servo object to control a servo
// twelve servo objects can be created on most boards

int servoPin = 9;// this pin must be one of those with PWM ~


#define STOPpin 3 // push button pin  for STOP
#define CWpin 2 //  push button for CW
#define CCWpin 4 // push button for CCW

int sc[]={106, 58, 0};// servo commands are in order
        //CCW, STOP,CW

String scText[]={"CCW","Stop","CW"};// define texts for 3 actions
int statusText;
int CWBS, CCWBS, SBS;
      //CW button status (CWBS)
      //CCW button status (CCWBS)
      //stop button status (SBS)

void setup() {
  Serial.begin(9600);
  pinMode(STOPpin,INPUT_PULLUP);// set pin for push button STOP
  pinMode(CCWpin,INPUT_PULLUP);// set pin for push button CCW
  pinMode(CWpin,INPUT_PULLUP);// set pin for push button CW

  myservo.attach(servoPin);  // attaches the servo on pin 9 to the servo object
  myservo.write(sc[1]);// send STOP command
  statusText=1;// initial value is STOP
}



void loop() {

    CCWBS = digitalRead(CCWpin);// read status of button CCW
    SBS = digitalRead(STOPpin);// read status of button STOP
    CWBS = digitalRead(CWpin);// read status of button CW

    if(CCWBS ==LOW)
    {
      servoCommand(0);
    }else if(SBS ==LOW)
    {
      servoCommand(1);
    }else if(CWBS ==LOW)
    {
      servoCommand(2);
    }

  Serial.println(scText[statusText]);
  delay(50);
}// loop



void servoCommand(int n)
{
   statusText = n;
   myservo.write(sc[n]);
   Serial.print("Going to  ");
   Serial.print(scText[n]);
   Serial.print( "(");
   Serial.print(sc[n]);
   Serial.println(")");
}