பாடம் 25/31: கார்-3 ஸ்மார்ட் கார் அகச்சிவப்பு சென்சார்களைப் பயன்படுத்தி தடையைத் தவிர்க்கிறது | SunFounder Robojax

பாடம் 25/31: கார்-3 ஸ்மார்ட் கார் அகச்சிவப்பு சென்சார்களைப் பயன்படுத்தி தடையைத் தவிர்க்கிறது | SunFounder Robojax

இந்தத் திட்டம் உங்கள் SunFounder 3-in-1 Arduino ஸ்மார்ட் காரை தானியங்கி தடை-தவிர்ப்பு வாகனமாக மாற்றுகிறது. இரண்டு அகச்சிவப்பு (IR) சென்சார்களை பொருத்துவதன் மூலம்—ஒன்று இடதுபுறமும் ஒன்று வலதுபுறமும்—கார் அதன் பாதையில் உள்ள பொருட்களைக் கண்டறிந்து, அவற்றைச் சுற்றி செல்ல உடனடி முடிவுகளை எடுக்க முடியும். இது ரோபாட்டிக்ஸில் ஒரு அடிப்படை படியாகும், சென்சார் உள்ளீட்டை மோட்டார் கட்டுப்பாட்டு தர்க்கத்துடன் இணைத்து எதிர்வினை செய்யும், தானாக இயங்கும் இயந்திரத்தை உருவாக்குவதை உங்களுக்குக் கற்பிக்கிறது. இங்கே நீங்கள் கற்கும் கொள்கைகள் பரந்த அளவிலான நிஜ-உலக பயன்பாடுகளுக்கு பொருந்தும், அவற்றுள்:

• ரோபோடிக் வெற்றிட கிளீனரை உருவாக்குதல் இது தளபாடங்களில் மோதாமல் அறையில் செல்லவல்லது.
• கோடு-பின்தொடரும் அல்லது புதிர்-தீர்க்கும் ரோபோவை உருவாக்குதல் போட்டிகள் அல்லது கல்வித் திட்டங்களுக்காக.
• தானியங்கி பாதுகாப்பு ரோந்து போட்டை உருவாக்குதல் இது சுற்றளவை சுற்றி வந்து சுவர்களைத் தவிர்க்கும்.
• ஸ்மார்ட் பொம்மை காரை வடிவமைத்தல் இது சிக்கிக்கொள்ளாமல் சுயாதீனமாக விளையாடக்கூடியது.

இந்த வழிகாட்டி முந்தைய பாடங்களில் நீங்கள் காரின் மோட்டார்களைக் கட்டுப்படுத்தவும் IR சென்சார்கள் எவ்வாறு செயல்படுகின்றன என்பதைப் புரிந்துகொள்ளவும் கற்றுக்கொண்டதன் அடிப்படையில் நேரடியாக உருவாக்கப்பட்டுள்ளது. இங்கே, எளிய ஆனால் பயனுள்ள தடை-தவிர்ப்பு அல்காரிதத்தை செயல்படுத்த அந்த திறன்களை இணைப்போம்.

தடை தவிர்ப்பு தர்க்கம் எவ்வாறு செயல்படுகிறது

முக்கிய யோசனை எளிதானது: கார் அதன் இடது மற்றும் வலது பக்கங்களில் உள்ள தடைகளை சரிபார்க்க இரண்டு IR சென்சார்களைப் பயன்படுத்துகிறது. ஒவ்வொரு சென்சாரும் ஒரு டிஜிட்டல் சிக்னலை வெளியிடுகிறது: அது அதன் வரம்பிற்குள் (சுமார் 20 செ.மீ) ஒரு பொருளைக் கண்டறியும்போது LOW (0) மற்றும் பாதை தெளிவாக இருக்கும்போது HIGH (1). பின்னர் தர்க்கம் சென்சார் நிலைகளின் அடிப்படையில் காரின் செயலை தீர்மானிக்கிறது (வீடியோவில் 02:35 இல்):

• இடதுபுறம் தடை, வலதுபுறம் தெளிவு: கார் அதைத் தவிர்க்க வலதுபுறம் திரும்புகிறது.
• வலதுபுறம் தடை, இடதுபுறம் தெளிவு: கார் இடதுபுறம் திரும்புகிறது.
• இருபுறமும் தடைகள்: சாத்தியமான முட்டுச்சந்தில் இருந்து தப்பிக்க கார் பின்னோக்கி நகர்கிறது.
• தடைகள் இல்லை: கார் முன்னோக்கி செல்கிறது.

இந்த எதிர்வினை அணுகுமுறை ஒரு வரையறுக்கப்பட்ட-நிலை இயந்திரத்தின் சிறந்த எடுத்துக்காட்டு, இதில் காரின் நடத்தை அதன் தற்போதைய சென்சார் உள்ளீடுகளுக்கு நேரடி பதிலாகும்.

வன்பொருள் கூறுகள்

