Magpadala ng Data ng Numero Mula sa Isang Arduino patungo sa Isa pa: 16 Hakbang

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

Panimula

ni David Palmer, CDIO Tech. sa Aston University.

Kailangan mo bang magpadala ng ilang mga numero sa kabuuan mula sa isang Arduino patungo sa isa pa? Ipinapakita ng Tagubilin na ito kung paano.

Madali mong masubukan itong gumagana sa pamamagitan lamang ng pagta-type ng isang string ng mga numero upang maipadala sa terminal ng Serial Monitor, at makita ang mga numero na bumalik sa isang pangalawang Serial monitor na konektado sa pangalawang Arduino. Maaari mo ring gamitin ang isang link sa Bluetooth.

Kung ano ang ginagawa nito

Dalawang programa ng Arduino (mga sketch sa Arduino ang nagsasalita) na kailangang bumuo, isa sa isang Master program upang kumonekta sa host computer na nagpapatakbo ng Arduino Serial Monitor, isa upang kumilos bilang Alipin upang matanggap ang serial message mula sa Master, i-decode ito at ibalik ito. Ang alipin ay opsyonal na may kakayahang ipakita ang mga numero na hinarap nito sa isang Serial Monitor ng pangalawang IDE - kung sakaling nais mong gamitin ito. Maaari itong makatulong na makuha ang mga bagay na gumagana sa una, at makakatulong sa iyo kung magpasya kang gumawa ng anumang mga pagbabago sa mga programa upang umangkop sa iyong sariling mga kinakailangan.

Kagamitan

• 2 ni Arduino
• 2 USB lead
• patch wires (tulad ng kinakailangan)
• 1 PC / laptop na puno ng Arduino IDE (magagamit bilang libreng pag-download mula sa website ng Arduino.cc)

Hakbang 1: Pag-set up - Itakda muna ang Iyong Hardware

I-plug ang 2 Arduinos sa 2 USB port sa iyong computer.

Tip, magandang ideya na lagyan sila ng label bilang M at S (master at alipin) upang hindi ka mapunta sa isang muddle sa paglaon (tulad ng ipinakita sa 2 larawan dito.)

Hakbang 2: Pag-set up - Itakda ang Iyong Screen

Ang pinakamagandang bagay ay i-set up ang iyong screen upang mayroon ka

• ang IDE na na-load sa Master program sa kaliwa at
• yan sa Alipin sa kanan.

Panatilihin ang mga Serial Monitor para sa Maser at Alipin sa kaliwa at kanan din tulad ng ipinakita sa screen shot dito.

Hakbang 3: I-set-up ang Master End, Pagkatapos Magkonekta Sama-sama - Bahagi 1

Kapag na-set up mo ang iyong Master End Serial Monitor upang magpadala ng dalawang numero, dapat mong palaging gamitin ang pagsisimula, at pagtatapos, mga character ng delimiter, at ang character na separat ng kuwit na nakikita mo rito.

Kailangan mo na ngayong ikonekta ang magkasama ang 2 Arduino sa serial. Ginagawa ito sa dalawang mga wire ng patch.

Gumamit ako ng berde at dilaw

• Kunin muna ang dilaw, dapat itong isaksak sa D6 sa isang Arduino at D7 sa pangalawa
• Pagkatapos ang kabaligtaran para sa berdeng kawad, D7 sa una at D6 sa pangalawang Arduino.

Bilang kahalili, kung mayroon kang isang magagamit na tulad ng isang pares ng mga Bluetooth module - tulad ng HC-05's - gagana rin ito upang mabigyan ka ng eksaktong kaparehong epekto ng mga wire sa itaas.

Hakbang 4: I-set-up ang Master End, Pagkatapos Magkonekta Sama-sama - Bahagi 2

Ginagawa naming paggamit ang Software Serial library. Ang karagdagang impormasyon ay magagamit sa link na ito

Maaari mong makita ang tinawag na ito sa linya 7 ng alinman sa mga programa. I-configure nito ang mga pin na digital 7 at 6 bilang TX at RX (ihatid at matanggap). Ito ay kung paano ang data ay maglakbay palabas ng Master Arduino sa pamamagitan ng berdeng kawad papunta sa Alipin, at, kapag ang programa ng Alipin sa pangalawang Arduino ay natapos na ang gawain nito, bumalik sa pamamagitan ng dilaw na kawad. Sa ilalim ng parehong ilustrasyon (sa window ng Serial Monitor) maaari mong makita ang data na aming naihatid na matagumpay na nag-ikot sa loop na inilarawan dito, at bumalik sa PC habang ang pares ng mga integer ay mahusay na pinaghiwalay.

