પાઠ ૧૮/૩૧: આર્ડુઇનો સાથે સર્વો મોટરનો ઉપયોગ — સનફાઉન્ડરની આર્ડુઇનો કિટ

પાઠ ૧૮/૩૧: આર્ડુઇનો સાથે સર્વો મોટરનો ઉપયોગ — સનફાઉન્ડરની આર્ડુઇનો કિટ

સર્વો મોટર્સ અસંખ્ય રોબોટિક્સ અને રિમોટ-કંટ્રોલ પ્રોજેક્ટ્સના વર્કહોર્સ છે, જે સ્ટીયરિંગ મિકેનિઝમ્સથી લઈને રોબોટિક આર્મ્સ સુધીની દરેક વસ્તુ માટે ચોક્કસ કોણીય નિયંત્રણ પ્રદાન કરે છે. આ માર્ગદર્શિકા, SunFounder Arduino કિટ કોર્સના પાઠ 18 પર આધારિત છે, જે તમને Arduino સાથે સર્વો મોટરનો ઉપયોગ કરવાની મૂળભૂત બાબતોમાંથી પસાર કરશે. તમે હાર્ડવેરને કેવી રીતે કનેક્ટ કરવું અને બે અલગ અલગ પદ્ધતિઓનો ઉપયોગ કરીને મોટરની સ્થિતિને કેવી રીતે નિયંત્રિત કરવી તે શીખી શકશો: એક સરળ સ્વીપિંગ ગતિ અને નોબ-નિયંત્રિત સ્થિતિ. તમે અહીં મેળવેલું જ્ઞાન અત્યંત વ્યવહારુ છે અને તેને વિવિધ પ્રોજેક્ટ્સમાં લાગુ કરી શકાય છે, જેમાં નીચેનાનો સમાવેશ થાય છે:

• રોબોટિક આર્મ બનાવવું જે ચોકસાઈ સાથે વસ્તુઓને પકડી અને ખસેડી શકે.
• સ્ટીયરિંગ માટે સર્વો સાથે રિમોટ-કંટ્રોલ કાર અથવા બોટ બનાવવી.
• સોલાર ટ્રેકર વિકસાવવું જે ઊર્જા સંગ્રહને મહત્તમ કરવા સૂર્યને અનુસરે.
• સર્વેલન્સ અથવા ફોટોગ્રાફી માટે પાન-અને-ટિલ્ટ કેમેરા માઉન્ટ બનાવવું.
• મોડેલ એરોપ્લેનના કંટ્રોલ સરફેસ, જેમ કે રડર અથવા એલિરોન્સને સ્વચાલિત કરવું.

હાર્ડવેર ઝાંખી

કોડમાં ડૂબકી મારતા પહેલા, સર્વો મોટરને સમજવું આવશ્યક છે. વિડિયોમાં દર્શાવ્યા મુજબ, સર્વો મોટર પ્રમાણભૂત DC મોટરની જેમ સતત ફરતી નથી. તેના બદલે, તે ચોક્કસ કોણીય સ્થિતિમાં ફરે છે, સામાન્ય રીતે 0 અને 180 ડિગ્રી વચ્ચે. આ તેને ચોક્કસ હિલચાલની જરૂર હોય તેવા કાર્યક્રમો માટે આદર્શ બનાવે છે. વિડિયો ઘણા ઉદાહરણો પ્રકાશિત કરે છે, RC કારને સ્ટીયરિંગ કરવાથી લઈને રોબોટિક આર્મના જટિલ સાંધાઓને નિયંત્રિત કરવા સુધી (વિડિયોમાં 00:06 પર).

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

મોટાભાગના શોખના સર્વોમાં પ્રમાણભૂત કનેક્ટરમાં ત્રણ વાયર હોય છે. વિડિયો એક સમજદાર ડિઝાઇન પસંદગી સમજાવે છે: મધ્યમ વાયર હંમેશા પાવર વાયર (VCC) હોય છે, સામાન્ય રીતે 5V. આ એક સલામતી સુવિધા છે જે કનેક્ટરને ઊલટું પ્લગ કરવામાં આવે તો ઉપકરણને ખોટી ધ્રુવીયતાથી રક્ષણ આપે છે (વિડિયોમાં 03:27 પર). અન્ય બે વાયર ગ્રાઉન્ડ (GND) અને કંટ્રોલ સિગ્નલ માટે છે.

વાયરિંગ માર્ગદર્શિકા

સર્વોને તમારા Arduino સાથે વાયરિંગ કરવું સરળ છે. વિડિયો કનેક્શન્સનું સ્પષ્ટ પ્રદર્શન પૂરું પાડે છે (વિડિયોમાં 04:48 પર). સર્વો કનેક્ટર પરના ત્રણ પિન નીચે મુજબ Arduino સાથે કનેક્ટ થાય છે:

