Lecția 86: Controlul poziției unui servomotor folosind potențiometrul

Lecția 86: Controlul poziției unui servomotor folosind potențiometrul

Imaginează-ți că rotești un simplu buton și urmărești cum un braț mecanic urmează cu precizie fiecare mișcare a ta. Aceasta este magia combinării unui potențiometru cu un servomotor. Acest proiect, parte din cursul Arduino Step by Step de la Robojax, demonstrează un concept fundamental și extrem de util în electronică: transformarea unei intrări analogice într-o mișcare fizică precisă. Vei învăța cum să citești o tensiune variabilă de la un potențiometru, să transformi acea valoare într-un interval de unghiuri și să comanzi un servomotor să se rotească în acea poziție exactă. Aceasta este poarta ta de acces către construirea de proiecte intuitive și interactive în care controlul manual întâlnește automatizarea.

Aplicațiile acestei abilități sunt vaste și practice. Iată doar câteva idei pentru a te inspira:

• Controlul brațului robotic: Folosește un potențiometru pentru a poziționa manual fiecare articulație a unui braț robotic pentru operațiuni precise de ridicare și plasare.
• Sistem de panoramare și înclinare pentru cameră: Construiește un suport de cameră controlat de la distanță pentru time-lapse sau supraveghere, panoramând și înclinând lin cu o simplă rotire a unui buton.
• Replică de indicator analogic: Creează un indicator fizic de bord (ca un vitezometru sau un cadran de temperatură) care se mișcă pe baza datelor de la senzori, potențiometrul acționând ca o unealtă de override manual sau de calibrare.
• Instalații artistice interactive: Creează sculpturi cinetice care răspund la inputul privitorului, unde rotirea unui buton schimbă poziția pieselor în mișcare.
• Direcție pentru vehicule model: Controlează unghiul de direcție al unei mașini sau bărci model de la distanță, oferind o senzație mai intuitivă și analogică decât butoanele digitale.

Acest ghid se bazează pe tutorialul video Lesson 86: Control position of a servo motor using potentiometer de Robojax (în video la 00:00). Te ghidează prin întregul proces, de la înțelegerea cablajului până la explicarea codului care face totul să funcționeze. Să începem.

Hardware și componente

Pentru a urma acest proiect, vei avea nevoie de următoarele componente:

• O placă Arduino (de exemplu, Uno, Nano)
• Un servomotor standard (de exemplu, SG90 sau MG996R)
• Un potențiometru (rezistor variabil, de obicei 10kΩ)
• Fire de legătură (jumper wires)
• O breadboard (opțional, pentru conexiuni mai ușoare)

Înțelegerea cablajului

Cablajul pentru acest proiect este simplu. Cheia este să furnizezi conexiunile corecte de alimentare și semnal atât pentru servomotor, cât și pentru potențiometru. Servomotorul este un dispozitiv care consumă multă energie, deci primește alimentarea direct de la pinul de 5V al Arduino. Potențiometrul acționează ca un divizor de tensiune, iar noi citim tensiunea la cursorul său (pinul din mijloc) pentru a determina poziția. (în video la 01:05)

Un truc inteligent folosit în acest proiect este crearea unei surse suplimentare de 5V pe un pin digital pentru a alimenta potențiometrul, deoarece unele plăci Arduino au doar un singur pin dedicat de 5V. Acest lucru se face în cod prin setarea unui pin digital (pinul 8) la HIGH, care scoate 5V. (în video la 00:39)

Iată diagrama de cablare menționată în video:

Să descompunem conexiunile:

• Servomotor:
  • Alimentare (fir roșu) → Pinul 5V al Arduino
  • Masă (fir maro/negru) → Pinul GND al Arduino
  • Semnal (fir portocaliu/galben) → Pinul 3 al Arduino (un pin capabil de PWM)
• Potențiometru:
  • Pinul din stânga → Pinul GND al Arduino
  • Pinul din mijloc (cursor) → Pinul analogic A0 al Arduino
  • Pinul din dreapta → Pinul 8 al Arduino (definit ca VCC2 în cod)

Explicația codului

Codul pentru acest proiect este elegant de simplu. Folosește câteva funcții cheie Arduino pentru a citi potențiometrul și a controla servomotorul. Să ne concentrăm pe părțile configurabile de utilizator pe care le poți ajusta pentru propriile proiecte. (în video la 03:00)

În partea de sus a schiței, vei defini pinii și vei crea obiectul servomotor. Acestea sunt variabilele principale pe care le vei schimba în funcție de cablajul tău:

#include <Servo.h>

Servo myservo;  // creează obiectul servomotor pentru a controla un servomotor

