Arduino Datalogger: 8 Hakbang (na may Mga Larawan)

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

Sa tutorial na ito, gagawa kami ng isang simpleng logger ng data gamit ang Arduino. Ang punto ay upang malaman ang mga pangunahing kaalaman sa paggamit ng Arduino upang makuha ang impormasyon at mai-print sa terminal. Maaari naming gamitin ang pangunahing pag-set up na ito upang makumpleto ang isang hanay ng mga gawain.

Upang makapagsimula:

Kakailanganin mo ang isang Tinkercad (www.tinkercad.com) account. Tumungo at mag-sign up gamit ang iyong email o social media account.

Dadalhin ka ng pag-log in sa Tinkercad Dashboard. I-click ang "Circuits" sa kaliwa at piliin ang "Lumikha ng bagong Circuit". Magsimula na tayo!

Maaari mong makita ang kumpletong file sa TInkercad Circuits - Salamat sa pag-check out nito!

Hakbang 1: Magdagdag ng Ilang Mga Bahagi

Kakailanganin mo ang ilang pangunahing mga sangkap. Kabilang dito ang:

• Board ng Arduino
• Breadboard

Idagdag ang mga iyon sa pamamagitan ng paghahanap para sa kanila at i-click ang pag-drag sa kanila sa gitnang lugar.

Ilagay ang breadboard sa ibabaw ng Arduino. Ginagawa nitong mas madali upang tingnan ang mga koneksyon sa paglaon.

Hakbang 2: Isang Tandaan Tungkol sa Mga Breadboard

Ang isang breadboard ay isang napaka-kapaki-pakinabang na aparato para sa mabilis na prototyping. Ginagamit namin ito upang ikonekta ang mga sangkap. Ang ilang mga bagay na dapat tandaan.

1. Ang mga tuldok ay konektado nang patayo, ngunit ang linya sa gitna ay naghihiwalay sa koneksyon na ito mula sa mga itaas at ibaba na haligi.
2. Ang mga haligi ay hindi konektado kaliwa hanggang kanan, tulad ng sa buong hilera. Nangangahulugan ito na ang lahat ng mga bahagi ay dapat na konektado sa mga haligi sa halip na ibaba ang mga ito nang patayo.
3. Kung kailangan mong gumamit ng mga pindutan o switch, ikonekta ang mga ito sa kabuuan ng pahinga sa gitna. Bibisitahin namin ito sa isang susunod na tutorial.

Hakbang 3: Magdagdag ng Dalawang Sensor

Ang dalawang sensor na ginagamit namin ay isang Photosensitive sensor at Temperature sensor.

Sinusuri ng mga sensor na ito ang ilaw at temperatura. Ginagamit namin ang Arduino upang basahin ang halaga at ipakita ito sa Serial monitor sa Arduino.

Maghanap para sa at idagdag ang dalawang mga sensor. Tiyaking nakaposisyon ang mga ito sa kabuuan ng mga haligi sa breadboard. Maglagay ng sapat na puwang sa pagitan nila upang mas madaling makita ang mga ito.

Hakbang 4: Sensor ng Photosensitive

1. Para sa photosensitive sensor, magdagdag ng isang kawad mula sa 5V pin sa Arduino sa parehong haligi ng kanang binti sa bahagi sa breadboard. Palitan ang pula ng kulay ng kawad.
2. Ikonekta ang kaliwang binti sa pamamagitan ng pin sa parehong haligi sa A0 (A-zero) na pin sa Arduino. Ito ang analog pin, na gagamitin namin upang mabasa ang halaga mula sa sensor. Kulayan ang kawad na ito dilaw o ibang bagay kaysa sa pula o itim.

3. Maglagay ng risistor (paghahanap at pag-click-drag) sa pisara. Nakumpleto nito ang circuit at pinoprotektahan ang sensor at pin.

   • Paikutin ito upang dumaan ito sa mga haligi.
   • Ikonekta ang isang binti sa kanang haligi ng binti sa breadboard
   • Maglagay ng isang kawad mula sa kabilang dulo ng risistor sa lupa

     Palitan ang kulay ng kawad sa itim

4. I-double check ang lahat ng mga koneksyon. Kung ang isang bagay ay hindi nasa tamang lugar, hindi ito gagana nang wasto.