இந்த திட்டத்தை முடிக்க, உங்களுக்கு பின்வரும் கூறுகள் தேவைப்படும், இவை அனைத்தும் SunFounder 3-in-1 Arduino கிட்டில் சேர்க்கப்பட்டுள்ளன:

• 1x SunFounder 3-in-1 Arduino ஸ்மார்ட் கார் கிட் (அல்லது சமமான பாகங்கள்)
• 2x அகச்சிவப்பு தடை தவிர்ப்பு சென்சார்கள்
• 1x Arduino Uno (அல்லது இணக்கமான போர்டு)
• 1x மோட்டார் டிரைவர் ஷீல்டு/போர்டு
• ஜம்பர் கம்பிகள்

வயரிங் வழிகாட்டி

இந்த திட்டம் வேலை செய்ய சரியான சென்சார் சீரமைப்பு முக்கியமானது. IR சென்சார்கள் முன்னோக்கி மற்றும் சற்று வெளிப்புறமாக எதிர்கொள்ளும் வகையில் சீரமைக்கப்பட வேண்டும், ஏனெனில் அவை காரின் பக்கங்களில் உள்ள தடைகளைக் கண்டறியும் (வீடியோவில் 02:07 இல்). பின்வரும் வயரிங் வரைபடம் சென்சார்களை Arduino உடன் எவ்வாறு இணைப்பது என்பதைக் காட்டுகிறது. பயிற்றுவிப்பாளர் காரின் பிரெட்போர்டில் ஒரு குறிப்பிட்ட மின் விநியோக புள்ளியைப் பயன்படுத்தினார் என்பதை நினைவில் கொள்ளவும், ஆனால் Arduino க்கான இணைப்புகளே முக்கியம்.

வயரிங் இணைப்புகள் பின்வருமாறு (வீடியோவில் 03:47 இல்):

• மின்சாரம் (VCC): இரண்டு IR சென்சார்களின் VCC பின்னையும் Arduino இன் 5V வெளியீடு அல்லது காரின் மின் ரெயிலுடன் இணைக்கவும்.
• தரை (GND): இரண்டு IR சென்சார்களின் GND பின்னையும் Arduino இன் பொதுவான தரை அல்லது காரின் தரை ரெயிலுடன் இணைக்கவும்.
• வலது சென்சார் வெளியீடு (OUT): வலது IR சென்சாரின் டிஜிட்டல் வெளியீடு பின்னை Arduino இன் டிஜிட்டல் பின் 7 உடன் இணைக்கவும்.
• இடது சென்சார் வெளியீடு (OUT): இடது IR சென்சாரின் டிஜிட்டல் வெளியீடு பின்னை Arduino இன் டிஜிட்டல் பின் 8 உடன் இணைக்கவும்.

இடது மற்றும் வலது மோட்டார்களுக்கான மோட்டார் டிரைவர் இணைப்புகள் மோட்டார் கட்டுப்பாடு குறித்த முந்தைய பாடத்தில் நிறுவப்பட்டதைப் போலவே இருக்கும்.

குறியீடு விளக்கம்

இந்த திட்டத்திற்கான குறியீடு நேரடியானது. முக்கிய நிரல் கட்டுரைக்கு கீழே பதிவிறக்கத்திற்கு கிடைக்கிறது. இங்கே, உங்கள் சொந்த காருக்காக நீங்கள் சரிசெய்யக்கூடிய பயனர்-கட்டமைக்கக்கூடிய பகுதிகளில் கவனம் செலுத்துவோம்.

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;

இந்த வரிகள் மோட்டார் டிரைவர் மற்றும் IR சென்சார்களுக்கு பயன்படுத்தப்படும் பின்களை வரையறுக்கின்றன. மோட்டார் பின்கள் (A_1B, A_1A, B_1B, B_1A) இரண்டு மோட்டார்களின் வேகம் மற்றும் திசையைக் கட்டுப்படுத்துகின்றன. rightIR மற்றும் leftIR பின்கள் உங்கள் சென்சார்களில் இருந்து சிக்னல் கம்பிகளை இணைக்கும் இடங்கள். நீங்கள் வேறு பின்களைப் பயன்படுத்தினால், இந்த மதிப்புகளை இங்கே மாற்றுவீர்கள்.

int speed = 150;

இந்த மாறி காருக்கான அடிப்படை வேகத்தை அமைக்கிறது. மதிப்பு 0 முதல் 255 வரை இருக்கலாம், இதில் 255 அதிகபட்ச வேகம். கற்றலுக்கு 150 ஒரு நல்ல தொடக்க புள்ளியாகும், ஏனெனில் இது போதுமான வேகமாக இருந்தாலும் எதிர்வினை நேரத்திற்கு அனுமதிக்கும் அளவுக்கு மெதுவாக உள்ளது (வீடியோவில் 07:10 இல்). உங்கள் காரை வேகமாக அல்லது மெதுவாக மாற்ற இதை சரிசெய்யலாம்.