Hakbang 5: Pangkalahatang-ideya ng Sketch / Programs - Istraktura ng Program

Layout Tulad ng lahat ng mga sketch ng Arduino mayroong 3 pangunahing mga bahagi:

• Ang Mga Pahayag
• Ang set up
• Ang pangunahing Loop

Tulad ng madalas na nangyayari, nagawa namin ang paggamit dito ng isang ika-4 na seksyon na kung saan ay ang pagdaragdag ng 'Mga Pag-andar'. Kung hindi ka pamilyar sa paggamit ng Mga Pag-andar maaari kang Google para sa "Mga pagpapaandar ng Arduino" at mahahanap mo ang mga site ng paliwanag tulad ng halimbawa sa link na ito: www.tutorialspoint.com/arduino/arduino_function…..

Gumawa rin kami ng paggamit ng mga tab upang paghiwalayin ang programa sa mga mas madaling pamahalaan na mga bloke.

Ang tatlong mga bloke na ginamit namin ay makikita sa tuktok ng bawat paglalarawan ng mga window ng IDE sa itaas:

• simpleRxTx0330Master
• pangkaraniwan
• mga tala

Ang mga ito ay talagang hiwalay na mga file sa loob ng folder ng programa, tulad ng nakikita mo sa view ng Windows Explorer na ito ng mga file ng Slave program.

Mayroong napakahusay na dahilan kung bakit natin nagawa ito.

• Habang binubuo namin ang programa ay napagtanto namin na ang karamihan sa programa para sa Master ay kapareho ng para sa Alipin.
• Natapos namin ang paghila ng lahat ng mga karaniwang bahagi sa isang tab, kung saan pinangalanan namin na "pangkaraniwan", at pagkatapos ay sa tuwing na-debug namin ang isang bahagi (nasubukan ito, at nasiyahan na gumana ito OK) kinopya lamang namin at na-paste ang buong tab na iyon. sa tapat ng Master hanggang sa Alipin, o visa versa.
• Mangyayari ding magkatulad ang mga tab na tala, dahil ang disenyo ay pangkaraniwan.

Wala sa mga pagpapaandar ang tinawag mula sa pag-setup, lahat sila ay tinawag mula sa loop, kaya nilikha namin ang mga ito pagkatapos ng pag-set up ngunit bago mag-loop.

Hakbang 6: Nangungunang Down Design

Magandang ideya na idisenyo ang iyong sketch na nagsisimula sa isang kahulugan ng kung ano ang nais mong gawin.

Kapag mayroon ka nito maaari mong simulan ang paggawa ng sketch na gawin ang mga bagay na iyon. Pangkalahatan kung mayroong isang detalye na hindi mo pa alam kung paano gawin, gawin lamang itong isang pag-andar, at iwanan ang paglikha ng pagpapaandar hanggang sa paglaon.

