Naka-embed ang UCL - B0B ang Linefollower: 9 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:10

Ito ang B0B. *

Ang B0B ay isang pangkaraniwang kotse na Kinokontrol ng Radio, pansamantalang ihinahatid ang batayan ng isang sumusunod na linya ng robot.

Tulad ng maraming mga robot na sumusunod sa Linya bago siya, gagawin niya ang kanyang makakaya upang manatili sa isang linya na sanhi ng isang paglipat sa pagitan ng sahig at isang magkakaibang materyal, sa aming case duct tape.

Hindi tulad ng maraming iba pang mga robot na sumusunod sa Linya, nangangalap din ang B0B ng data at ipinapadala ito sa pamamagitan ng WiFi.

Ganap na labis na labis na labis para sa isang proyekto sa libangan, nagsasangkot ito ng isang bilang ng mga paksa na maaari mong makita na kawili-wili. Inilalarawan ng gabay na ito ang kanyang kapanganakan, kanyang mga pag-andar at kung paano mo magagawa ang isang katulad niya.

Nagsasangkot din ito ng pagiging galit sa iba't ibang mga electronics para sa hindi paggana tulad ng nais namin sa kanila, at ang mga hakbang na ginawa namin upang mapagtagumpayan ang mga paghihirap na iyon, (Tumingin ako sa iyo sa ESP 8266-01).

Mayroong 2 mga code upang gumana ang proyekto. Ang unang code ay para sa module na ESP8266 na ginagamit namin ang Arduino bilang isang programmer, at ang pangalawang code ay tatakbo sa Arduino.

Hakbang 1: Mga Bahagi

Para sa proyektong ito kakailanganin mo:

Hardware:

• 1x radio controller car, (dapat mayroong ESC at steering servo).

Gumagamit kami ng karamihan sa stock na Traxxas 1/16 E-Revo VXL, karamihan dahil iyon ang mayroon kami, at lubos na nagtitiwala na makokontrol namin ito sa isang Arduino. Dahil din sa pagtatapos nito ay nagdadala ng isang hindi gaanong halaga ng labis na hardware, tiwala kaming hindi ito magiging isyu para sa 1/16 E-Revo.

Gayunpaman, ang karamihan sa mga kotseng kinokontrol ng radyo (na maaaring madaling paghiwalayin) ay maaaring magamit sa halip, at ang proseso ay magkatulad.

• Isang tonelada ng duct tape.

Ang kulay ay dapat na ibahin ang sahig hangga't maaari. Sa aming kapaligiran sa pagsubok ginamit namin ang puting tape sa isang madilim na sahig.

• 1x Arduino Mega 2560.

Ang mas maliit na Arduino's ay marahil ayos din, ngunit mapindot ka para sa mga pin.

• 1x malaking board ng tinapay.

Ang isa ay sapat na, ngunit mayroon din kaming isang maliit na isa upang paghiwalayin ang iba pang mga linya ng kuryente ng boltahe upang mabawasan ang panganib ng error ng gumagamit.

• 1x TCRT5000 IR analog sensor (ginamit para sa pag-iwas sa banggaan).

Ang eksaktong tatak / modelo ay hindi mahalaga kung ito ay tumutugma sa Arduino at sumusukat sa distansya. Maghanap ng mga keyword tulad ng sensor na "Distansya", "balakid". Teknikal na gagana ang isang digital sensor kasama rin ang mga menor de edad na pagbabago ng code, ngunit gumagamit kami ng isang analog.

• 1x o 2x Gravity: Analog Grayscale Sensor v2

Ang isa ay isang pangangailangan para sa tagasunod sa linya. Hindi mahalaga ang eksaktong modelo, basta't tinitingnan nito ang tindi ng sinasalamin na ilaw at naglalabas ng isang analog signal. Ang pangalawa para sa pagtuklas ng 'silid' ay hindi gumana pati na rin ang inaasahan at maaaring matanggal, o isang kahalili, tulad ng isang kulay ng RGB na sensor ay matatagpuan, marahil para sa mas mahusay na epekto. Hindi pa natin ito masusubukan.

