પાઠ 27/31: કાર-5 SunFounder સ્માર્ટ કાર તમારા હાથને અનુસરે છે Arduino નો ઉપયોગ કરીને | Robojax

પાઠ 27/31: કાર-5 SunFounder સ્માર્ટ કાર તમારા હાથને અનુસરે છે Arduino નો ઉપયોગ કરીને | Robojax

પરિચય

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

આ પ્રોજેક્ટ Robojax Arduino કોર્સ (પાઠ 27/31) નો ભાગ છે અને SunFounder 3-ઇન-1 Arduino કિટનો ઉપયોગ કરીને બનાવવામાં આવ્યો છે. સેન્સર ફ્યુઝન વિશે શીખવાની આ એક ઉત્તમ રીત છે, જ્યાં બહુવિધ સેન્સર મળીને વધુ જટિલ અને પ્રતિભાવશીલ વર્તન બનાવે છે. અહીં વાસ્તવિક દુનિયાનું મૂલ્ય એ સમજવામાં છે કે નિર્ણયો લેવા માટે વિવિધ પ્રકારના ઇનપુટ્સ કેવી રીતે જોડવા, જે રોબોટિક્સ અને ઓટોમેશનમાં મૂળભૂત ખ્યાલ છે.

અહીં કેટલાક વ્યવહારુ વિચારો છે જે તમે આ તર્ક પર આધારિત બનાવી શકો છો:

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

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

આ પ્રોજેક્ટ SunFounder 3-ઇન-1 Arduino કિટમાં સમાવિષ્ટ ઘટકોનો ઉપયોગ કરે છે. તમે ઉપયોગ કરશો તે મુખ્ય ઘટકો છે:

• SunFounder સ્માર્ટ કાર ચેસિસ: પૈડાં અને મોટર્સ સાથેનું ભૌતિક પ્લેટફોર્મ.
• Arduino બોર્ડ: કારનું "મગજ" જે કોડ ચલાવે છે.
• અલ્ટ્રાસોનિક સેન્સર (HC-SR04): કારની સામે કોઈ વસ્તુ (તમારા હાથ) સુધીનું અંતર માપવા માટે વપરાય છે.
• બે IR (ઇન્ફ્રારેડ) અવરોધ ટાળવાના સેન્સર: ડાબી અને જમણી બાજુએ માઉન્ટ કરેલા છે જેથી તે બાજુઓ પર તમારા હાથની હાજરી શોધી શકાય.
• મોટર ડ્રાઇવર: એક મોડ્યુલ (ઘણીવાર L298N અથવા સમાન) જે Arduino તરફથી સિગ્નલોના આધારે કારની મોટર્સની ગતિ અને દિશા નિયંત્રિત કરવા માટે વપરાય છે.
• પાવર સ્ત્રોત: Arduino અને મોટર્સને પાવર આપવા માટે બેટરીઓ.

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

વિડિયોમાં ઉલ્લેખ કર્યા મુજબ, આ પ્રોજેક્ટ માટે વાયરિંગ અગાઉના પાઠોમાં અવરોધ-ટાળતી કાર માટે સમજાવ્યા મુજબ સમાન છે. સેન્સર અને મોટર્સ બધા Arduino ના ડિજિટલ અને એનાલોગ પિન સાથે જોડાયેલા છે. દ્રશ્ય સંદર્ભ માટે, કૃપા કરીને SunFounder સ્માર્ટ કાર માટે વાયરિંગ ડાયાગ્રામનો સંદર્ભ લો.

કોડ દરેક ઘટક માટે વપરાતા ચોક્કસ પિન વ્યાખ્યાયિત કરે છે, જે આગલા વિભાગમાં વિગતવાર છે.

કોડ સમજૂતી

આ વિભાગ કોડના વપરાશકર્તા-રૂપરેખાંકિત ભાગો પર ધ્યાન કેન્દ્રિત કરે છે જે તમે તમારી પોતાની કાર માટે ગોઠવવા માંગો છો. સંપૂર્ણ પ્રોગ્રામ Robojax સંસાધન પૃષ્ઠ પર ડાઉનલોડ માટે ઉપલબ્ધ છે.

સ્કેચની ખૂબ જ ટોચ પર, તમને પિન વ્યાખ્યાઓ મળશે. જો તમે તમારી કારને પ્રશિક્ષક કરતાં અલગ રીતે વાયર કરી હોય તો આ સમજવા માટેની સૌથી મહત્વપૂર્ણ રેખાઓ છે.

const int A_1B = 5;
const int A_1A = 6;
const int B_1B = 9;
const int B_1A = 10;

const int rightIR=7;
const int leftIR=8;