Sinusundan ito ng mabuting pilosopiya sa disenyo, itinuro sa maraming Unibersidad, na tinatawag na CDIO (Kung hindi mo pa alam ang isang ito maaari mo itong Google, at maghanap ng mga site upang ipaliwanag ito tulad ng: https://www.cdio.org/s.) Karaniwang sinasabi nito: Huwag simulan ang Disenyo bago mo malinaw ang Konsepto. Huwag simulan ang Pagpapatupad hanggang sa makuha mong malinaw ang Disenyo. Huwag asahan na Magpatakbo ito bago mo malinaw ang Pagpapatupad. C muna, pagkatapos D, I, at O. Sa bawat kasunod na yugto ay umuulit ka (bumalik sa (mga) loop, kaya't sa sandaling masaya ka sa iyong paunang loop ng Disenyo at suriin na natutugunan pa rin nito ang Konsepto, at i-update ang C kung kailangan mo. At iba pa, kaya't kahit na nakarating ka sa Pagpapatakbo, bumalik ka sa tuktok, at muling makita kung paano ang C ngayon, pagkatapos ay ang D at ako, at gawin at suriin ang lahat nagbabago kung kinakailangan. Sa mga sketch ng programa gagana ito pareho kung ikaw ang Top-Down na disenyo.

Hakbang 7: Konsepto at Disenyo - Bahagi 1

Ang Konsepto dito ay katulad ng mga kinakailangang balangkas na nakasaad sa tab na 'mga tala.'

Ang Disenyo ay maaaring magmukhang isang maagang bersyon ng loop, na tumutugma sa tab na mga tala at maaaring magmukhang tulad ng nakikita mo sa figure na ito

Tingnan kung paano nais kong magsimula sa pamamagitan ng aktwal na pagkopya ng CTRL-C ng mga komento sa ulo ng loop, at pagkatapos ay simulang punan ang mga blangko na may mga utos na magagawa ang mga bagay na iyon.

Talagang pinagsasama-sama nito ang OK tulad ng nakikita mo sa ilalim ng screen sa figure. Na umaabot sa CDIO yugto D hanggang sa I, at habang binubuo namin ang code isang magandang ideya na panatilihin ang pag-ikot sa loop na D-I na ito.

Ngayon ay oras na upang bumaba sa susunod na yugto, mayroong isang komento doon na nagsasabing pupunta kami sa: // makatanggap ng isang bagay mula sa hardware USB, pagkatapos ay ipapadala namin iyon sa serial serial ng software. Isusulat namin ang code na ito upang maganap iyon - ang mga linya na 133 hanggang 138 ay ipinapakita dito sa dilaw na highlighter

Hakbang 8: Konsepto at Disenyo - Bahagi 2

Ang dalawang unang dalawang pagpapaandar na ipinakilala namin dito ay (recv () at tran () upang gawin ang pagtanggap mula sa hardware port at ang paglilipat sa software port - samakatuwid ay tinawag sila sa mga ipinakitang 'hw' o 'sw' na mga parameter.

Bilang karagdagan sa mga ito, nagdagdag kami ng isang pagsubok sa isang pandaigdigang variable na tinatawag na newData. Ito ay isang watawat na itatakda namin sa loob ng "void recv ();" na function. Kapag natanggap ang isang mensahe ang variable na ito ay nai-flag mula sa false hanggang true. Ginagawa namin ito upang makapagpadala lamang kami ng isang mensahe kung may natanggap (flag == true) sa linya 134. At sa sandaling naihatid namin ang aming mensahe na 'tapos na ang trabaho' kaya't tinanggal namin ang bandila pabalik sa maling muli sa linya 137.

Muli maaari naming suriin ang ipon (D sa I), at sa oras na ito mayroon kaming isang 'hindi idineklarang' mensahe ng error (ipinakita). Sinasabi nito sa amin na hindi namin idineklara ang recv (); pagpapaandar Plano naming gawin ito sa paglaon, kaya sa ngayon lamang upang payagan kaming makakuha ng isang malinis na compile na kailangan namin upang lumikha ng isang function na dummy o placeholder, tulad ng ipinakita sa susunod.

Muli maaari naming suriin ang compile (D to I), at sa oras na ito mayroon kaming isa pang 'hindi idineklarang' mensahe ng error para sa tran (); pagpapaandar Kailangan nito ng katulad na paggawa ng straw. Muli maaari naming suriin ang ipon (D sa I), at sa oras na ito ay mahahanap natin itong gumagana nang perpekto; sa ngayon napakahusay.

Hakbang 9: Tapusin ang Pangunahing Loop: A) Tumatanggap Mula sa USB, B) Tumatanggap Mula sa Alipin na Arduino

Mayroong isang pangwakas na piraso na idinagdag namin upang matapos ang bahaging ito na magdagdag ng ilang code sa pag-debug.

May isa pang Tagubilin sa pag-debug ng mga sketch na maaaring tinukoy upang maunawaan kung ano ang nagawa natin dito at kung bakit. Sumangguni sa Maituturo na "Paano bumuo at subukan ang mga sketch ng Arduino hanggang sa gumana ang mga ito"

Kaya ang mga linya ng pag-debug na ito [136-139 na ipinapakita] ay naidagdag na susunod sa pangunahing loop at, lo-and-see, maaari mong subukan ang mga ito sa Master end sa pamamagitan ng paggawa ng totoo ng variable ng debug, at Compiling (I), kung gayon ikinonekta mo ang isang Arduino up maaari mong I-upload, buksan ang Serial Monitor at tingnan kung kung ano ang bumalik sa Serial Monitor ay tulad ng ipinakita dito (nakikita mo ba ang mensahe na "DEBUG MODE" na naidagdag?)

