- LM393 Speed Sensor Module (H206)
- Pag-aayos ng H206 Sensor Mounting
- DIY Arduino LM393 Speed Sensor Robot Circuit Diagram
- Logic sa likod ng Pagsukat ng Bilis na may module ng bilis ng sensor ng LM393
- Logic sa likod ng pagsukat ng distansya na nalakbay ng gulong
- Logic sa likod ng pagsukat ng anggulo ng bot
- Code ng Robot ng Arduino
- Pagsubok sa Arduino Robot para sa pagsukat ng Distansya, Bilis at Anggulo
Ang mga robot ay dahan-dahang nagsimulang gumapang sa aming lipunan upang gawing mas simple ang aming buhay. Mahahanap na natin ang anim na mga robot na naghahatid ng pagkain na may gulong mula sa Starship sa mga kalsada ng UK, matalinong pag-navigate sa mga sibilyan upang maabot ang patutunguhan nito. Ang bawat mobile robot na nagna-navigate sa kapaligiran ay dapat palaging magkaroon ng kamalayan sa posisyon at oryentasyon na ito na may paggalang sa totoong mundo. Mayroong maraming mga paraan upang makamit ito sa pamamagitan ng paggamit ng iba't ibang mga teknolohiya tulad ng GPS, RF Triangulation, Accelerometers, Gyroscope atbp Ang bawat diskarte ay may sariling kalamangan at natatangi nang mag-isa. Sa Arduino LM393 bilis ng tutorial na tutorial gagamitin namin ang simple at madaling magagamit na module ng bilis ng sensor ng LM393upang sukatin ang ilang mahahalagang parameter tulad ng Bilis, Distansya ng paglalakbay at Angle ng robot gamit ang Arduino. Sa mga parameter na ito malalaman ng robot ang tunay na katayuan sa mundo at magagamit ito upang ligtas na mag-navigate.
Ang Arduino ay ang pinakapopular na pagpipilian sa mga hobbyist para sa pagbuo ng mga robot, mula sa isang simpleng tagasunod sa linya hanggang sa isang mas kumplikadong self-balancing o robot sa paglilinis ng sahig. Maaari mong suriin ang lahat ng uri ng mga robot sa seksyon ng Robotics.
Bumubuo kami ng isang maliit na robot na pinapatakbo ng isang baterya ng lithium at ihahatid ito gamit ang isang joystick. Sa panahon ng runtime maaari naming sukatin ang bilis, distansya at anggulo ng robot at ipakita ito real-time sa LCD display na konektado sa Arduino. Tinutulungan ka lamang ng proyektong ito sa pagsukat ng mga parameter na ito, sa sandaling tapos ka na sa ito maaari mong gamitin ang mga parameter na ito upang mapatakbo ang iyong bot nang may pagsasarili kung kinakailangan. Tunog nakakainteres di ba? Kaya't magsimula tayo.
LM393 Speed Sensor Module (H206)
Bago kami makarating sa circuit diagram at code para sa proyekto, ipaalam sa amin na maunawaan ang Modyul ng sensor ng Bilis na LM393 dahil gumaganap ito ng mahalagang papel sa proyekto. Ang module ng H206 Speed sensor ay binubuo ng isang Infrared Light sensor na isinama sa isang LM393 Voltage comparator IC samakatuwid ang pangalang LM393 Speed sensor. Ang module ay binubuo rin ng isang plate plate na kailangang mai-mount sa umiikot na poste ng motor. Ang lahat ng mga bahagi ay may label sa larawan sa ibaba.
Ang sensor ng Infrared Light ay binubuo ng isang IR LED at isang photo-transistor na pinaghihiwalay ng isang maliit na gab. Ang buong pag-aayos ng sensor ay inilalagay sa isang itim na pabahay tulad ng ipinakita sa itaas. Ang Grid plate ay binubuo ng mga puwang, ang plato ay nakaayos sa pagitan ng puwang ng Infrared Light Sensor sa paraang maaaring maunawaan ng sensor ang mga puwang sa grid plate. Ang bawat puwang sa grid plate ay nagpapalitaw ng IR sensor kapag dumadaan sa puwang; ang mga pag-trigger na ito ay nai-convert sa mga signal ng boltahe gamit ang kumpare. Ang kumpare ay walang anuman kundi isang LM393 IC mula sa ON semiconductors. Ang module ay may tatlong mga pin, dalawa sa mga ito ay ginagamit upang paandarin ang module at isang output pin ang ginagamit upang mabilang ang bilang ng mga nag-trigger.
Pag-aayos ng H206 Sensor Mounting
Ang pag-mount ng mga ganitong uri ng sensor ay medyo mahirap. Maaari itong mai-mount lamang sa mga motor na mayroong baras na nakausli sa magkabilang panig. Ang isang gilid ng baras ay konektado sa gulong habang ang kabilang panig ay ginagamit upang mai-mount ang grid plate tulad ng ipinakita sa itaas.
Dahil ang gulong at plato ay konektado sa parehong baras parehong umiikot sa parehong bilis at sa gayon sa pamamagitan ng pagsukat ng bilis ng plato maaari naming sukatin ang bilis ng gulong. Siguraduhin na ang mga puwang sa grid plate ay dumaan sa IR sensor, pagkatapos lamang mabilang ng sensor ang bilang ng mga puwang na dumaan. Maaari ka ring magkaroon ng iyong sariling mekanikal na pag-aayos upang mai-mount ang sensor hangga't natutugunan nito ang tinukoy na kondisyon. Ang IR sensor ay karaniwang ginagamit sa maraming mga proyekto ng Robotics upang gabayan ang robot tungkol sa mga hadlang.
Ang grid plate na ipinakita sa itaas ay may 20 puwang (grids). Nangangahulugan ito na ang sensor ay makakahanap ng 20 mga puwang para sa isang kumpletong pag-ikot ng gulong. Sa pamamagitan ng pagbibilang ng bilang ng mga puwang nakita ng sensor maaari nating kalkulahin ang distansya na nilakbay ng gulong, katulad ng pagsukat kung gaano kabilis natagpuan ng sensor ang mga puwang na maaari nating makita ang bilis ng gulong. Sa aming robot magkakaroon kami ng sensor na ito na naka-mount sa parehong mga gulong at kaya mahahanap din natin ang anggulo ng robot. Gayunpaman ang anggulo ng pag-ikot ay maaaring mas may katuturan na kinakalkula gamit ang Accelerometer o Gyroscope, alamin dito upang i-interface ang Accelerometer at gyroscope kasama ang Arduino at subukang sukatin ang anggulong rotational gamit ang mga ito.
DIY Arduino LM393 Speed Sensor Robot Circuit Diagram
Ang kumpletong diagram ng circuit ng Robot ng bilis at distansya ng sensing na ito ay ipinapakita sa ibaba. Ang Bot ay binubuo ng Arduino Nano bilang utak nito, ang dalawang DC motor para sa mga gulong ay hinihimok ng module ng L298N H-Bridge Motor Driver. Ginagamit ang Joystick upang makontrol ang bilis at direksyon ng bot at ang dalawang sensor ng bilis na H206 ay ginagamit upang sukatin ang bilis, distansya at anghel ng bot. Ang mga sinusukat na halaga ay ipinapakita sa module na 16x2 LCD. Ang potensyomiter na konektado sa LCD ay maaaring magamit upang ayusin ang kaibahan ng LCD at ang risistor ay ginagamit upang limitahan ang kasalukuyang dumadaloy sa backlight ng LCD.
Ang kumpletong circuit ay pinalakas ng isang 7.4V Lithium cell. Ang 7.4V na ito ay ibinibigay sa 12V pin ng module ng Motor driver. Ang voltage regulator sa module ng driver ng motor pagkatapos ay nagko-convert ng 7.4V sa kinokontrol na + 5V na ginagamit upang paandarin ang Arduino, LCD, Sensors at Joystick.
Ang Motor ay kinokontrol ng mga digital na pin na 8,9,10 at 11 ng Arduino. Dahil ang bilis ng motor ay dapat ding kontrolin dapat nating ibigay ang mga signal ng PWM sa positibong terminal ng motor. Samakatuwid mayroon kaming pin 9 at 10 na parehong PWM na may kakayahang mga pin. Ang mga halagang X at Y ay bumubuo ng joystick ay binabasa gamit ang Analog pin A2 at A3 ayon sa pagkakabanggit.
Tulad ng alam natin ang H206 sensor na may bumuo ng isang gatilyo kapag ang puwang sa grid plate ay nakita. Dahil ang mga pag-trigger na ito ay hindi dapat laging basahin nang wasto upang makalkula ang tamang bilis at distansya ng parehong mga gatilyo (output) na mga pin ay konektado sa Panlabas na makagambala na pin 2 at 3 ng Arduino Board. Ipunin ang buong circuit sa isang chassis at i-mount ang speed sensor tulad ng ipinaliwanag, ang aking bot ay tumingin ng isang bagay tulad sa ibaba pagkatapos makumpleto ang mga koneksyon. Maaari mo ring panoorin ang video sa dulo ng pahinang ito upang malaman kung paano naka-mount ang sensor.
Ngayon na nakumpleto ang bahagi ng hardware ipaalam sa amin ang mga lohika kung paano namin susukatin ang bilis, distansya at solong ng bot at pagkatapos ay magpatuloy sa seksyon ng programa.
Logic sa likod ng Pagsukat ng Bilis na may module ng bilis ng sensor ng LM393
Mula sa pag-set up ng sensor na dapat mong magkaroon ng kamalayan na ang LM393 speed sensor module (H206) ay sumusukat lamang sa mga puwang na naroroon sa grid plate. Habang ang pag-mount dapat itong tiyakin na ang gulong (na ang bilis ay dapat masukat) at ang grid plate ay umiikot sa parehong bilis. Tulad dito, dahil na-mount namin ang parehong gulong at ang plato sa parehong baras ay pareho silang paikutin na may parehong bilis na malinaw.
Sa aming set-up na naka-mount kami ng dalawang sensor para sa bawat gulong upang masukat ang anggulo ng bot. Ngunit kung ang iyong hangarin ay upang masukat lamang ang bilis at distansya maaari naming mai-mount ang sensor sa anumang isang gulong. Ang output ng sensor (mga signal ng pag-trigger) ay magiging karaniwang konektado sa isang panlabas na nakakagambala na pin ng isang microcontroller. Sa tuwing ang puwang sa grid plate ay napansin ang isang nakakagambala ay magti-trigger at ang code sa ISR (Nakagagambala sa Karaniwang serbisyo) ay papatayin. Kung nakakalkula namin ang agwat ng oras sa pagitan ng dalawang tulad na pag-trigger maaari nating kalkulahin ang bilis ng gulong.
Sa Arduino madali nating makalkula ang agwat ng oras na ito sa pamamagitan ng paggamit ng millis () function. Ang paggana ng millis na ito ay panatilihin ang pagtaas ng 1 para sa bawat milli segundo mula sa oras ng pag-up ng aparato. Kaya't kapag nangyari ang unang pagkakagambala maaari nating mai-save ang halaga ng millis () sa isang variable ng dummy (tulad ng pevtime sa code na ito) at pagkatapos kapag nangyari ang pangalawang pagkagambala maaari nating kalkulahin ang oras na kinuha sa pamamagitan ng pagbawas sa pevtime na halaga na bumubuo ng millis ().
Kinuha ang oras = kasalukuyang oras - nakaraang oras na itinakda = millis () - pevtime ; // timetaken sa millisec
Sa sandaling nakalkula ang oras na ginugol maaari lamang naming kalkulahin ang halaga ng rpm gamit ang mga formula sa ibaba, kung saan (1000 / timetaken) ay nagbibigay sa RPS (Mga Pag-ikot bawat segundo) at pinarami ito ng 60 upang i-convert ang RPS sa RPM (Mga Rebolusyon bawat minuto).
rpm = (1000 / timetaken) * 60;
Matapos kalkulahin ang rpm maaari nating kalkulahin ang tulin ng sasakyan gamit ang mga formula sa ibaba na ibinigay alam namin ang radius ng gulong.
Bilis = 2π × RPS × radius ng gulong. v = radius_of_wheel * rpm * 0.104
Tandaan, ang pormula sa itaas ay para sa pagkalkula ng bilis sa m / s, kung nais mong kalkulahin sa km / hr pagkatapos palitan ang 0.0104 ng 0.376. Kung gusto mong malaman kung paano nakuha ang halagang 0.104 pagkatapos ay subukang gawing simple ang pormulang V = 2π × RPS × radius ng gulong.
Ang parehong pamamaraan ay ginagamit kahit na ang isang sensor ng hall ay ginagamit upang masukat ang bilis ng isang umiikot na bagay. Ngunit para sa H206 sensor mayroong isang catch, ang grid plate ay may 20 puwang at samakatuwid para sa pagsukat ng oras sa pagitan ng dalawang puwang ng puwang ay mag-o-overload ang microcontroller. Samakatuwid sinusukat namin ang bilis lamang sa isang buong pag-ikot ng isang gulong. Dahil ang dalawang mga pagkagambala ay mabubuo para sa bawat puwang (isa sa simula at iba pa sa dulo ng puwang) makakakuha kami ng isang kabuuang 40 pagkagambala para sa gulong upang makagawa ng isang kumpletong pag-ikot. Kaya't hinihintay namin ang 40 na nakakagambala bago namin talaga kalkulahin ang bilis ng gulong. Ang code para sa pareho ay ipinapakita sa ibaba
kung (pag-ikot> = 40) { timetaken = millis () - pevtime; // timetaken sa millisec rpm = (1000 / timetaken) * 60; // formula upang makalkula ang rpm pevtime = millis (); pag-ikot = 0; }
Ang isa pang sagabal sa pamamaraang ito ay iyon, ang halaga ng bilis ay hindi mahuhulog sa zero dahil ang pagkagambala ay palaging naghihintay para sa gulong upang makumpleto ang isang pag-ikot para sa pagkalkula ng halaga ng rpm. Ang sagabal na ito ay maaaring madaling mapagtagumpayan sa pamamagitan ng pagdaragdag ng isang simpleng code na sinusubaybayan ang agwat ng oras sa pagitan ng dalawang pagkagambala at kung lumagpas ito kaysa sa normal maaari naming pilitin ang halaga ng rpm at bilis na maging zero. Ang link sa code sa ibaba ay ginamit namin ang variable dtime upang suriin ang pagkakaiba sa oras at kung lumagpas ito sa 500 milli segundo ang halaga ng tulin at rpm ay pinilit na maging zero.
/ * Upang mahulog sa zero kung ang sasakyan ay tumigil * / kung (millis () - dtime> 500) // walang natagpuang aksidente para sa 500ms { rpm = v = 0; // make rpm and velocity as zero dtime = millis (); }
Logic sa likod ng pagsukat ng distansya na nalakbay ng gulong
Alam na natin na ang Arduino ay makakaramdam ng 40 nakakagambala kapag ang gulong ay gumawa ng isang kumpletong pag-ikot. Kaya't para sa bawat pag-ikot na ginawa ng gulong maliwanag na ang distansya na nilakbay ng gulong ay katumbas ng bilog ng gulong. Dahil alam na natin ang radius ng gulong madali naming makalkula ang distansya na sakop gamit ang formula sa ibaba
Distansya = 2πr * bilang ng distansya ng pag-ikot = (2 * 3.141 * radius_of_wheel) * (left_intr / 40)
Kung saan ang bilog ng gulong ay kinakalkula gamit ang pormula 2πr at pagkatapos ito ay pinarami ng bilang ng mga pag-ikot na ginawa ng gulong.
Logic sa likod ng pagsukat ng anggulo ng bot
Maraming mga paraan upang matukoy ang anghel ng robot. Karaniwang ginagamit ang mga Accelerometers at Gyroscope upang matukoy ang mga halagang ito. Ngunit ang isa pang murang diskarte ay ang paggamit ng H206 sensor sa magkabilang gulong. Sa ganitong paraan malalaman natin kung gaano karaming mga liko ang nagawa ng bawat gulong. Inilalarawan ng pigura sa ibaba kung paano kinakalkula ang anggulo.
Kapag ang robot ay napasimulan ang anggulo na kinakaharap nito ay isinasaalang-alang bilang 0 °. Mula doon ay umiikot ito sa kaliwa ang anggulo ay nadagdagan sa negatibo at kung ito ay umiikot nang tama ang anghel ay nadagdagan sa positibo. Para sa pag-unawa isaalang-alang natin ang saklaw ng -90 hanggang +90 tulad ng ipinakita sa pigura. Sa ganitong pag-aayos dahil ang parehong mga gulong ay pareho ang lapad, kung ang alinman sa gulong ay gumagawa ng isang kumpletong pag-ikot ng bot na lumiliko kami sa isang anggulo na 90 °.
Halimbawa kung ang Kaliwang gulong ay gumagawa ng isang kumpletong pag-ikot (80 nakakagambala) pagkatapos ay ang bot ay babalik sa 90 ° patungo sa kaliwa at katulad kung ang Kanan na gulong ay gumagawa ng isang kumpletong pag-ikot (80 nakakagambala) pagkatapos ang bot ay babalik -90 ° patungo sa kanan. Ngayon alam natin na kung ang Arduino ay nakakakita ng 80 nakakagambala sa isang gulong pagkatapos ang bot ay lumiko ng 90 ° at batay sa kung aling gulong maaari nating sabihin kung ang bot ay nakabukas ng positibo (kanan) o negatibo (kaliwa). Kaya't ang kaliwa at kanang anggulo ay maaaring kalkulahin gamit ang mga formula sa ibaba
int anggulo_left = (left_intr% 360) * (90/80); int anggulo_ kanan = (kanan_intr% 360) * (90/80);
Kung saan ang 90 ay sakop ang anggulo kapag gumagawa ng isang nakakagambala na 80. Ang nagresultang halaga ay pinaraming bilang na nakakagambala. Gumamit din kami ng isang modulus ng 360 upang ang nagresultang halaga ay hindi hihigit sa 36. Kapag nakalkula namin ang parehong kaliwa at kanang anggulo ang mabisang anggulo kung saan nakaharap ang bot ay maaaring makuha sa pamamagitan ng pagbawas sa kaliwang anggulo na bumuo ng tamang anggulo.
anggulo = anggulo_ kanan - anggulo_kaliwa;
Code ng Robot ng Arduino
Ang kumpletong Arduino code para sa bilis at pagsukat na robot na ito ay matatagpuan sa dulo ng pahinang ito. Ang layunin ng programa ay upang makalkula ang bilis, distansya at anggulo ng bot gamit ang mga lohika sa itaas at ipakita ito sa LCD screen. Bukod sa na dapat magbigay ito ng isang pagpipilian upang makontrol ang bot gamit ang Joystick.
Sinimulan namin ang programa sa pamamagitan ng pagtukoy sa mga Digital I / O na pin para sa dalawang motor. Tandaan na kailangan din nating makontrol ang bilis ng motor at samakatuwid kailangan nating gamitin ang mga PWM na pin sa Arduino upang makontrol ang mga motor. Ginamit namin dito ang pin na 8,9,10 at 11.
#define LM_pos 9 // left motor #define LM_neg 8 // left motor #define RM_pos 10 // right motor #define RM_neg 11 // right motor #define joyX A2 #define joyY A3
Upang sukatin ang bilis at takip ng distansya kailangan nating malaman ang radius ng gulong, sukatin ang halaga at ipasok ito sa metro tulad ng ipinakita sa ibaba. Para sa aking bot ang radius ay 0.033 metro ngunit maaaring magkakaiba ito para sa iyo batay sa iyong bot.
float radius_of_wheel = 0.033; // Sukatin ang radius ng iyong gulong at ipasok ito dito sa cm
Sa loob ng pag- andar ng pag- setup , sinisimulan namin ang lahat ng halaga na maging zero at pagkatapos ay ipakita ang isang Intro Text sa LCD. Nasimulan din namin ang serial monitor para sa layunin ng pag-debug. Pagkatapos ay nabanggit namin na ang mga sensor ng bilis ng H206 ay konektado sa pin 2 at 3 bilang mga panlabas na pagkagambala. Iyon ay kung saan kailanman ang nakakagambala ay napansin ang ISR function na Left_ISR at Right_ISR ay papatayin nang naaayon.
void setup () { rotation = rpm = pevtime = 0; // Initialize all variable to zero Serial.begin (9600); lcd.begin (16, 2); // Initialise 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro Message line 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Intro Message line 2 pagkaantala (2000); lcd.clear (); lcd.print ("Lt: Rt:"); lcd.setCursor (0, 1); lcd.print ("S: D: A:"); pinMode (LM_pos, OUTPUT); pinMode (LM_neg, OUTPUT); pinMode (RM_pos, OUTPUT); pinMode (RM_neg, OUTPUT); digitalWrite (LM_neg, LOW); digitalWrite (RM_neg, LOW); attachInterrupt (digitalPinToInterrupt (2), Left_ISR, CHANGE); // Left_ISR ay tinawag kapag ang left sensor ng sensor ay na-trigger na attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Ang Right_ISR ay tinawag kapag ang kanang sensor ng gulong ay na-trigger }
Sa loob ng gawain ng Left_ISR, nagpapadagdag lang kami ng isang variable na tinatawag na left_intr na magagamit sa paglaon sa pagsukat ng anggulo ng bot. Sa loob ng Kanan_ISR ginagawa namin ang parehong bagay ngunit pagkatapos ay Bukod pa rito kinakalkula din namin ang bilis dito. Ang variable na pag-ikot ay nadagdagan para sa bawat makagambala at pagkatapos ay ang lohika sa itaas ay ginagamit upang makalkula ang bilis.
walang bisa Left_ISR () { left_intr ++; antala (10); } i- void ang Right_ISR () { right_intr ++; antala (10); pag-ikot ++; dtime = millis (); kung (pag-ikot> = 40) { timetaken = millis () - pevtime; // timetaken sa millisec rpm = (1000 / timetaken) * 60; // formula upang makalkula ang rpm pevtime = millis (); pag-ikot = 0; } }
Sa loob ng pangunahing walang katapusang pagpapaandar ng loop sinusubaybayan namin ang mga halaga ng X at Y mula sa joystick. Batay sa halaga kung inilipat ang joystick kinokontrol namin ang bot nang naaayon. Ang bilis ng bot ay nakasalalay sa kung gaano kalayo ang natulak ang joystick.
int xValue = analogRead (joyX); int yValue = analogRead (joyY); int acceleration = mapa (xValue, 500, 0, 0, 200); kung (xValue <500) { analogWrite (LM_pos, acceleration); analogWrite (RM_pos, pagpabilis); } iba pa { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } kung (yValue> 550) analogWrite (RM_pos, 80); kung (yValue <500) analogWrite (LM_pos, 100);
Tutulungan nito ang gumagamit na ilipat ang bot at suriin kung ang mga halagang nakuha ay inaasahan. Panghuli maaari nating kalkulahin ang bilis, distansya at anggulo ng bot gamit ang mga lohika sa itaas at ipakita ito sa LCD gamit ang code sa ibaba.
v = radius_of_wheel * rpm * 0.104; Ang //0.033 ay ang radius ng gulong sa metro ang distansya = (2 * 3.141 * radius_of_wheel) * (left_intr / 40); int anggulo_left = (left_intr% 360) * (90/80); int anggulo_ kanan = (kanan_intr% 360) * (90/80); anggulo = anggulo_ kanan - anggulo_kaliwa; lcd.setCursor (3, 0); lcd.print (""); lcd.setCursor (3, 0); lcd.print (left_intr); lcd.setCursor (11, 0); lcd.print (""); lcd.setCursor (11, 0); lcd.print (right_intr); lcd.setCursor (2, 1); lcd.print (""); lcd.setCursor (2, 1); lcd.print (v); lcd.setCursor (9, 1); lcd.print (""); lcd.setCursor (9, 1); lcd.print (distansya); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (anggulo);
Pagsubok sa Arduino Robot para sa pagsukat ng Distansya, Bilis at Anggulo
Kapag handa na ang iyong hardware na i-upload ang code sa iyong Arduino at gamitin ang joystick upang ilipat ang iyong bot. ang bilis ng bot, distansya na sakop nito at ang anggulo ay ipapakita sa LCD tulad ng ipinakita sa ibaba.
Sa LCD ang term na Lt at Rt ay kumakatawan sa Left Interrupt Count at Right Interrupt count ayon sa pagkakabanggit. Maaari mong matagpuan ang mga halagang ito na nadagdagan para sa bawat puwang na nakita ng sensor. Ipinapahiwatig ng tem S ang Bilis ng bot sa m / sec at ang salitang D ay nagpapahiwatig ng Saklaw na sakop sa metro. Ang Angle ng bot ay ipinapakita sa dulo kung saan ang 0 ° ay para sa tuwid at negatibo ito para sa pag-ikot ng anti-clockwise at positibo para sa pag-ikot ng pakanan.
Maaari mo ring panoorin ang video sa dulo ng pahinang ito upang maunawaan kung paano gumagana ang bot. Inaasahan kong naintindihan mo ang proyekto at nasiyahan sa pagbuo nito. Kung mayroon kang anumang mga alalahanin iwan ang mga ito sa seksyon ng komento at susubukan ko sa pamamagitan ng pinakamahusay sa pagtugon pabalik. Maaari mo ring gamitin ang mga forum para sa mabilis na tulong panteknikal.