પાઠ ૮૬: પોટેન્શિયોમીટરનો ઉપયોગ કરીને સર્વો મોટરની સ્થિતિ નિયંત્રિત કરો

પાઠ ૮૬: પોટેન્શિયોમીટરનો ઉપયોગ કરીને સર્વો મોટરની સ્થિતિ નિયંત્રિત કરો

કલ્પના કરો કે એક સરળ નોબ ફેરવો અને જુઓ કે યાંત્રિક હાથ તમારી દરેક હિલચાલને ચોક્કસપણે અનુસરે છે. આ જ પોટેન્શિયોમીટરને સર્વો મોટર સાથે જોડવાનો જાદુ છે. આ પ્રોજેક્ટ, રોબોજેક્સ દ્વારા આર્ડુનો સ્ટેપ બાય સ્ટેપ કોર્સનો ભાગ છે, જે ઇલેક્ટ્રોનિક્સમાં એક મૂળભૂત અને અત્યંત ઉપયોગી ખ્યાલ દર્શાવે છે: એનાલોગ ઇનપુટને ચોક્કસ ભૌતિક ગતિમાં રૂપાંતરિત કરવું. તમે શીખી શકશો કે પોટેન્શિયોમીટરમાંથી ચલ વોલ્ટેજ કેવી રીતે વાંચવું, તે મૂલ્યને ખૂણાઓની શ્રેણીમાં કેવી રીતે મેપ કરવું, અને સર્વો મોટરને તે ચોક્કસ સ્થિતિમાં ફેરવવાનો આદેશ કેવી રીતે આપવો. આ તમારા માટે સાહજિક અને ઇન્ટરેક્ટિવ પ્રોજેક્ટ્સ બનાવવાનો પ્રવેશદ્વાર છે જ્યાં મેન્યુઅલ નિયંત્રણ ઓટોમેશન સાથે મળે છે.

આ કૌશલ્યના ઉપયોગો વિશાળ અને વ્યવહારુ છે. તમને પ્રેરણા આપવા માટે અહીં થોડા વિચારો છે:

• રોબોટિક આર્મ કંટ્રોલ: ચોક્કસ પિક-એન્ડ-પ્લેસ કામગીરી માટે રોબોટિક આર્મના દરેક સાંધાને મેન્યુઅલી સ્થાન આપવા પોટેન્શિયોમીટરનો ઉપયોગ કરો.
• કેમેરા પાન અને ટિલ્ટ સિસ્ટમ: ટાઇમ-લેપ્સ અથવા સર્વેલન્સ માટે રિમોટ-કંટ્રોલ્ડ કેમેરા માઉન્ટ બનાવો, ડાયલ ફેરવવાથી સરળતાથી પાન અને ટિલ્ટ થાય.
• એનાલોગ ગેજ રેપ્લિકા: સેન્સર ડેટાના આધારે ખસતું ભૌતિક ડેશબોર્ડ ગેજ (જેમ કે સ્પીડોમીટર અથવા તાપમાન ડાયલ) બનાવો, જેમાં પોટેન્શિયોમીટર મેન્યુઅલ ઓવરરાઇડ અથવા કેલિબ્રેશન ટૂલ તરીકે કામ કરે.
• ઇન્ટરેક્ટિવ આર્ટ ઇન્સ્ટોલેશન્સ: દર્શકોના ઇનપુટને પ્રતિસાદ આપતી કાઇનેટિક શિલ્પો બનાવો, જ્યાં ડાયલ ફેરવવાથી ફરતા ભાગોની સ્થિતિ બદલાય.
• મોડેલ વ્હીકલ સ્ટીયરિંગ: મોડેલ કાર અથવા બોટના સ્ટીયરિંગ એંગલને રિમોટલી નિયંત્રિત કરો, જે ડિજિટલ બટનો કરતાં વધુ સાહજિક અને એનાલોગ અનુભવ આપે.

આ માર્ગદર્શિકા રોબોજેક્સ દ્વારા વિડિયો ટ્યુટોરિયલ પાઠ 86: પોટેન્શિયોમીટરનો ઉપયોગ કરીને સર્વો મોટરની સ્થિતિ નિયંત્રિત કરો (વિડિયોમાં 00:00 પર) પર આધારિત છે. તે તમને સમગ્ર પ્રક્રિયામાં લઈ જાય છે, વાયરિંગ સમજવાથી લઈને તે બધું કામ કરતા કોડ સમજાવવા સુધી. ચાલો શરૂ કરીએ.