Hakbang 10: Pagtanggap at Pangangasiwa ng Data sa Alipin ng Arduino

Tumatanggap mula kay Alipin Arduino

Idagdag ang kinakailangang code para sa pangalawang channel sa pangunahing loop, ang serial software receiver tulad ng ipinakita - mga linya 149 hanggang 155.

Maaari mo bang makita na ang istraktura ay maluwag batay sa aming isinulat sa itaas para sa kaso ng Master?

Gayundin makikita mo na nakakakuha kami ng isang error sa tagatala, isa pang hindi naideklarang pagpapaandar - sa oras na ito parseData (); - kaya kailangan nating gumawa ng isang usbong din para sa ito, bago kami magpatakbo ng isang pagsubok na walang error na ipunin.

Pangangasiwa ng data sa Alipin Arduino

Idagdag ang pangunahing loop code na kinakailangan para sa Arduino kung naka-configure ito bilang isang Slave device tulad ng ipinakita - mga linya 163 hanggang 174. Maaari mo bang makita na ang istraktura nito ay halos kapareho ng sa unang channel?

At dapat mong makita ang oras na ito na ito ay nagtatala ng ganap na pagmultahin.

Hakbang 11: Isulat ang Tanggapin na Pag-andar

Ang function na Tumanggap - walang bisa recv (char mula sa) {} - ay may dalawang pangunahing mga trabaho.

1 upang makatanggap ng isang string ng mga character mula sa USB channel, at

2 upang makatanggap ng isa mula sa Arduino hanggang sa Arduino channel.

Para sa una kakailanganin naming gamitin dahil gumagamit ito ng built-in na hardware ng Arduino, at para sa pangalawa gamit ang karaniwang Arduino Library: software UART.

Kapag nagsimula kaming magdagdag ng code sa isang pagpapaandar - upang lumikha ng isang pagpapaandar na gumagawa ng isang bagay, sa halip na isang maliit lamang na sanga - kailangan nating tandaan na alisin o bigyan ng puna ang palitan na pinapalitan nito. Kung hindi man nakakakuha kami ng isang error sa pag-ipon: refefintion ng 'void lrec (char)'.

Subukan at alisin ang error, at pagkatapos ay subukan ang alinman sa mga paraang iminungkahi sa itaas upang matanggal ito.

Magsimula sa isang pagpapaandar na kamukha ng ipinakita namin dito ng mga linya na 75 hanggang 88 na kulay dilaw.

Sa ngayon alam mo na ang pagkakaroon ng code kakailanganin mong subukan ang pagpapatakbo ng Compile. Nagbibigay sa iyo ng isang error, tulad ng mga nauna sa amin, ng uri: ang pangalan ng pag-andar na hindi idineklara sa saklaw na ito. Kakailanganin namin ng una ang isa pang usbong upang ipaalam sa amin na ipagsama ang error na ito, kaya magdagdag ng isa tulad ng dati, at siguraduhin na makakakuha ka ng isang sumulat nang walang mga error.

Hinahayaan ngayon na tingnan ang code na isinulat namin para sa pagpapaandar ng recv ().

Ito ay lubos na malinis, maaari mong makita ang paggamit ng kundisyon na 'kung' upang makagawa ng dalawang bahagi ng pagpapaandar na tinukoy sa itaas.

Ang code sa loob ng 'sw' na bahagi at ang 'hw' na bahagi ay pareho ng form, at ilalarawan ko ito dito.