• 1 x ESP 8266-01.

Mayroong maraming mga bersyon ng magagamit na ESP 8266. Mayroon lamang kaming karanasan sa 8266-01, at hindi matitiyak na gagana ang ESP code sa ibang bersyon.

• 1 x ESP8266-01 Wi-Fi na kalasag.

Opsyunal na opsyonal, ngunit kung hindi mo ito gagamitin, ang lahat na may kinalaman sa module na Wi-Fi ay magiging mas kumplikado. Gayunpaman, ipagpalagay ng gabay na mayroon ka nito, (kung hindi, hanapin ang mga gabay sa online para sa wastong pag-wire sa ESP-01 sa Arduino), tulad ng paggawa nito nang hindi wasto maaari at maaaring makapinsala sa modyul.

• Mga baterya para sa sasakyan mismo at mga baterya upang mapagana ang mga add-on electronics.

Gumamit kami ng isang pares ng 2.2 AH na kapasidad, 7.4V Lipo na mga baterya na kahanay sa kapangyarihan ng lahat. Dapat mong magamit ang anumang mga baterya na karaniwang ginagamit mo sa iyong sasakyang pinili. Kung nasa itaas ka ng 5V ngunit mas mababa sa 20V, mas mahalaga ang kapasidad kaysa sa nominal na boltahe.

• Maraming mga jumper cable.

Sumuko na ako sa pagbibilang ng eksaktong bilang ng mga ito. Kung sa palagay mo ay mayroon kang sapat, malamang na wala ka.

• Panghuli, upang ikabit ang lahat, kakailanganin mong i-mount ang Arduino, ang mga sensor, ang (mga) breadboard at ang Wi-Fi-module sa sasakyan na iyong pinili. Ang iyong resulta ay mag-iiba depende sa ginagamit mo bilang batayan, at kung anong mga materyal ang magagamit.

Ginamit namin ang:

• Mga kurbatang zip.

• Ilang sobrang pandikit.

• Mga maliliit na piraso ng scrap paper / resin tube na mayroon kaming angkop na diameter.

• Isang matandang backplate ng Masonite mula sa isang frame ng larawan, gupitin sa laki.

• Kaunting duct tape pa.

• Anumang mga tool na kinakailangan upang gumana sa iyong napiling kontroladong kotse sa radyo.

Karamihan ay ginamit namin ang isang maliit na driver ng tornilyo na itinakda na may maraming mga bit, ngunit paminsan-minsan ay kailangang hilahin ang stock toolet na kasama ng kotse.

Software:

• Node-red

Isang mahalagang bahagi ng koleksyon ng data.

• Isang MQTT server.

Ang gitnang tao sa pagitan ng aming sasakyan at Node-pula. Sa una, para sa pagsubok, gumamit kami ng test.mosquitto.org

Nang maglaon ginamit namin ang:

• CloudMQTT.com

Ito ay mas maaasahan kung saan higit sa binubuo para sa pagiging mas kumplikado upang mai-set up.

• WampServer.

Ang huling bahagi ng koleksyon ng data. Partikular, gagamitin namin ang SQL database nito para sa pagtatago ng aming nakolektang data.

Hakbang 2: Electrical Diagram

Hakbang 3: Paggawa ng Pisikal

Ang aming solusyon ay may tuwid na diskarte sa pisikal na pagpupulong.

Ang orihinal na reciever at ang enclosure na hindi tinatagusan ng tubig ay tinanggal mula sa RC car, dahil hindi ito kinakailangan.

Nalaman namin na mayroong isang naaangkop na lokasyon sa pagitan ng mga gulong sa harap para sa aming linya na sundan ang sensor, kaya't hinawakan namin ito sa lugar sa pamamagitan ng pag-loop ng isang ziptie sa itaas ng plato ng harapan na wala.