હાર્ડવેર અને ઘટકો

આ પ્રોજેક્ટ સાથે આગળ વધવા માટે, તમારે નીચેના ઘટકોની જરૂર પડશે:

• એક આર્ડુનો બોર્ડ (દા.ત., Uno, Nano)
• એક સ્ટાન્ડર્ડ સર્વો મોટર (દા.ત., SG90 અથવા MG996R)
• એક પોટેન્શિયોમીટર (ચલ રેઝિસ્ટર, સામાન્ય રીતે 10kΩ)
• જમ્પર વાયર
• એક બ્રેડબોર્ડ (વૈકલ્પિક, સરળ જોડાણો માટે)

વાયરિંગ સમજવું

આ પ્રોજેક્ટ માટે વાયરિંગ સીધું છે. મુખ્ય વાત એ છે કે સર્વો અને પોટેન્શિયોમીટર બંને માટે યોગ્ય પાવર અને સિગ્નલ જોડાણો પ્રદાન કરવા. સર્વો એક પાવર-ભૂખ્યું ઉપકરણ છે, તેથી તેને તેનો પાવર સીધો આર્ડુનોના 5V પિનમાંથી મળે છે. પોટેન્શિયોમીટર વોલ્ટેજ ડિવાઇડર તરીકે કામ કરે છે, અને અમે તેની સ્થિતિ નક્કી કરવા માટે તેના વાઇપર (મધ્યમ પિન) પરનો વોલ્ટેજ વાંચીએ છીએ. (વિડિયોમાં 01:05 પર)

આ પ્રોજેક્ટ ઉપયોગ કરે છે તે એક સરસ યુક્તિ એ છે કે પોટેન્શિયોમીટરને પાવર આપવા માટે ડિજિટલ પિન પર વધારાનો 5V સ્ત્રોત બનાવવો, કારણ કે કેટલાક આર્ડુનો બોર્ડમાં ફક્ત એક જ સમર્પિત 5V પિન હોય છે. આ કોડમાં ડિજિટલ પિન (પિન 8) ને HIGH પર સેટ કરીને કરવામાં આવે છે, જે 5V આઉટપુટ કરે છે. (વિડિયોમાં 00:39 પર)

અહીં વિડિયોમાં ઉલ્લેખિત વાયરિંગ ડાયાગ્રામ છે:

ચાલો જોડાણોને તોડીએ:

• સર્વો મોટર:
  • પાવર (લાલ વાયર) → આર્ડુનો 5V પિન
  • ગ્રાઉન્ડ (ભૂરો/કાળો વાયર) → આર્ડુનો GND પિન
  • સિગ્નલ (નારંગી/પીળો વાયર) → આર્ડુનો પિન 3 (PWM-સક્ષમ પિન)
• પોટેન્શિયોમીટર:
  • ડાબો પિન → આર્ડુનો GND પિન
  • મધ્યમ પિન (વાઇપર) → આર્ડુનો એનાલોગ પિન A0
  • જમણો પિન → આર્ડુનો પિન 8 (કોડમાં VCC2 તરીકે વ્યાખ્યાયિત)

કોડ સમજૂતી

આ પ્રોજેક્ટ માટેનો કોડ ખૂબ જ સરળ છે. તે પોટેન્શિયોમીટર વાંચવા અને સર્વો નિયંત્રિત કરવા માટે થોડા મુખ્ય આર્ડુનો ફંક્શનનો ઉપયોગ કરે છે. ચાલો તમારા પોતાના પ્રોજેક્ટ્સ માટે તમે ગોઠવી શકો તેવા વપરાશકર્તા-રૂપરેખાંકિત ભાગો પર ધ્યાન કેન્દ્રિત કરીએ. (વિડિયોમાં 03:00 પર)

સ્કેચની ટોચ પર, તમે પિન વ્યાખ્યાયિત કરશો અને સર્વો ઑબ્જેક્ટ બનાવશો. આ મુખ્ય ચલો છે જે તમે તમારા વાયરિંગના આધારે બદલશો:

#include <Servo.h>

Servo myservo;  // સર્વો નિયંત્રિત કરવા માટે સર્વો ઑબ્જેક્ટ બનાવો

int potpin = A0;  // પોટેન્શિયોમીટર જોડવા માટે વપરાતો એનાલોગ પિન
int servoPin = 3; // સર્વો માટે ડિજિટલ પિન (PWM સાથે) વ્યાખ્યાયિત કરો. ફક્ત પિન 3, 5, 6, 9, 10, 11 વાપરી શકાય છે
int VCC2 = 8;// પોટેન્શિયોમીટર માટે વધારાનો VCC વ્યાખ્યાયિત કરો
int val;    // એનાલોગ પિનમાંથી મૂલ્ય વાંચવા માટે ચલ

અહીં દરેક ભાગ શું કરે છે:

• Servo myservo;: આ લાઇન myservo નામનો ઑબ્જેક્ટ બનાવે છે જેનો ઉપયોગ આપણે આપણી ચોક્કસ સર્વો મોટરને નિયંત્રિત કરવા માટે કરીશું. તમે તેનું નામ બદલી શકો છો, પરંતુ તમારે પછીથી કોડમાં સમાન નામનો ઉપયોગ કરવો પડશે.
• int potpin = A0;: આ વ્યાખ્યાયિત કરે છે કે પોટેન્શિયોમીટરનો વાઇપર કયા એનાલોગ પિન સાથે જોડાયેલ છે. જો તમે વાયરને અલગ એનાલોગ પિન પર ખસેડો છો, તો તમારે આ નંબર અપડેટ કરવો પડશે.
• int servoPin = 3;: આ સર્વોના સિગ્નલ વાયર માટે ડિજિટલ પિન સેટ કરે છે. PWM-સક્ષમ પિન (સામાન્ય રીતે બોર્ડ પર '~' સાથે ચિહ્નિત) નો ઉપયોગ કરવો મહત્વપૂર્ણ છે. ટિપ્પણી મોટાભાગના આર્ડુનો માટે માન્ય પિનની સૂચિ આપે છે.
• int VCC2 = 8;: આ તે પિન છે જેનો ઉપયોગ આપણે પોટેન્શિયોમીટર માટે ગૌણ 5V સ્ત્રોત તરીકે કરી રહ્યા છીએ. જો તમારી પાસે બહુવિધ 5V પિનવાળું બોર્ડ છે, તો તમે તેને સીધું જોડી શકો છો અને કોડનો આ ભાગ દૂર કરી શકો છો.

setup() ફંક્શનમાં, કોડ સર્વોને ઇનિશિયલાઇઝ કરે છે અને વધારાનો પાવર પિન સેટ કરે છે. myservo.attach(servoPin) ફંક્શન આવશ્યક છે કારણ કે તે આર્ડુઇનોને જણાવે છે કે કયો પિન સર્વોના સિગ્નલ વાયર સાથે જોડાયેલો છે.

void setup() {
  Serial.begin(9600);          //  સીરિયલ સેટઅપ કરો
  myservo.attach(servoPin);  // સર્વો ઑબ્જેક્ટ સાથે પિન 3 પર સર્વોને જોડે છે

  pinMode(VCC2, OUTPUT);// પિન 8 ને આઉટપુટ તરીકે સેટ કરો
  digitalWrite(VCC2, HIGH);// પિન 8 ને HIGH સેટ કરો જેથી તે 5V પિન તરીકે કાર્ય કરે
}

મુખ્ય લોજિક loop() ફંક્શનમાં છે. તે પોટેન્શિયોમીટરનું મૂલ્ય વાંચે છે, તેને કોણમાં રૂપાંતરિત કરે છે, અને સર્વોને ખસેડવાનો આદેશ આપે છે. અહીં બે મહત્વપૂર્ણ ફંક્શનો છે analogRead() અને map(). (વિડિયોમાં 04:27 પર)