Ang una sa pares ng mga linya sa bawat kaso ay ang simula ng isang habang loop. Kung hindi ka pamilyar sa habang maaari mo itong tingnan sa Arduino.cc/Referensi site para sa paliwanag at mga halimbawa. Hinahintay namin 'habang' ang nakapaloob na 'Serial' na pag-andar ay hindi nakatanggap ng anumang (mga) character at dahil ang newData variable ay naka-off (ibig sabihin ang newData == maling kondisyon ay totoo). Sa lalong madaling isang character - o higit pa sa isang character - ay natanggap habang habang 'drop through' sa pangalawang linya sa pares na ito. Tatawag iyon sa recAstringChar (char); pagpapaandar upang hawakan ang kasalukuyang character. Ang pares ng mga linya na ito ay kahalili habang (o hangga't) mayroong anumang mga character na nangangailangan ng matanggap. Kapag tapos na silang lahat habang nagtatapos ang estado, pinapayagan ang kung o iba pang susunod na antas hanggang sa wakas, at sa turn pinapayagan ang rec (char); pag-andar upang matapos. Sa gayon isang buong mensahe ang natanggap ngayon sa bee.

Hakbang 12: Isulat ang Tumanggap ng Sub-function - Bahagi 1

Kailangan namin ngayon na isulat ang pagpapaandar na tinatawag na recAstringChar (char);. Nakita mo mula sa komento hanggang linya 50 dito sa tuktok, na ang trabaho nito ay ang pag-update ng dalawang buffer na may mga kopya ng papasok na serial message. [Ito ay nangyari habang sinusubukan kong gawin ang lahat ng ito na ang isang bagay na natutunan ko ay kailangan ko ng dalawang magkakaibang buffer - o hindi bababa sa iyon ang pinakamadaling paraan upang maiikot ang ilang mga problema, kaya't medyo nag-evolve ito sa nangangailangan ng 2 buffer, kaya't Ginawa ko lang sila.] Tumawag ako ng isang buffer: natanggap angData, at ang iba pa: natanggap na Mga Char.

Ang mga buffer ay mga variable ng mundo, kaya idineklara ito sa antas ng module, tingnan ang mga linya na 9 at 10 ng karaniwang tab. Mayroong iba pang mga variable na idineklara sa loob ng pagpapaandar na ito kung kaya mayroong lokal na saklaw- ipinakita sa mga linya 51-54 dito. Hindi ito ang lugar upang ipaliwanag ang mga pagkakaiba sa pagitan ng mga globo at mga lokal, ngunit mayroong higit pang impormasyon tungkol dito sa https://www.arduino.cc/glossary/en/ sa ilalim ng Lokal at Pandaigdigan.

Maaari mo ring malaman ang lahat tungkol sa mga uri ng data at mga uri ng modifier: static, boolean, byte, const, char sa https://www.arduino.cc/referensi/en/#variables, ipinakita rito.

Ang pangunahing daloy ng programa sa pagpapaandar na ito ay kinokontrol ng kung sa linya 56 dito, at ang kaukulang iba pa sa linya na 74. Nakikipag-usap ito sa dalawang mga sitwasyon

a) [mula sa linya 74 sa] kapag nagsisimula ang natanggap na mensahe. Nangyayari ito kapag nakita ang startMarker - ito ay tinukoy bilang character na '<', kaya't sa tuwing susubukan namin ang sketch ay palagi naming sinisimulan ang aming string sa character na iyon. Kung hindi tayo magagawa, walang mapoproseso bilang natanggap, lahat ay hindi papansinin na parang nagta-type kami ng kalokohan sa prompt ng 'Serial Monitor' na keyboard.

b) [mga linya 56 hanggang 73] na tumatanggap ng lahat ng iba pang mga character, anuman ang mga ito, ngunit nakikipag-usap lamang sila sa mga character pagkatapos ng isang wastong pagsisimula na nangyari (isang '>' natanggap tulad ng a) sa itaas.)

Sa mga linyang ito (mula 74 hanggang 78) inilalagay namin ang natanggap na <sa isa sa mga buffer (natanggapData [0]) ngunit hindi sa isa pa. Inaayos namin ang buffer pointer (variable: char ndx) upang ituro sa susunod na posisyon ng ekstrang buffer (natanggapData [1]) gamit ang post-increment command (++) sa linya ndx ++;, at itinakda namin ang isinasagawa na bandila sa totoo.

Ang daloy ng programa sa bahaging ito ng pag-andar ay kinokontrol ng kung sa linya 57 dito, at ang kaukulang iba pa sa linya 65. Pakikitungo ito sa dalawang mga sitwasyon