• સિગ્નલ વાયર (ઘણીવાર નારંગી અથવા પીળો): આને Arduino પર ડિજિટલ PWM પિન સાથે કનેક્ટ કરો. ઉદાહરણ પિન 9 નો ઉપયોગ કરે છે.
• પાવર વાયર (ઘણીવાર લાલ): આને Arduino પર 5V પિન સાથે કનેક્ટ કરો.
• ગ્રાઉન્ડ વાયર (ઘણીવાર ભૂરો અથવા કાળો): આને Arduino પરના GND પિનમાંથી એક સાથે કનેક્ટ કરો.

વિડિયોમાં, પ્રસ્તુતકર્તા સર્વો પરના ફિમેલ કનેક્ટરને Arduino ના પિન હેડર્સ સાથે કનેક્ટ કરવા માટે મેલ-ટુ-મેલ DuPont જમ્પર વાયરનો ઉપયોગ કરે છે (વિડિયોમાં 05:23 પર).

પ્રોગ્રામ 1: સર્વો મોટરને નિયંત્રિત કરવું (સ્વીપ)

આ પ્રથમ પ્રોગ્રામ ક્લાસિક "સ્વીપ" ઉદાહરણ છે. તે સર્વોને 0 અને 180 ડિગ્રી વચ્ચે આગળ અને પાછળ ખસેડીને તેની સંપૂર્ણ ગતિ શ્રેણી દર્શાવવા માટે રચાયેલ છે. તમારું વાયરિંગ સાચું છે તે ચકાસવાનો અને તમારા સર્વોને ક્રિયામાં જોવાનો આ એક સરસ રસ્તો છે. વિડિયો આ કોડ અપલોડ કરવાનું અને સર્વોને આગળ અને પાછળ સ્વીપ થતું જોવાનું દર્શાવે છે (વિડિયોમાં 09:21 પર).

સર્વોને નિયંત્રિત કરવા માટે, કોડ પહેલા બિલ્ટ-ઇન Servo.h લાઇબ્રેરીનો સમાવેશ કરે છે, જે જરૂરી કંટ્રોલ સિગ્નલો ઉત્પન્ન કરવાની પ્રક્રિયાને સરળ બનાવે છે. પછી તમે સર્વો ઑબ્જેક્ટ બનાવો છો અને તેને myservo જેવું નામ આપો છો. setup() ફંક્શનમાં, તમે myservo.attach(9) નો ઉપયોગ કરીને આ ઑબ્જેક્ટને ચોક્કસ પિન સાથે જોડો છો, જે Arduino ને કહે છે કે સર્વોનો સિગ્નલ વાયર પિન 9 સાથે કનેક્ટેડ છે.

જાદુ loop() ફંક્શનમાં થાય છે, જે સર્વોને ખસેડવા માટે બે for લૂપ્સનો ઉપયોગ કરે છે. પ્રથમ લૂપ સ્થિતિ ચલ pos ને 0 થી 180 સુધી વધારે છે, સર્વોને એક સમયે એક ડિગ્રી ખસેડે છે. બીજો લૂપ વિરુદ્ધ કરે છે, pos ને 180 થી પાછું 0 સુધી ઘટાડે છે. નિર્ણાયક ભાગ દરેક લૂપ પુનરાવૃત્તિના અંતે delay(15) છે. આ વિરામ સર્વોને આગલો આદેશ મોકલતા પહેલા નવી સ્થિતિમાં શારીરિક રીતે ખસેડવા માટે પૂરતો સમય આપે છે. આ વિલંબ વિના, સર્વો ગતિ જાળવી શકશે નહીં અને અટકી જશે અથવા ધ્રૂજશે (વિડિયોમાં 12:31 પર).

આ ઉદાહરણ શીખવા માટે યોગ્ય છે, પરંતુ વાસ્તવિક એપ્લિકેશનમાં, તમે સંભવતઃ સર્વોને ચોક્કસ ખૂણા પર સેટ કરવા માંગો છો. વિડિયોમાં બતાવ્યા મુજબ, તમે for લૂપ્સને myservo.write(90) જેવા એક આદેશ સાથે બદલીને કોડમાં ફેરફાર કરી શકો છો જેથી સર્વોને 90 ડિગ્રી પર ખસેડી શકાય અને તેને ત્યાં પકડી શકાય (વિડિયોમાં 10:09 પર).

પ્રોગ્રામ 2: સર્વો મોટરને નિયંત્રિત કરવું (નોબ)

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

આ પ્રોગ્રામ અગાઉના પ્રોગ્રામ પર પોટેન્શિયોમીટર ઉમેરીને આગળ વધે છે. પોટેન્શિયોમીટર એ એક ચલ રેઝિસ્ટર છે જે એનાલોગ વોલ્ટેજ ડિવાઈડર તરીકે કાર્ય કરે છે. જ્યારે તમે નોબ ફેરવો છો, ત્યારે તે તેના આઉટપુટ પિન પર વોલ્ટેજ બદલે છે. આર્ડુઈનો તેના એનાલોગ પિનમાંથી એક પર એનાલોગ-ટુ-ડિજિટલ કન્વર્ટર (ADC) નો ઉપયોગ કરીને આ વોલ્ટેજ વાંચે છે, અને તેને 0 થી 1023 ની વચ્ચેના મૂલ્યમાં રૂપાંતરિત કરે છે.