const int trigPin = 3;
const int echoPin = 4;

અહીં દરેક પિન જૂથ શું કરે છે:

• મોટર પિન (A_1A, A_1B, B_1A, B_1B): આ બે મોટર્સને નિયંત્રિત કરવા માટે મોટર ડ્રાઇવર સાથે જોડાયેલા પિન છે. "A" અને "B" લેબલ સામાન્ય રીતે અનુક્રમે ડાબી અને જમણી મોટર્સનો સંદર્ભ આપે છે. જો તમારો મોટર ડ્રાઇવર અલગ Arduino પિન સાથે જોડાયેલો હોય તો તમારે આ બદલવું આવશ્યક છે.
• IR સેન્સર પિન (rightIR, leftIR): આ ડિજિટલ ઇનપુટ પિન ડાબા અને જમણા ઇન્ફ્રારેડ અવરોધ સેન્સરમાંથી સિગ્નલ વાંચે છે. 0 નું મૂલ્ય એટલે અવરોધ (તમારો હાથ) શોધાયો છે, જ્યારે 1 એટલે માર્ગ સ્પષ્ટ છે.
• અલ્ટ્રાસોનિક સેન્સર પિન (trigPin, echoPin): trigPin એ આઉટપુટ છે જે ટૂંકી અલ્ટ્રાસોનિક પલ્સ મોકલે છે, અને echoPin એ ઇનપુટ છે જે અંતરની ગણતરી કરવા માટે પ્રતિબિંબિત પલ્સની અવધિ વાંચે છે.

loop() ફંક્શનની અંદર, તમને મુખ્ય વર્તન તર્ક મળશે. એક એકલ ચલ છે જે તમે ગોઠવવા માંગો છો:

int speed = 150;

આ speed ચલ હલનચલન દરમિયાન મોટર્સને મોકલવામાં આવતી શક્તિને નિયંત્રિત કરે છે. તે 0 (અટકેલું) થી 255 (મહત્તમ ગતિ) સુધી હોઈ શકે છે. તમે ઝડપી કાર માટે આ મૂલ્ય વધારી શકો છો (દા.ત., 200 સુધી) અથવા વધુ નિયંત્રિત, ધીમી હલનચલન માટે ઘટાડી શકો છો (દા.ત., 100 સુધી).

કોડમાં moveForward(), turnLeft(), અને turnRight() જેવા ફંક્શન પણ શામેલ છે. આ ફંક્શન કારની હિલચાલને નિયંત્રિત કરવા માટે વપરાય છે અને સેન્સર રીડિંગ્સના આધારે કહેવામાં આવે છે. તમારે તેમને સંશોધિત કરવાની જરૂર નથી, પરંતુ તમે તમારા પોતાના કસ્ટમ વર્તન બનાવવા માટે તેમને બિલ્ડિંગ બ્લોક્સ તરીકે ઉપયોગ કરી શકો છો.

"તમારા હાથને અનુસરો" તર્ક કેવી રીતે કાર્ય કરે છે

આ પ્રોજેક્ટની જાદુઈ વાત એ છે કે Arduino ત્રણ સેન્સરમાંથી મળતા ડેટાને કેવી રીતે સમજે છે. આ તર્ક સરળ છે અને loop() ફંક્શનમાં સતત ચાલુ રહે છે.

પ્રથમ, કાર અલ્ટ્રાસોનિક સેન્સરનો ઉપયોગ કરીને તેની સામે સીધા રહેલા પદાર્થનું અંતર માપે છે. પછી, તે બે ઇન્ફ્રારેડ સેન્સર તપાસે છે કે તેની ડાબી કે જમણી બાજુ કોઈ પદાર્થ છે કે નહીં. નિર્ણય લેવાની પ્રક્રિયા નીચે મુજબ છે:

1. આગળ વધો: જો અલ્ટ્રાસોનિક સેન્સર દ્વારા માપેલું અંતર 5 સેમી કરતાં વધુ પરંતુ 10 સેમી કરતાં ઓછું હોય, તો કાર આગળ વધે છે. આ એક "સ્વીટ સ્પોટ" ઝોન બનાવે છે જ્યાં કાર તમારા હાથને અનુસરશે.
2. ડાબે વળો: જો અંતર તે ઝોનમાં ન હોય, તો કાર IR સેન્સર તપાસે છે. જો ડાબો સેન્સર અવરોધિત હોય (તમારો હાથ ડાબી બાજુ હોય) અને જમણો સેન્સર સ્પષ્ટ હોય, તો કાર ડાબે વળે છે.
3. જમણે વળો: તેનાથી વિપરીત, જો જમણો સેન્સર અવરોધિત હોય અને ડાબો સ્પષ્ટ હોય, તો કાર જમણે વળે છે.
4. અટકો: જો આમાંની કોઈ પણ સ્થિતિ પૂરી ન થાય—ઉદાહરણ તરીકે, જો તમારો હાથ ખૂબ દૂર હોય અથવા ખૂબ નજીક હોય—તો કાર અટકી જાય છે.