Ang sensor na ginagamit namin para sa anti-banggaan ay isang uri ng wedged sa likod ng bumper sa harap. Protektado pa rin ito mula sa mga epekto, at magkasya ang alitan nito. Nagtatapos ito na inaasahan ang isang napakadalang pataas na anggulo. Perpekto ito

Ang plato ng Masonite, (backplate mula sa lumang frame ng larawan), sa itaas ay may maliit na mga seksyon ng papel / resin pipe na gupitin sa laki at nakadikit sa ilalim. Nakahanay ang mga ito sa mga pag-mount para sa mga post sa katawan at nakaupo lamang sa itaas, ligtas na hawak ang lahat. Ipagpalagay na ang pandikit na nakakabit ang tubo sa mga hawak ng plato, at na hindi ito labis na ikiling, mananatili ito sa lugar. Mahalaga rin na tandaan na ang plato ay nasa loob ng proteksiyon na sphere ng mga gulong at mga bumper. Ang Arduino Mega at ang dalawang mga breadboard ay naidikit sa plato na may alinman sa dobleng tape sa gilid, o may isang loop ng duct tape na naka-loop sa paligid, nakadikit.

Walang mga espesyal na hakbang na kinuha upang ma-secure ang WiFi-module. Hindi ito sa atin, kaya nakadikit ito, o ang pag-tap down na ito ay itinuturing na hindi kinakailangan dahil napakagaan nito ay hindi ito gagalawin, at sapat na ang mga wire upang hawakan ito sa lugar.

Sa wakas, mayroon kaming sensor para sa pagtuklas ng 'mga silid' na ito ay naka-zip sa mga bahagi ng suspensyon ng isa sa mga gulong sa likuran. Sa panahon ng pagpapatakbo, kailangang malayo ito sa linya na nagmamarka ng ginagamit ng sasakyan upang mag-navigate.

Hakbang 4: Modyul ng ESP8266

Ang module ng WiFi, ESP8266, ay nangangailangan ng dalawang magkaibang pag-setup ng pin. Ang isang pag-setup ay gagamitin kapag nag-flash ng module sa isang bagong programa at ginagamit ang Arduino Mega 2560 bilang isang programmer. Ang iba pang pag-setup ay para sa module kapag ginagamit ito at nagpapadala ng impormasyon sa MQTT Broker.

Gamit ang Arduino IDE upang mag-upload ng code sa module na ESP8266 kakailanganin mong mag-install ng isang board manager at isang karagdagang board manager

Sa ilalim ng board manager i-install ang esp8266 board manager. Madali itong mahahanap sa pamamagitan ng paghahanap ng "esp". Mahalagang i-install mo ang bersyon 2.5.0, hindi mas matanda, hindi mas bago.

Sa ilalim ng mga setting sa mga karagdagang board manager URL, kopyahin ang linyang ito:

arduino.esp8266.com/stable/package_esp8266c…

Upang makapag-upload ng anumang bagay sa module na ESP8266 kakailanganin mong gumamit ng isang tukoy na pag-setup ng pin upang ma-flash mo ang module. Kailangan itong gawin tuwing nais mong gumawa ng pagbabago sa kasalukuyang code na tumatakbo sa module. Huwag kalimutang piliin ang tamang module ng ESP8266 mula sa board manager bago i-flashing ang module. Sa proyektong ito pinili namin ang pangkalahatang board ng ESP8266. Ang pag-setup ng pin para sa flashing ng module ay matatagpuan sa unang larawan sa segment na ito.

Matapos ma-flash ang module na ESP8266 kailangan mong ilipat ang pag-setup ng pin. Maaari mo ring piliing gumamit ng isang adapter upang gawing madali para sa iyo ang pag-setup. Sa proyektong ito pinili namin na magkaroon ng isang adapter tuwing mayroon kaming module na tumatakbo. Ang pag-setup ng pin na may adapter ay matatagpuan sa pangalawang larawan sa segment na ito.