int potpin = A0;  // pin analogic folosit pentru a conecta potențiometrul
int servoPin = 3; // definește un pin digital (cu PWM) pentru servomotor. Poți folosi doar pinii 3, 5, 6, 9, 10, 11
int VCC2 = 8;// definește VCC suplimentar pentru potențiometru
int val;    // variabilă pentru a citi valoarea de la pinul analogic

Iată ce face fiecare parte:

• Servo myservo;: Această linie creează un obiect numit myservo pe care îl vom folosi pentru a controla servomotorul nostru specific. Îl poți redenumi, dar trebuie să folosești același nume mai târziu în cod.
• int potpin = A0;: Aceasta definește pinul analogic la care este conectat cursorul potențiometrului. Dacă muți firul la un alt pin analogic, trebuie să actualizezi acest număr.
• int servoPin = 3;: Aceasta setează pinul digital pentru firul de semnal al servomotorului. Este crucial să folosești un pin capabil de PWM (de obicei cele marcate cu '~' pe placă). Comentariul listează pinii valizi pentru majoritatea plăcilor Arduino.
• int VCC2 = 8;: Acesta este pinul pe care îl folosim ca sursă secundară de 5V pentru potențiometru. Dacă ai o placă cu mai mulți pini de 5V, poți conecta direct și elimina această parte din cod.

În funcția setup(), codul inițializează servomotorul și configurează pinul suplimentar de alimentare. Funcția myservo.attach(servoPin) este esențială, deoarece îi spune plăcii Arduino care pin este conectat la firul de semnal al servomotorului.

void setup() {
  Serial.begin(9600);          //  configurează seriala
  myservo.attach(servoPin);  // atașează servomotorul pe pinul 3 la obiectul servo

  pinMode(VCC2, OUTPUT);// setează pinul 8 ca ieșire
  digitalWrite(VCC2, HIGH);// setează pinul 8 la HIGH pentru a acționa ca pin de 5V
}

Logica principală se află în funcția loop(). Aceasta citește valoarea potențiometrului, o scalează la un unghi și comandă servomotorul să se miște. Cele două funcții critice aici sunt analogRead() și map(). (în video la 04:27)

void loop() {
  val = analogRead(potpin);            // citește valoarea potențiometrului (valoare între 0 și 1023)
  val = map(val, 0, 1023, 0, 180);     // o scalează pentru a o folosi cu servomotorul (valoare între 0 și 180)
  myservo.write(val);                  // setează poziția servomotorului conform valorii scalate
  Serial.print(val);
  Serial.println();
  delay(50);                           // așteaptă ca servomotorul să ajungă acolo
}

Iată cum funcționează:

• analogRead(potpin): Această funcție citește tensiunea de la cursorul potențiometrului și returnează o valoare între 0 (0V) și 1023 (5V).
• map(val, 0, 1023, 0, 180): Aceasta este cheia întregului proiect. Prelucrează valoarea brută de la potențiometru (0 la 1023) și o convertește proporțional într-un unghi pentru servomotor (0 la 180 de grade). De exemplu, dacă potențiometrul citește 511 (aproximativ jumătate), funcția map() va returna 90, mișcând servomotorul în poziția centrală.
• myservo.write(val): Această funcție preia unghiul calculat (acum stocat în val) și îi spune servomotorului să se rotească în acea poziție.
• delay(50): Aceasta adaugă o mică pauză la sfârșitul fiecărei bucle. Controlează rata de actualizare. O întârziere mai mare (cum ar fi 200ms) face ca servomotorul să se miște în pași, în timp ce o întârziere mai mică (cum ar fi 50ms) face mișcarea foarte lină. Poți ajusta aceasta pentru a schimba capacitatea de răspuns. (în video la 07:26)

Demonstrație live a proiectului

În video, poți vedea proiectul în acțiune. Pe măsură ce butonul potențiometrului este rotit, brațul servomotorului urmează proporțional poziția acestuia. Monitorul serial afișează unghiul curent, confirmând că maparea funcționează corect. Când potențiometrul este în poziția minimă, servomotorul este la 0 grade. Pe măsură ce rotești butonul la maxim, servomotorul se rotește lin până la 180 de grade. (în video la 06:33)

Această buclă de feedback în timp real demonstrează integrarea perfectă a unui senzor analogic cu un actuator digital, creând un sistem de control receptiv și intuitiv.

Capitole

• [00:00] Introducere și prezentare generală a proiectului
• [01:05] Schemă și diagramă de conexiuni
• [02:07] Demonstrație fizică a conexiunilor
• [03:00] Explicația codului
• [06:33] Demonstrație live și testare
• [07:26] Ajustarea vitezei de răspuns a servomotorului

Imagini

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
}