આ પ્રોગ્રામની ચાવી એ map() ફંક્શન છે. આ ફંક્શન સંખ્યાને એક શ્રેણીમાંથી બીજી શ્રેણીમાં સ્કેલ કરે છે. આ કિસ્સામાં, તેનો ઉપયોગ પોટેન્શિયોમીટરના કાચા મૂલ્ય (0 થી 1023) ને સર્વો માટે યોગ્ય મૂલ્ય (0 થી 180 ડિગ્રી) માં ભાષાંતર કરવા માટે થાય છે. કોડ analogRead(potpin) સાથે પોટેન્શિયોમીટરનું મૂલ્ય વાંચે છે, map(val, 0, 1023, 0, 180) નો ઉપયોગ કરીને તેને સ્કેલ કરે છે, અને પછી તે સ્કેલ કરેલ મૂલ્યને myservo.write(val) સાથે સર્વોને મોકલે છે. આ એક સીધો સંબંધ બનાવે છે જ્યાં નોબને તેના મધ્યબિંદુ પર ફેરવવાથી સર્વો 90 ડિગ્રી પર સ્થિત થશે, અને તેમ આગળ.

નિયંત્રણની આ પદ્ધતિ અત્યંત સાહજિક છે અને તે ઘણા માનવ-મશીન ઈન્ટરફેસો માટે પાયો છે, સરળ રિમોટ કંટ્રોલથી લઈને જટિલ રોબોટિક કંટ્રોલર્સ સુધી.

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

વિડિયો બંને પ્રોગ્રામનું લાઈવ પ્રદર્શન પૂરું પાડે છે. સ્વીપ પ્રોગ્રામ માટે, તમે સર્વો આર્મને 0 થી 180 ડિગ્રી અને પાછળ સરળતાથી ફરતું જોઈ શકો છો. પ્રસ્તુતકર્તા એ પણ બતાવે છે કે for લૂપમાં સ્ટેપ સાઈઝ (દા.ત., 1 ડિગ્રીથી 20 ડિગ્રી સુધી) અને વિલંબ સમયને સમાયોજિત કરવાથી સર્વોની વર્તણૂક કેવી રીતે બદલાય છે, જે ગતિને ઝડપી પરંતુ ઓછી સરળ બનાવે છે (વિડિયોમાં 11:19 પર).

નોબ પ્રોગ્રામ માટે, પ્રદર્શન બતાવે છે કે પોટેન્શિયોમીટરને ફેરવવાથી સર્વોની સ્થિતિ રીઅલ-ટાઇમમાં સીધી રીતે કેવી રીતે નિયંત્રિત થાય છે. આ દ્રશ્ય પ્રતિસાદ એનાલોગ ઇનપુટ અને ભૌતિક આઉટપુટ વચ્ચેના સંબંધને સમજવા માટે ઉત્તમ છે.

પ્રકરણો

• [00:00] સર્વો મોટર્સનો પરિચય
• [01:07] સર્વો મોટર્સના ઉપયોગો
• [02:57] સર્વો મોટરની રચના
• [04:48] સર્વોને આર્ડુઈનો સાથે જોડવું
• [06:06] સ્વીપ ઉદાહરણ કોડની શોધખોળ
• [09:21] સ્વીપ પ્રોગ્રામનું પ્રદર્શન
• [10:04] કસ્ટમ સર્વો કોણ સેટ કરવું
• [11:19] સ્વીપ ઝડપ અને સ્ટેપ સાઈઝમાં ફેરફાર
• [13:15] બીજા સર્વો મોટરનું ઉદાહરણ

છબીઓ

SG90_servo_motor-1

SG90 servo

Servo-pot_wiring

Servo-wiring_bb

SG90_servo_motor-1

SG90 servo

Servo-pot_wiring

Servo-wiring_bb

/*
Lesson 18/31: Controlling servo motor (sweep)
Get this code and watch video Download and resource page https://robojax.com/RJT601
YouTube video https://www.youtube.com/watch?v=KAt1WUWpHLQ
 
  
 * 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 download 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 pos = 0;    // variable to store the servo position

void setup() {
  myservo.attach(9);  // attaches the servo on pin 9 to the Servo object
}

void loop() {
  for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
    // in steps of 1 degree
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15 ms for the servo to reach the position
  }
  for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15 ms for the servo to reach the position
  }
}

/*
Lesson 18/31: Controlling servo motor (knob)
Get this code and watch video Download and resource page https://robojax.com/RJT601
YouTube video https://www.youtube.com/watch?v=KAt1WUWpHLQ
 
  
 * 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 download 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

int potpin = 0;  // analog pin used to connect the potentiometer
int val;    // variable to read the value from the analog pin

void setup() {
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object
}

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
  delay(15);                           // waits for the servo to get there
}