Ang code na mai-flash papunta sa module ng ESP8266 ay nag-aayos ng koneksyon sa isang WiFi at isang MQTT Broker, sa kasong ito na may isang username at password, ngunit maaaring gawin nang wala kung gagawin mo ang mga kinakailangang pagbabago na inilarawan sa mga komento ng code. Para sa proyektong ito, ang aming Broker ay nangangailangan ng isang username at password upang gumana. Binabasa ng module ang mga papasok na mensahe mula sa serial port kung saan ito nakakonekta. Babasahin nito ang bawat bagong linya na nilikha ng Arduino code, mai-decipher ang mensahe at muling likhain ang mensahe. Pagkatapos ay nagpapadala ito ng mensahe sa MQTT Broker na tinukoy sa code. Ang code para sa Module ng ESP8266:

Hakbang 5: Arduino

Matapos mai-configure ang module ng WiFi, titingnan namin ang program na gagamitin para sa pagkontrol sa motor at servo sa RC car. Ang kotse ay tutugon ayon sa isang kulay-abo na impormasyon mula sa gitnang sensor, na kilala rin bilang "Line Detector" sa proyektong ito. Malinaw na naglalayon nitong mapanatili ang impormasyon mula sa Line Detector malapit sa isang preset na halaga na katumbas ng impormasyong naitala sa pagbabago sa pagitan ng ilaw at madilim o sa proyektong ito, puti at itim. Kaya't kung ang halaga ay naiiba sa sobrang layo, ang kaukulang output sa servo ay patnubayan ang kotse malapit sa preset na halaga ng linya.

Ang programa ay may dalawang mga pindutan na gumagalaw bilang isang start at stop button para sa RC car. Sa teknikal na paraan ang pindutan na "huminto" ay isang pindutan na "arming" na sa mga tuntunin ay katumbas ng halagang PWM na ipinadala sa motor na sanhi ng pagtigil ng kotseng RC. Ang panimulang pindutan ay nagpapadala ng halagang PWM na katumbas ng RC car na bahagya nang sumulong dahil masyadong mabilis ang pagmamaneho nito kung nakakakuha ito ng labis na momentum.

Ang isang detector ng pag-iwas sa banggaan ay idinagdag sa front-end ng RC car upang matukoy kung ang paraan sa unahan ay malinaw o na-block. Kung naka-block ang kotseng RC ay titigil hanggang sa ang hadlang ay nawala / matanggal. Ang analog signal mula sa detektor ay ginagamit upang matukoy kung mayroon o hindi ang isang bagay na humahadlang sa paraan at ginawang pamantayan para makapag-isulong din tulad ng pagtigil.

Ang pangalawang kulay-abong sensor ng grey, "Room Detector", ay ginagamit upang makita kung aling silid ang pinasok ng kotseng RC. Gumagana ito sa isang katulad na prinsipyo bilang Line Detector, ngunit hindi nito hahanapin ang pagbabago sa pagitan ng ilaw at madilim, ngunit sa halip para sa mga halagang nasa loob ng isang tukoy na saklaw na tumutugma sa iba't ibang mga silid depende sa halagang nakikita mula sa Room Detector.

Panghuli ang programa ay lumilikha ng isang linya ng impormasyon mula sa mga sensor para sa module ng WiFi na basahin at pagkatapos ay ipadala sa MQTT Broker. Ang linya ng impormasyon ay nilikha bilang isang string at nakasulat sa kaukulang serial na kung saan nakakonekta ang module ng WiFi. Mahalaga na ang pagsusulat sa serial ay nangyayari lamang nang madalas hangga't nababasa ng module ng WiFi ang papasok na mensahe, ngunit tandaan na huwag gumamit ng anumang pagkaantala sa code na ito dahil makagambala ito sa kakayahan ng RC car na sundin ang linya. Sa halip gumamit ng "millis" dahil papayagan nitong tumakbo ang programa nang walang pagkaantala ngunit pagkatapos ng isang tinukoy na dami ng millis na lumipas mula nang buksan ang Arduino, magsusulat ng isang mensahe sa serial nang hindi hinaharangan ang code sa parehong paraan ng pagkaantala.