a) [mula sa linya 65 sa] kapag natapos ang natanggap na mensahe. Nangyayari ito kapag nakita ang endMarker - tinukoy bilang>, na kung bakit tuwing sinusubukan namin ang aming sketch ay palaging tinatapos namin ang aming string sa character na iyon. Ang isa sa mga bagay na nangyayari kapag natanggap ang end character ay ang pandaigdigang flag (technically variable) na bagongData ay itinatakda tulad din ng pagtatapos ng pagpapaandar, upang ang pagpapaandar na tinatawag na aming sub-function (ang calling function: recv (char);) maaaring 'malaman' na ang wastong bagong data ay natanggap kumpleto.

b) [mga linya 57 hanggang 64] na tumatanggap ng lahat ng iba pang mga character, anuman ang mga ito. Abala lamang itong ipinapark ang mga ito nang maayos sa mga hilera sa pareho ng mga buffer.

Hakbang 13: Isulat ang Tumanggap ng Sub-function - Bahagi 2

Maaari itong makatulong na magbigay ng isang halimbawa ng kung ano ang hitsura ng 2 buffer kapag sila ay na-populasyon na. Kung papasok kami sa pagpasok, ipapakita sa mga buffer ang mga character sa kanila:

Kaya't nakikita mo ngayon na mayroon kaming isang buffer na eksakto ang lahat ng parehong mga character tulad ng una naming nai-type, at isang buffer na mayroon lamang dalawang halaga at isang naghihiwalay na kuwit. Ngayon mayroon kaming ilang code na maaaring makatanggap ng mga character na nai-type namin sa keyboard ng Serial Monitor, maaari kaming ilipat mula sa CDIO phase I hanggang O, na nagta-type sa ilang mga string at nakikita kung ano ang nangyayari. I-upload ang code sa Master Arduino, buksan ang Serial Monitor at subukang mag-type sa isang wastong bagay, tulad ng pagpasok. Nakatanggap ka ba ng isang echo sa screen ng Serial Monitor tulad ng ipinakita dito?

Hakbang 14: Isulat ang Mga Pag-andar ng Transmit at Parse

Una para sa Paghahatid

Kaya ngayon nakatanggap kami ng isang string, maaari naming isulat ang pagpapaandar na function: tran (char); upang mapalitan ang tuod nito. Papayagan kaming magpadala ng isang string mula sa Master sa Slave Arduino, kaya siguraduhin na ang parehong mga aparato ay naka-plug in at konektado magkasama upang subukan ang bagong pagpapaandar.

Ipasok ang pagpapaandar na ito tulad ng ipinakita dito sa mga linya 117 hanggang 133. Tulad ng makikilala mo, mayroon itong dalawang bahagi, isa upang maipadala sa USB channel (hardware UART) at isa upang maipadala sa iba pang Arduino (software UART.) Dapat itong mag-ipon ng error -free, at agad mong mai-upload ang sketch at makita kung ano ang nangyayari. This time magpapadala na ako. Naipakita mo ba ang resulta?

Ang screen shot ay kagiliw-giliw dahil ang Natanggap na string … ay dapat magmukhang tama tulad ng dati, at ang Transmitted string… ay dapat na magmukhang tama. Gayunpaman tandaan na ang pag-convert ng Integer ay hindi gumana. Mayroon pa ring kaunti pang code na maidaragdag upang gumana ito.

Hakbang 15: Isulat ang Mga Pag-andar ng Transmit at Parse

Pagkatapos para sa Parse

Ito ay isang piraso ng code na pinag-parse ang string na natanggap upang makuha ang bilang ng bahagyang mga string at i-convert ang mga ito sa mga halaga ng integer. Ito ang walang bisa na parseData (); pagpapaandar ng pangunahing loop

Palitan ang parse rint ng code na ipinakita sa mga linya 98 - 113. I-upload ito, at tingnan natin kung ang problema na mayroon tayo sa 2 na integer na halaga ay naayos na. Subukan Natin.

Oo, gumagana ito, tulad ng ipinakita, ang mga integer na natagpuan ay 49 at 98.

Hakbang 16: Katapusan

Ang data na ito ay nawala pakanan sa loop mula sa PC sa pamamagitan ng Master sa pamamagitan ng alipin at pabalik sa pamamagitan ng Master muli sa PC muli. Sa natapos na bersyon ng karaniwang na-upload sa parehong Master at alipin natapos, at sa mode ng pag-debug na naka-off ngayon, makakakita kami ng tamang natanggap ng data sa magkabilang dulo tulad ng ipinakita dito.