void loop() {
  val = analogRead(potpin);            // પોટેન્શિયોમીટરનું મૂલ્ય વાંચે છે (મૂલ્ય 0 અને 1023 વચ્ચે)
  val = map(val, 0, 1023, 0, 180);     // તેને સર્વો સાથે ઉપયોગ કરવા માટે સ્કેલ કરો (મૂલ્ય 0 અને 180 વચ્ચે)
  myservo.write(val);                  // સ્કેલ કરેલા મૂલ્ય અનુસાર સર્વો સ્થિતિ સેટ કરે છે
  Serial.print(val);
  Serial.println();
  delay(50);                           // સર્વો ત્યાં પહોંચે ત્યાં સુધી રાહ જુએ છે
}

તે કેવી રીતે કાર્ય કરે છે તે અહીં છે:

• analogRead(potpin): આ ફંક્શન પોટેન્શિયોમીટરના વાઇપરમાંથી વોલ્ટેજ વાંચે છે અને 0 (0V) અને 1023 (5V) વચ્ચેનું મૂલ્ય પરત કરે છે.
• map(val, 0, 1023, 0, 180): આ સમગ્ર પ્રોજેક્ટની ચાવી છે. તે પોટેન્શિયોમીટરમાંથી કાચું મૂલ્ય (0 થી 1023) લે છે અને તેને પ્રમાણસર સર્વો કોણ (0 થી 180 ડિગ્રી) માં રૂપાંતરિત કરે છે. ઉદાહરણ તરીકે, જો પોટેન્શિયોમીટર 511 (લગભગ અડધું) વાંચે છે, તો map() ફંક્શન 90 પરત કરશે, સર્વોને તેની મધ્ય સ્થિતિમાં ખસેડશે.
• myservo.write(val): આ ફંક્શન ગણતરી કરેલું કોણ (હવે val માં સંગ્રહિત) લે છે અને સર્વોને તે સ્થિતિમાં ફેરવવાનું કહે છે.
• delay(50): આ દરેક લૂપના અંતે થોડો વિરામ ઉમેરે છે. તે અપડેટ દરને નિયંત્રિત કરે છે. મોટો વિલંબ (જેમ કે 200ms) સર્વોને પગલાંઓમાં ખસેડે છે, જ્યારે નાનો વિલંબ (જેમ કે 50ms) હલનચલનને ખૂબ જ સરળ બનાવે છે. પ્રતિભાવ બદલવા માટે તમે આને સમાયોજિત કરી શકો છો. (વિડિયોમાં 07:26 પર)

લાઇવ પ્રોજેક્ટ પ્રદર્શન

વિડિયોમાં, તમે પ્રોજેક્ટને કાર્યરત જોઈ શકો છો. જેમ પોટેન્શિયોમીટરનું નોબ ફેરવવામાં આવે છે, સર્વો મોટરનો હાથ તેની સ્થિતિને પ્રમાણસર અનુસરે છે. સીરિયલ મોનિટર વર્તમાન કોણ છાપે છે, જે પુષ્ટિ કરે છે કે મેપિંગ યોગ્ય રીતે કાર્ય કરી રહ્યું છે. જ્યારે પોટેન્શિયોમીટર તેની ન્યૂનતમ સ્થિતિમાં હોય છે, ત્યારે સર્વો 0 ડિગ્રી પર હોય છે. જેમ તમે નોબને તેના મહત્તમ સુધી ફેરવો છો, સર્વો સરળતાથી 180 ડિગ્રી સુધી ફરે છે. (વિડિયોમાં 06:33 પર)

આ રીઅલ-ટાઇમ ફીડબેક લૂપ એનાલોગ સેન્સર અને ડિજિટલ એક્ટ્યુએટરના સીમલેસ એકીકરણને દર્શાવે છે, જે પ્રતિભાવશીલ અને સાહજિક નિયંત્રણ સિસ્ટમ બનાવે છે.

પ્રકરણો

• [00:00] પરિચય અને પ્રોજેક્ટ ઝાંખી
• [01:05] સ્કીમેટિક અને વાયરિંગ ડાયાગ્રામ
• [02:07] ભૌતિક વાયરિંગ પ્રદર્શન
• [03:00] કોડ સમજૂતી
• [06:33] લાઇવ પ્રદર્શન અને પરીક્ષણ
• [07:26] સર્વો પ્રતિભાવ ગતિ સમાયોજિત કરવી

છબીઓ

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
}