Ang code para sa Arduino Mega 2560:

Hakbang 6: MySQL Database

Ang WampServer ay isang web development environment para sa Windows na nagpapahintulot sa amin na lumikha ng mga application na may PHP at isang MySQL database. Pinapayagan kami ng PhpMyAdmin na pamahalaan ang aming mga database sa isang madaling paraan.

Upang magsimula pumunta sa:

Sa proyektong ito gumagamit kami ng bersyon 3.17 x64 bits para sa Windows. Matapos ang pag-install siguraduhin na ang lahat ng mga serbisyo ay tumatakbo na kung saan sa mga term na nangangahulugang ang maliit na icon ay nagiging berde sa halip na pula o orange. Kung ang icon ay berde, maaari mong ma-access ang PhpMyAdmin upang pamahalaan ang iyong MySQL database.

I-access ang MySQL gamit ang PhpMyAdmin at lumikha ng isang bagong database. Pangalanan ito ng isang bagay na naaangkop na maaari mong matandaan, sa proyektong ito tinawag itong "line_follow_log". Matapos likhain ang database, dapat kang lumikha ng isang talahanayan sa database. Tiyaking umaangkop ang bilang ng mga haligi. Sa proyekto ay gumagamit kami ng 4 na mga haligi. Ang isang haligi ay para sa isang timestamp at ang huling tatlo ay ginagamit upang mag-imbak ng data mula sa sasakyan. Gumamit ng tamang datatype para sa bawat haligi. Gumamit kami ng "longtext" para sa hanay ng timestamp at "mediumtext" para sa iba pa.

Iyon lang dapat ang gawin mo sa PhpMyAdmin at MySQL. Tandaan ang iyong database at ang talahanayan para sa seksyon tungkol sa Node-Red.

Hakbang 7: Node-Red

Upang mahawakan ang koleksyon ng data, gagamit kami ng medyo simpleng daloy sa Node-red. Kumokonekta ito sa aming MQTT server, at nagsusulat sa aming MYSQL database.

Upang magawa ito, kailangan namin ng ilang mga paleta para gumana ang iba't ibang mga pagpapaandar, at kailangan namin ng ilang aktwal na code upang mapatakbo ito.

Una muna. Kakailanganin namin ang mga sumusunod na palyet.

Node-red-contrib-mqtt-broker: Ito ang koneksyon sa aming MQTT broker.

Node-red-dashboard: Ang aming Dashboard, kinakailangan upang visual na kumatawan sa nakolektang data.

Node-red-node-MySQL: Ang aming koneksyon sa SQL database.

Hindi ito sinadya upang maging isang ganap na gabay sa Node-red, ngunit ipapaliwanag ko kung ano ang ginagawa ng daloy ng pulang Node.

Maaga pa, mayroon kaming mga isyu sa aming server ng pagpipilian ng MQTT na namamatay / nag-disconnect, na tila random, na gumawa ng anumang mga pagbabago ng isang nakakabigo na hangarin dahil hindi malinaw kung ang mga pagbabago ay naging kapaki-pakinabang, o hindi kapag hindi namin makita ang resulta. Kaya ang pindutang 'Namatay ba ang server?' injects 'Hindi' ang mga sumusunod na block injects ito sa aming MQTT server. Kung hindi ito patay, lilitaw ang 'Hindi' sa window ng Debug. Ginagawa ito hindi lamang upang subukan, ngunit upang pilitin ang Node-red na subukang muling kumonekta sa MQTT server.