Hakbang 5: Simulan ang Code

Tingnan natin ang code para sa sangkap na ito.

Una, tingnan ang pangatlong imahe sa hakbang na ito. Naglalaman ito ng ilang code na may dalawang pag-andar:

walang bisa ang pag-setup ()

walang bisa loop ()

Sa C ++, ang lahat ng mga pagpapaandar ay nagbibigay ng kanilang uri ng pagbabalik, pagkatapos ang pangalan, pagkatapos ang dalawang bilog na brace na maaaring magamit upang makapasa sa mga argumento, karaniwang bilang mga variable. Sa kasong ito, ang uri ng pagbabalik ay walang bisa, o wala. Ang pangalan ay naka-set up at ang pagpapaandar ay hindi kumukuha ng mga argumento.

Ang pag-andar ng pag-setup ay tumatakbo nang isang beses kapag ang Arduino boots (kapag na-plug mo ito o nakakabit ng mga baterya).

Ang loop function ay tumatakbo sa isang pare-pareho loop mula sa millisecond nakumpleto ang pag-andar ng pag-setup.

Lahat ng iyong inilagay sa loop function ay tatakbo kapag tumatakbo ang Arduino. Tumatakbo lamang ang lahat sa labas kapag tinawag. Tulad ng kung tinukoy at tinawagan namin ang isa pang pagpapaandar sa labas ng loop.

Gawain

Buksan ang panel ng Code na may pindutan sa Tinkercad. Palitan ang dropdown ng Mga Block sa Text. Sumang-ayon sa kahon ng babala na pop up. Ngayon, tanggalin ang lahat ng iyong nakikita maliban sa teksto sa pangatlong imahe sa hakbang na ito.

Mga variable

Upang makapagsimula, kailangan naming magtalaga ng ilang mga variable upang gawin naming mahusay ang aming code.

Ang mga variable ay tulad ng mga timba na maaari lamang magkaroon ng isang bagay (C ++ ang tinatawag nating oriented na object). Oo, mayroon kaming mga array, ngunit ang mga ito ay mga espesyal na variable at pag-uusapan natin ang tungkol sa kanila sa paglaon. Kapag nagtalaga kami ng isang variable, kailangan nating sabihin dito kung anong uri ito, pagkatapos bigyan ito ng isang halaga. Parang ganito:

int someVar = A0;

Kaya, nagtalaga kami ng isang variable at binigyan ito ng uri ng int. Ang int ay isang integer o isang buong numero.

"Ngunit hindi mo ginamit ang isang buong numero!", Naririnig kong sinabi mo. Totoo yan.

Gumagawa ang Arduino ng isang bagay na espesyal para sa amin upang maaari naming gamitin ang A0 bilang isang integer, dahil sa ibang file tinutukoy nito ang A0 bilang isang integer, kaya maaari naming gamitin ang A0 pare-pareho upang mag-refer sa integer na ito nang hindi kinakailangang malaman kung ano ito. Kung nag-type lang kami ng 0, magre-refer kami sa digital pin sa posisyon 0, na hindi gagana.

Kaya, para sa aming code magsusulat kami ng isang variable para sa sensor na na-attach namin. Habang inirerekumenda kong bigyan ito ng isang simpleng pangalan, nasa sa iyo iyon.

Dapat ganito ang hitsura ng iyong code:

int lightSensor = A0;

void setup () {} void loop () {}

Ngayon, sabihin natin sa Arduino kung paano hawakan ang sensor sa pin na iyon. Patakbuhin namin ang isang pag-andar sa loob ng pag-setup upang maitakda ang pin mode at sabihin sa Arduino kung saan hahanapin ito.

int lightSensor = A0;

void setup () {pinMode (lightSensor, INPUT); } void loop () {}

ang pagpapaandar ng pinMode ay nagsasabi sa Arduino na ang pin (A0) ay gagamitin bilang isang INPUT pin. Tandaan ang camelCaseUsed (tingnan ang bawat unang titik ay isang kabisera, tulad ng sa ito ay may mga humps, samakatuwid … camel …!) Para sa mga variable at pangalan ng pag-andar. Ito ay isang kombensiyon at mahusay upang masanay.

Panghuli, gamitin natin ang pagpapaandar ng analogRead upang makakuha ng ilang data.