નિયમોનો આ સરળ સમૂહ કારને તમારા હાથની સ્થિતિ પ્રત્યે ગતિશીલ રીતે પ્રતિક્રિયા આપવા દે છે, જે સરળ અને સાહજિક અનુસરણ વર્તન બનાવે છે.

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

વિડિયો પ્રદર્શનમાં, પ્રશિક્ષક કારના વર્તનને રીઅલ-ટાઇમમાં બતાવે છે. સીરિયલ મોનિટરનો ઉપયોગ અલ્ટ્રાસોનિક સેન્સર દ્વારા વાંચેલું અંતર દર્શાવવા માટે થાય છે. જ્યારે કાર નિષ્ક્રિય હોય અને તમારો હાથ દૂર હોય (દા.ત., 36 સેમી), ત્યારે તે અટકેલી રહે છે. જલદી તમે તમારો હાથ કારની સામે 5-10 સેમીના ઝોનમાં મૂકો છો, તે આગળ વધવાનું શરૂ કરે છે.

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

પ્રકરણો

• [00:00] હાથ-અનુસરતી સ્માર્ટ કારનો પરિચય
• [00:35] રોબોજેક્સ Arduino કોર્સ અને કિટ વિશે
• [01:41] પ્રોજેક્ટ ઝાંખી અને કોડ સેટઅપ
• [02:19] પિન વ્યાખ્યાઓ અને સેટઅપની સમજૂતી
• [03:19] તમારા હાથને અનુસરવા માટેનો કોડ તર્ક
• [05:48] કારનું લાઇવ પ્રદર્શન
• [07:28] અંતિમ પ્રદર્શન અને કામગીરી સમીક્ષા

છબીઓ

Car 7 8 follow hand

27 SunFounder Car 5 follow hand

Car 7 8 follow hand

27 SunFounder Car 5 follow hand

/*
Lesson 27/31: Car-5 SunFounder Smart Car Follows Your Hand
Get this code and watch video Download and resource page https://robojax.com/RJT610
YouTube video https://www.youtube.com/watch?v=mcbJlE7-8ro

*/
const int A_1B = 5;
const int A_1A = 6;
const int B_1B = 9;
const int B_1A = 10;

const int rightIR=7;
const int leftIR=8;

const int trigPin = 3;
const int echoPin = 4;

void setup() {
  Serial.begin(9600);

  //motor
  pinMode(A_1B, OUTPUT);
  pinMode(A_1A, OUTPUT);
  pinMode(B_1B, OUTPUT);
  pinMode(B_1A, OUTPUT);

  //IR obstacle
  pinMode(leftIR,INPUT);
  pinMode(rightIR,INPUT);
  
  //ultrasonic
  pinMode(echoPin, INPUT);
  pinMode(trigPin, OUTPUT);
}

void loop() {

  float distance = readSensorData();

  int left = digitalRead(leftIR);  // 0: Obstructed   1: Empty
  int right = digitalRead(rightIR);
  int speed = 150;

  if (distance>5 && distance<10){
    moveForward(speed);
  }else if(!left&&right){
    turnLeft(speed);
  }else if(left&&!right){
    turnRight(speed);
  }else{
    stopMove();
  }
}

float readSensorData() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  float distance = pulseIn(echoPin, HIGH) / 58.00; //Equivalent to (340m/s*1us)/2
  return distance;
}

void moveForward(int speed) {
  analogWrite(A_1B, 0);
  analogWrite(A_1A, speed);
  analogWrite(B_1B, speed);
  analogWrite(B_1A, 0);
}

void moveBackward(int speed) {
  analogWrite(A_1B, speed);
  analogWrite(A_1A, 0);
  analogWrite(B_1B, 0);
  analogWrite(B_1A, speed);
}

void turnRight(int speed) {
  analogWrite(A_1B, speed);
  analogWrite(A_1A, 0);
  analogWrite(B_1B, speed);
  analogWrite(B_1A, 0);
}

void turnLeft(int speed) {
  analogWrite(A_1B, 0);
  analogWrite(A_1A, speed);
  analogWrite(B_1B, 0);
  analogWrite(B_1A, speed);
}

void stopMove() {
  analogWrite(A_1B, 0);
  analogWrite(A_1A, 0);
  analogWrite(B_1B, 0);
  analogWrite(B_1A, 0);
}