Ang 'Test string' ay nagpapadala ng isang costum string sa MQTT broker. Na-format namin ang string na ito upang maging katulad sa makukuha namin mula sa Arduino. Ito ay upang magkaroon ng isang mas madaling oras sa pag-configure ng network na mag-decode ng mga mensahe, nang hindi kinakailangan na magpatakbo ng proyekto, mangolekta ng data.

Ang huling daloy sa workspace ay maaaring nahahati sa dalawang mga segment. Basahin lamang ng ilalim na sangay ang mga mensahe na incomming, nai-post ang mga ito sa window ng pag-debug at nai-save ang mga ito sa SQL server.

Ang malaking network ng mga konektadong switch ay sumusunod sa isang function node kung saan ang tunay na 'mahika' ay nangyayari.

Binabasa ng pagpapaandar na pagpapatuloy ang papasok na string, pinaghahati ito sa bawat semi-colon at ipinapasa ang mga seksyon sa bawat isa sa mga output. Ang mga sumusunod na switch ay tumingin para sa isa sa dalawang magkakaibang papasok na impormasyon. Ang isang tukoy na impormasyon ay palaging ipinapasa sa labas ng isang output, ang iba pang pagpipilian ay umalis ng pangalawang output. Kasunod nito, ay isang pangalawang pangkat ng mga bloke ng switch. Mag-e-activate lang sila sa isang tukoy na input, at maglabas ng iba pa.

Isang halimbawa, 'balakid', tulad ng lahat ng iba pa ay isang pagpipilian sa binary, malinaw na magmaneho, o hindi. Tumatanggap ito ng isang 0, o isang 1. Isang 0 ay ipapadala sa 'malinaw' na sangay, isang 1 ay ipapadala sa sangay na 'Na-block'. Ang switch na 'Malinaw', 'Na-block', kung ang aktibo ay maglalabas ng isang bagay na tukoy, Malinaw, o hadlang, ayon sa pagkakabanggit. Ang berdeng mga bloke ng pagpapatuloy ay magpo-post sa debug window, ang asul ay susulat sa aming dashboard.

Ang mga katayuan na 'katayuan' at 'lokasyon' ay gumagana nang eksakto magkatulad.

Hakbang 8: MQTT Broker

Ang isang Broker ay isang server na naglalagay ng mga mensahe mula sa mga kliyente patungo sa mga patutunguhang kliyente. Ang isang MQTT Broker ay isa kung saan gumagamit ang mga kliyente ng isang MQTT Library upang kumonekta sa broker sa isang network.

Para sa proyektong ito lumikha kami ng isang MQTT Broker gamit ang serbisyo ng CloudMQTT na may libreng subscription para sa isang "Cute Cat" na bersyon. Mayroon itong limitasyon ngunit hindi kami lalampas sa mga nasa proyektong ito. Ang module ng WiFi ay maaaring kumonekta sa broker at ng broker pagkatapos ay i-ruta ang mga mensahe sa isang patutunguhang client ng patutunguhan. Sa kasong ito ang kliyente ay ang aming Node-Red. Nagse-set up ang serbisyo ng CloudMQTT ng isang username at password para sa kanilang server, kaya garantisado kami ng isang mas mataas na seguridad. Karaniwang nangangahulugang tanging ang mga may username at password ang maaaring mag-access sa tukoy na serbisyong CloudMQTT na ito. Mahalaga ang username at password kapag nagse-set up ang koneksyon sa code ng ESP8266 pati na rin ang Node-Red.

Ang nagpapatuloy na mga istatistika para sa mga mensahe na tinatanggap ng Broker ay isang kaaya-ayang tampok, na maaaring magamit upang makita kung gaano kahusay ang paghawak ng iyong plano sa subscription sa impormasyong sinasara nito.

Ang isang magandang tampok ay ang posibilidad na magpadala ng mga mensahe mula sa Broker sa module ng WiFi ngunit hindi namin ginamit ang mga nasa proyektong ito.