மீதமுள்ள குறியீடு loop() செயல்பாட்டில் உள்ள தர்க்கத்தை வரையறுக்கிறது. இது இடது மற்றும் வலது சென்சார்களின் நிலையைப் படித்து, பின்னர் பொருத்தமான இயக்க செயல்பாட்டை (moveForward(), moveBackward(), backLeft(), backRight()) அழைக்கிறது. இந்த செயல்பாடுகள் முன் வரையறுக்கப்பட்டவை மற்றும் விரும்பிய இயக்கத்தை அடைய மோட்டார் டிரைவரைக் கட்டுப்படுத்துகின்றன. பயிற்றுவிப்பாளர் பின்னர் ஒரு மாற்றத்தில் stop() செயல்பாட்டையும் சேர்த்தார், இது தவிர்ப்பு சூழ்ச்சிக்குப் பிறகு காரை சிறிது நேரம் நிறுத்தி, அதன் இயக்கங்களை மேலும் திட்டமிட்டதாக ஆக்குகிறது (வீடியோவில் 10:29).

நேரடி திட்ட ஆர்ப்பாட்டம்

வீடியோவில், பயிற்றுவிப்பாளர் முதலில் சீரியல் மானிட்டரைப் பயன்படுத்தி தர்க்கத்தை நிரூபிக்கிறார். சென்சார்களுக்கு அருகில் ஒரு பெட்டியை வைப்பதன் மூலம், "Go Left", "Go Right", அல்லது "Go Backward" போன்ற தொடர்புடைய செய்திகள் திரையில் தோன்றுவதைக் காணலாம், இது சென்சார் அளவீடுகள் மற்றும் தர்க்கம் சரியானவை என்பதை உறுதிப்படுத்துகிறது (வீடியோவில் 09:11).

தர்க்கத்தை சரிபார்த்த பிறகு, பயிற்றுவிப்பாளர் ஒரு முக்கியமான மேம்பாட்டைச் சேர்க்கிறார்: ஒரு stop() செயல்பாடு. இந்த செயல்பாடு கார் ஒரு திருப்பம் அல்லது பின்னோக்கி இயக்கத்தைச் செய்த பிறகு, ஒரு குறிப்பிட்ட காலத்திற்கு (எ.கா., 1 வினாடி) முழுமையாக நிறுத்துகிறது, இது திடீர் இயக்கங்களைத் தடுக்கிறது மற்றும் கார் அதன் சுற்றுப்புறங்களை மீண்டும் மதிப்பீடு செய்ய அனுமதிக்கிறது (வீடியோவில் 10:29).

இறுதியாக, கார் தரையில் தொடர்ச்சியான தடைகளுடன் சோதிக்கப்படுகிறது. வீடியோ கார் வெற்றிகரமாக பெட்டிகளைச் சுற்றி செல்வதை, இடது, வலது திருப்புவதை, மற்றும் தேவைக்கேற்ப பின்னோக்கி செல்வதைக் காட்டுகிறது, இது தெளிவான பாதையைக் கண்டறிய உதவுகிறது, இந்த தடை-தவிர்ப்பு வழிமுறையின் நிஜ உலக பயன்பாட்டை நிரூபிக்கிறது (வீடியோவில் 12:13).

அத்தியாயங்கள்

• [00:00] IR சென்சார்களுடன் தடை தவிர்ப்பு அறிமுகம்
• [01:24] முன்நிபந்தனைகள் மற்றும் திட்ட கண்ணோட்டம்
• [02:35] தடை தவிர்ப்பு தர்க்கம் எவ்வாறு செயல்படுகிறது
• [03:47] IR சென்சார்கள் மற்றும் மோட்டார்களை இணைத்தல்
• [05:40] குறியீட்டைத் திறந்து விளக்குதல்
• [09:11] சீரியல் மானிட்டருடன் தர்க்கத்தை சோதித்தல்
• [10:29] மென்மையான வழிசெலுத்தலுக்கு நிறுத்த செயல்பாட்டைச் சேர்த்தல்
• [11:42] நிறுத்த செயல்பாட்டை சோதித்தல்
• [12:13] தரையில் இறுதி நடைமுறை சோதனை

படங்கள்

Sunfounder smartcar obstacle avoidance 1

Sunfounder smartcar obstacle avoidance wiring

Sunfounder smartcar obstacle avoidance 1

Sunfounder smartcar obstacle avoidance wiring

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;

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);

}

void loop() {

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

  if (!left && right) {
    backLeft(speed);
  } else if (left && !right) {
    backRight(speed);
  } else if (!left && !right) {
    moveBackward(speed);
  } else {
    moveForward(speed);
  }
}

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 backLeft(int speed) {
  analogWrite(A_1B, speed);
  analogWrite(A_1A, 0);
  analogWrite(B_1B, 0);
  analogWrite(B_1A, 0);
}

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