int lightSensor = A0;

void setup () {pinMode (lightSensor, INPUT); } void loop () {int reading = analogRead (lightSensor); }

Makikita mong naimbak namin ang pagbabasa sa isang variable. Ito ay mahalaga dahil kailangan nating i-print ito. Gamitin natin ang Serial library (ang isang library ay code na maaari nating idagdag sa aming code upang gawing mas mabilis ang mga bagay para sa ating maisulat, sa pamamagitan lamang ng pagtawag nito sa pamamagitan ng kahulugan nito) upang mai-print ito sa serial monitor.

int lightSensor = A0;

void setup () {// Itakda ang mga pin mode na pinMode (lightSensor, INPUT); // Idagdag ang serial library Serial.begin (9600); } void loop () {// Basahin ang sensor int pagbabasa = analogRead (lightSensor); // I-print ang halaga sa monitor Serial.print ("Light:"); Serial.println (nagbabasa); // antalahin ang susunod na loop ng 3 segundo pagkaantala (3000); }

Ilang mga bagong bagay! Una, makikita mo ang mga ito:

// Ito ay isang puna

Gumagamit kami ng mga komento upang sabihin sa ibang tao kung ano ang ginagawa ng aming code. Dapat mong gamitin ang mga ito nang madalas. Hindi basahin ng tagatala ang mga ito at i-convert ito sa code.

Ngayon, nagdagdag din kami ng Serial library na may linya

Serial.begin (9600)

Ito ay isang halimbawa ng isang pagpapaandar na tumatagal ng isang pagtatalo. Tinawag mo ang library ng Serial pagkatapos ay nagpatakbo ng isang pagpapaandar (alam namin na ito ay isang pag-andar dahil sa mga bilog na brace) at ipinasa sa isang integer bilang isang pagtatalo, itinatakda ang Serial function upang gumana sa 9600baud. Huwag mag-alala kung bakit - alam lamang na gumagana ito, sa ngayon.

Ang susunod na ginawa namin ay mag-print sa serial monitor. Gumamit kami ng dalawang pag-andar:

// Ang isang ito ay naka-print sa serial na walang line break (isang enter sa dulo)

Serial.print ("Banayad:"); // Ang isang ito ay inilalagay sa linya ng linya kaya't sa tuwing magbasa at magsulat tayo, pupunta ito sa isang bagong linya Serial.println (nagbabasa);

Ang mahalaga na makita ay ang bawat isa ay may magkakahiwalay na layunin. Siguraduhin na ang iyong mga string ay gumagamit ng mga marka ng dobleng quote at iwanan mo ang puwang pagkatapos ng colon. Nakatutulong iyon sa kakayahang mabasa para sa gumagamit.

Sa wakas, ginamit namin ang pagpapaandar na pagkaantala, upang mabagal ang aming loop at gawin itong basahin nang isang beses bawat tatlong segundo lamang. Ito ay nakasulat sa libu-libong segundo. Palitan ito upang basahin nang isang beses lamang sa bawat 5 segundo.

Malaki! Patuloy na tayo!

Hakbang 6: Simulation

Palaging suriin ang mga bagay na gumagana sa pamamagitan ng pagpapatakbo ng simulation. Para sa circuit na ito, kakailanganin mo ring buksan ang simulator upang suriin itong gumagana at suriin ang iyong mga halaga.

Simulan ang simulation at suriin ang serial monitor. Baguhin ang halaga ng light sensor sa pamamagitan ng pag-click dito at pagbabago ng halaga gamit ang slider. Dapat mong makita ang pagbabago ng halaga sa serial monitor, din. Kung hindi ito, o kung kapag pinindot mo ang pindutan ng Simula ng Simulation nakakakuha ka ng mga pagkakamali, maingat na bumalik at suriin ang lahat ng iyong code.

• Ituon ang mga linya na nakalagay sa pulang window ng pag-debug na ipapakita sa iyo.
• Kung ang iyong code ay tama at ang simulation ay hindi pa rin gumagana, suriin ang iyong mga kable.
• I-reload ang pahina - maaaring mayroon kang isang hindi kaugnay na error sa system / server.
• Iling ang iyong kamao sa computer, at suriin muli. Ginagawa ito ng lahat ng programmer. Lahat Ang. Oras

Hakbang 7: Wire Up ang Temp Sensor

Ipagpalagay ko na nasa tamang track ka ngayon. Sige at i-wire ang sensor ng temperatura tulad ng iminumungkahi ng larawan. Tandaan ang paglalagay ng 5V at GND wires sa parehong puwang tulad ng mga para sa ilaw. Ok lang ito Ito ay tulad ng isang parallel circuit at hindi magiging sanhi ng mga isyu sa simulator. Sa isang tunay na circuit, dapat kang gumamit ng isang breakout board o kalasag upang makapagbigay ng mas mahusay na pamamahala sa kuryente at mga koneksyon.

Ngayon, i-update natin ang code.

Ang temp sensor code

Ito ay medyo mas mahirap, ngunit dahil lamang sa kailangan naming gawin ang ilang matematika upang i-convert ang pagbabasa. Hindi naman masyadong masama.

int lightSensor = A0;

int tempSensor = A1; void setup () {// Itakda ang mga pin mode na pinMode (lightSensor, INPUT); // Idagdag ang serial library Serial.begin (9600); } void loop () {// Ang temp sensor // Lumilikha ng dalawang variable sa isang linya - oh kahusayan! // Float var upang mag-imbak ng isang decimal float boltahe, degreeC; // Basahin ang halaga ng pin at i-convert ito sa isang pagbasa mula 0 - 5 // Mahalagang boltahe = (5/1023 = 0.004882814); boltahe = (analogRead (tempSensor) * 0.004882814); // convert to Degree C degreesC = (boltahe - 0.5) * 100; // I-print sa serial monitor Serial.print ("Temp:"); Serial.print (degreeC); Serial.println ("oC"); // Basahin ang sensor int pagbabasa = analogRead (lightSensor); // I-print ang halaga sa monitor Serial.print ("Light:"); Serial.println (nagbabasa); // antalahin ang susunod na loop ng 3 segundo pagkaantala (3000); }

Gumawa ako ng ilang mga pag-update sa code. Isa-isa nating lakarin ang mga ito.

Una, idinagdag ko ang linya

int tempSensor = A1;

Tulad ng lightSensor, kailangan kong itabi ang halaga sa isang variable upang mas madali itong gawin sa paglaon. Kung kailangan kong baguhin ang lokasyon ng sensor na ito (tulad ng pag-rewire ng board) pagkatapos ay kailangan ko lamang baguhin ang isang linya ng code, hindi maghanap sa buong buong codebase upang baguhin ang A0 o A1, atbp.

Pagkatapos, nagdagdag kami ng isang linya upang maiimbak ang pagbabasa at ang temp sa isang float. Tandaan ang dalawang variable sa isang linya.

float boltahe, degreeC;

Ito ay talagang kapaki-pakinabang dahil binabawasan nito ang bilang ng mga linya na kailangan kong isulat at pinapabilis ang code. Maaari itong maging mas mahirap upang makahanap ng mga error, bagaman.

Ngayon, gagawin namin ang pagbabasa at maiimbak ito, pagkatapos ay i-convert ito sa aming halaga ng output.

boltahe = (analogRead (tempSensor) * 0.004882814);

degreesC = (boltahe - 0.5) * 100;

Ang dalawang linya na iyon ay mukhang mahirap, ngunit sa una ay isinasaalang-alang namin ang pagbabasa at i-multiply ito ng 0,004… dahil binago nito ang 1023 (ibabalik ng analog na pagbasa ang halagang ito) sa isang pagbasa ng 5.

Ang ikalawang linya doon ay pinaparami ang pagbabasa ng 100 upang ilipat ang decimal point. Ibinibigay sa atin ang temperatura. Magaling!

Hakbang 8: Pagsubok at Pagsuri

Lahat ng mga bagay na magpaplano, dapat ay mayroon kang isang gumaganang circuit. Subukan sa pamamagitan ng pagpapatakbo ng simulation at paggamit ng serial monitor. Kung mayroon kang mga error, suriin, suriin muli at iling ang iyong kamao.

Nagawa mo ba ito? Ibahagi at sabihin sa amin ang iyong kwento!

Ito ang huling circuit na naka-embed para sa iyo upang maaari mong i-play / subukan ang pangwakas na paglikha. Salamat sa pagkumpleto ng tutorial!