Hakbang 9: Hobby Electronics

Bago simulan alam namin mula sa isang nakaraang proyekto na ang stock steering servo ay maaaring makontrol mula sa isang Arduino na may signal na PWM, pagkakaroon ng katulad na mga kable, at pag-plug sa iba't ibang mga channel sa parehong stock radio receiver, ipinapalagay namin ang Electronic Speed Control, (ESC mula sa sa ngayon), na kinokontrol ang motor, maaaring katulad na kontrolado sa pamamagitan ng PWM mula sa Arduino.

Upang subukan ang teoryang ito, nag-aparato kami ng isang maliit na sketch ng Arduino. Binabasa ng sketch ang isang input ng analogue mula sa isang potensyomiter, muling nilalagay ang halaga mula 0, 1024 hanggang 0, 255 at inilalabas ang nagresultang halaga sa isang PWM pin, gamit ang analogWrite () habang ang R / C na kotse sa isang maliit na kahon, at nagkaroon ng tinanggal ang mga gulong.

Matapos magwalis sa saklaw sa pot meter, ang ESC ay tila 'gumising' at maaari naming itong throttle pataas at pababa, mayroon din kaming naka-print na Arduino na mga halaga sa serial na koneksyon upang masubaybayan namin ang mga ito.

Ang ESC ay tila ayaw

Hindi namin kailangang ibahin ang bilis ng sasakyan at perpektong naihatid ito sa pinakamabilis na bilis na makakapagpagalaw nito. Ang 192 ay ang pinakamababang halaga na magpapasara sa motor, subalit hindi pa rin namin maiipon ang lahat at hindi sigurado kung ang output na ito ay sapat upang ilipat ang sasakyan pagkatapos ng huling pagpupulong, subalit ang pagpasok ng isang bahagyang mas malaking halaga ay dapat na walang halaga.

Ang pag-circuit sa potensyomiter at paglalagay ng nakapirming halaga sa code, gayunpaman, ay hindi gumana. Ang stock ESC ay kumurap lamang at hindi paikutin ang motor, 'ayusin ang throttle trim' ayon sa manwal.

Galit na pag-shoot ng problema, pagbato dito ng iba't ibang mga halaga, paggamit ng iba't ibang mga wire, at kahit na pag-eksperimento sa pagbabago ng dalas ng PWM na ginagamit ng Arduino lahat ay nagresulta sa higit pang pagiging kakatwa.

Tila ito ay isang paulit-ulit na isyu, minsan tatakbo ito, sa ibang pagkakataon ay tumanggi itong gumawa ng kahit ano. Pasimple itong nagpatuloy. Ang isang pagsubok kasama ang orihinal na tagakontrol at tatanggap ay nakumpirma na ang ESC ay gumagana pa rin nang eksakto tulad ng inilaan, na gumawa ng mga isyu kahit na hindi kilalang tao. Mas mataas na mga halaga, hindi pinansin at patuloy na kumikislap, mas mababang mga halaga na bumalik ang ESC sa nagniningning na isang masayang berde, ngunit hindi pa rin nakabukas.

Ano ang kaiba sa pag-set up gamit ang potentiometer, o stock transmitter at receiver, at ang bersyon na nagbigay ng mga nakapirming halaga?

Minsan ang pagtatrabaho tulad ng inilaan at pagtatrabaho tulad ng inaasahan ay hindi talaga mag-o-overlap sa diagram ng Venn. Sa kasong ito, bilang isang laruan, dapat walang pagkakataon na ang modelo ay mag-alis lamang o mabali ang mga daliri o mahuli ang buhok sa mga gulong o magmaneho ng tren habang nakabukas ang modelo, kahit na ang isang bagay tulad ng paghawak ng transmitter na kakaiba ay may throttle sa anumang iba pang posisyon kaysa sa walang kinikilingan.

'Ayusin ang throttle trim', iyon mismo ang ibig sabihin nito. Inaasahan ng ESC ang isang walang kinikilingan na signal kapag ito ay nagpapatuloy, bago makuha na wala itong gagawin. Karaniwan ang transmiter ay palaging magiging walang kinikilingan kapag ang ESC ay naka-on at mula doon ay masayang nagmamaneho. Kung sakaling hindi ito, marahil ay bumalik ito sa walang kinikilingan na hindi bababa sa isang beses sa oras na ang modelo ay mahigpit na nasa lupa at nararamdaman ng operator na handa na siyang tumakbo.

Habang ginagamit ang potensyomiter, kami ay 'nagwawalis' sa mga saklaw, at pagkatapos ay magsisimulang gumana. Simpleng armado lamang ito habang ang potentiometer ay natangay sa posisyon na walang kinikilingan, at pagkatapos ay gumana ito.

Ang mga mas mababang saklaw, gayunpaman ay tila hindi pa nasisiyahan ang ESC. Ito ay naging isang produkto ng mga cycle ng tungkulin ng PWM.

Alinman sa disenyo o tapos na para sa isang teknikal na kadahilanan, kapwa hindi pinapansin ng steering servo at ng ESC ang mga signal sa ibaba ng 50% na cycle ng tungkulin. Ito ay maaaring sakaling huminto sa pagtatrabaho o tumatakbo sa kuryente ang tatanggap / transmitter, ang modelo ay babalik sa walang kinikilingan, at hindi aalis sa malayo sa buong balbula ng baligtad. Parehas, umiikot lamang ang servo ng 180 degree, at hindi kailangan ng buong saklaw.

Gamit ang bagong kaalamang nasa kamay, isang bagong Arduino sketch ang nilikha. Tumatanggap ang paunang bersyon ng mga string na ipinasok sa Serial monitor, i-convert ito sa isang integer at ilipat ito sa PWM pin, gamit ang servo library at isulat ang () *. Kung ang isang bagong halaga ay ipinasok sa serial monitor, ang halaga ng sumulat () ay na-update.

Sa panahon ng pagsubok, ang stock na Traxxas ESC ay pinalitan ng isang Mtroniks G2 Micro, subalit dapat magkaparehas ang mga ito, bagaman ang eksaktong mga halaga ay maaaring magkakaiba.

Tinatrato ng library na ito ang ESC bilang isang servo, maayos naman ito. Ang function na magsulat () mula sa silid-aklatan ng Servo.h ay nagmula sa 0 hanggang 180, ang inaasahang signal ng arming ay inaasahang nasa gitna.

Ang mga armas ng G2 Micro sa isang sulatin () sa isang saklaw ng mga halagang malapit sa 90 subalit mahirap na matukoy dahil tila 'naaalala' ang pagiging armado.

Ang Traxxas VXL-s3 ay inaasahang maghahanda sa isang sulatin () na halaga na 91.

Matapos ang signal ng arming, alinman sa ESC ay masayang tinanggap ang mga signal ng PWM, hindi mahalaga ang mga pagpapaandar ng Arduino na tinawag upang makabuo ng mga ito, at kontrolado ang motor nang naaayon.

Nagsasalita ng mga pagpapaandar; ang karaniwang analogWrite (), pati na rin ang magsulat () at magsulatMicroseconds () mula sa silid aklatan ng Servo.h ay maaaring magamit nang palitan, tandaan lamang kung ano ang ginagawa, at sa huli ay walang iba kundi ang mga duty cycle cycle. Maaaring magamit ang WritingMicroseconds () kung kinakailangan ng mas malaking granularity, tandaan lamang na ang saklaw dito ay mula 1000 hanggang 2000, na may arming o 'walang kinikilingan' na inaasahan na nasa 1500. Sa pamantayang analogWrite () ang magagamit na saklaw ay inaasahan na mula 128 hanggang 255 na may bandang 191 na walang kinikilingan.