Arduino UNO Logic Sniffer: 8 Hakbang (na may Mga Larawan)

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

Nagsimula ang proyektong ito bilang isang simpleng eksperimento. Sa panahon ng aking pagsasaliksik sa datasheet ng ATMEGA328P para sa isa pang proyekto, nakita ko ang isang bagay na medyo nakakainteres. Ang Timer1 Input Capture Unit. Pinapayagan nitong makita ang microcontroller ng aming Arduino UNO na makita ang isang gilid ng signal, mag-imbak ng isang timestamp, at magpalitaw ng isang nakakagambala, lahat sa hardware.

Naisip ko kung aling application ang maaaring maging kapaki-pakinabang, at kung paano ito subukan. Tulad ng nais kong makakuha ng isang tagapag-aral ng lohika sa loob ng ilang oras ngayon, nagpasya akong subukang magpatupad ng isa sa aking Arduino UNO board, upang subukan lamang ang tampok, at makita kung makakakuha kami ng magagandang resulta dito.

Hindi lang ako ang may ganitong ideya, at mahahanap mo ang marami sa kanila sa pamamagitan lamang ng pag-google ng "Arduino Logic Analyzer". Sa simula ng proyekto, bilang nagsimula lamang ito bilang isang eksperimento, hindi ko alam na nagawa na ito ng mga tao, at humanga sa magagandang resulta na nakamit nila sa maliit na piraso ng hardware na ito. Gayunpaman, hindi ako makahanap ng isa pang proyekto gamit ang input capture unit, kaya kung nakita mo na ito, ipaalam sa akin!

Upang buod, ang aking tagapag-aral ng lohika ay:

• Magkaroon ng isang channel,
• Magkaroon ng isang grapikong interface,
• Makipag-usap sa interface sa pamamagitan ng USB,
• Tumakbo sa isang board ng Arduino UNO.

Sa wakas ay magkakaroon ito ng 800 mga sample na lalim ng memorya, at matagumpay na nakuha ang isang mensahe ng 115200 bauds UART (hindi ko talaga ito sinubukan sa mas mataas na bilis).

Ang tagubilin na ito ay naglalaman ng parehong "kung paano ito gumagana" at "kung paano ito gamitin" na mga bahagi ng proyektong ito, kaya para sa mga hindi interesado sa teknikal na panig, maaari kang direktang tumalon sa hakbang 4.

Mga gamit

Nais kong panatilihing simple ang analyzer hangga't maaari, kaya nangangailangan ng napakakaunting hardware.

Kakailanganin mong:

• Isang Arduino UNO board (o katumbas basta umaasa sa ATMEGA328P MCU),
• Isang kompyuter,
• Isang bagay upang mai-debug (ang iba pang Arduino UNO board ay gumagana nang maayos upang gumawa ng ilang mga pagsubok).

Ang code para sa parehong Arduino UNO at web interface ay matatagpuan dito. Kakailanganin mo rin ang p5serialcontrol, at PulseView software.

Hakbang 1: Prinsipyo sa Paggawa

Ang ideya ay simple. Piliin mo ang mga setting ng pagkuha, at mag-click sa "kumuha". Ipapadala ng web interface ang mga ito sa p5serialcontrol software, na nagbibigay-daan sa amin upang magamit ang serial interface mula sa isang browser, dahil hindi ito direktang ma-access ito. Ang p5.serialcontrol software pagkatapos ay ipapasa ang impormasyon sa Arduino UNO board, na kinukuha ang data, at ibabalik ito sa interface sa pamamagitan ng parehong landas.

Madali! Sa gayon … Dahil hindi talaga ako mahusay sa pag-program ng interface ng Human / Machine o mga teknolohiya sa web, ang minahan ay tiyak na medyo pangit at maraming surot. Ngunit pinapayagan akong magsimula ng isang makuha at makuha muli ang aking data, na kung saan ito ay dinisenyo, kaya sa palagay ko ay mabuti lang. Para sa mas seryosong gawain sa pagtatasa, ini-import ko ang aking mga tala sa PulseView, na madaling gamitin at nag-aalok ng isang mahusay na hanay ng mga tampok at mga decoder ng protokol, tulad ng makikita natin sa paglaon.

Ang unit ng input capture ng Arduino UNO ay maaaring mai-configure upang magamit ang iba't ibang mga dibisyon ng orasan, sa gayon ay binabawasan ang resolusyon, ngunit pinapataas ang pagkaantala bago umapaw. Maaari rin itong mag-trigger sa pagtaas, pagbagsak o parehong gilid upang simulang makuha ang data.

Hakbang 2: Arduino UNO Sketch

Sinulat ko at pinagsama ang sketch sa Arduino IDE. Nagsimula muna ako sa pamamagitan ng pagse-set up ng Timer1 sa "Normal" na mode ng operasyon sa pamamagitan ng pagsulat sa mga rehistro ng TCCR1A at TCCR1B sa pag-setup (). Gumawa ako pagkatapos ng ilang mga pag-andar upang madali ang kaunting paggamit nito sa hinaharap, tulad ng isa upang itakda ang dibisyon ng orasan na pinangalanang "setTim1PSC ()". Sumulat din ako ng mga pagpapaandar upang buhayin at i-deactivate ang Timer1 input capture unit at overflow interrupts.

Idinagdag ko ang "sample" na array, na hahawak sa nakuha ng data. Ito ay isang pandaigdigang hanay na itinakda ko sa "pabagu-bago" upang maiwasan ang tagatala na gumawa ng mga pag-optimize at ilagay ito sa flash, tulad ng ginagawa nito sa aking unang mga pinagsama-sama. Tinukoy ko ito bilang isang "uint16_t" array, dahil ang Timer1 ay 16bit din, na may haba na 810. Humihinto kami sa pagkuha ng 800 na halaga, ngunit habang ang pagsubok ay tapos na sa labas ng mga nakakagambala para sa halatang mga kadahilanan ng bilis, pinili kong panatilihin ang 10 mas maraming mga halaga upang maiwasan ang pag-apaw. Na may ilang dagdag na variable para sa natitirang code, ang sketch ay gumagamit ng 1313 bytes (88%) ng memorya, na iniiwan sa amin ng 235 bytes ng libreng RAM. Nasa isang mataas na paggamit na kami ng memorya, at hindi ko nais na magdagdag ng higit pang sample na kapasidad, dahil maaari itong maging sanhi ng mga kakatwang pag-uugali dahil sa napakakaunting puwang ng memorya.

Sa aking pakikipagsapalaran na palaging taasan ang bilis ng pagpapatupad, gumamit ako ng mga point point sa pag-andar sa halip na kung ang mga pahayag sa loob ng mga nakakagambala, upang mabawasan ang kanilang oras ng pagpapatupad sa isang minimum. Ang capture pin ay palaging magiging Arduino UNO bilang 8, dahil ito lang ang konektado sa input capture unit ng Timer1.

Ang proseso ng pagkuha ay ipinapakita sa imahe sa itaas. Nagsisimula ito kapag ang Arduino UNO ay tumatanggap ng isang wastong frame ng data ng UART, na naglalaman ng nais na mga setting ng pagkuha. Pagkatapos ay pinoproseso namin ang mga setting na iyon sa pamamagitan ng pag-configure ng tamang mga rehistro upang makuha ang napiling gilid, at gamitin ang tamang paghati ng orasan. Pagkatapos ay pinagana namin ang PCINT0 (pagbabago ng pin) makagambala upang makita ang unang gilid ng signal. Kapag nakuha namin ito, nai-reset namin ang halaga ng Timer1, hindi pinagana ang PCINT0 makagambala, at paganahin ang ICU (Input Capture Unit) makagambala. Mula sa sandaling iyon, ang anumang pagbagsak / pagtaas ng gilid ng signal (depende sa napili na pagsasaayos), ay magpapalitaw sa input capture unit, kaya't nagse-save ng isang timestamp ng kaganapang ito sa rehistro ng ICR1, at nagpapatupad ng isang nakakagambala. Sa pagkagambala na ito, inilalagay namin ang halaga ng rehistro ng ICR1 sa aming "sample" na array, at pinapataas ang index para sa susunod na makuha. Kapag umapaw ang Timer1 o ang array, hindi namin pinagana ang nakakagambala, at ipinapadala ang data pabalik sa web interface sa pamamagitan ng UART.

Napagpasyahan kong gumamit ng isang pagbabago ng pin na nakakagambala upang ma-trigger ang pagkuha, dahil pinapayagan lamang ng unit ng pagkuha ng pag-capture na makuha ang isa o iba pang gilid, hindi pareho. Nagdudulot din ito ng isang problema kapag nais mong makuha ang parehong mga gilid. Ang aking solusyon ay dapat na baligtarin ang kaunti na kumokontrol sa pagpili ng gilid sa rehistro ng control control ng capture sa bawat sample na nakuha. Sa ganoong paraan maluwag tayo sa bilis ng pagpapatupad, ngunit maaari pa rin nating magamit ang mga pag-andar ng input capture unit.

Kaya, tulad ng napansin mo, hindi talaga namin nakukuha ang bawat sample sa mga takdang agwat ng oras, ngunit kinukuha namin ang sandali kung saan mangyayari ang isang paglipat ng signal. Kung nakakuha kami ng isang sample sa bawat pag-ikot ng orasan, kahit na may pinakamataas na dibisyon ng orasan, mapunan namin ang buffer sa humigit-kumulang na 0.1, sa pag-aakalang gumagamit kami ng uri ng uint8_t, na ang pinakamaliit sa memorya nang hindi gumagamit ng mga struct.

Hakbang 3: Web Interface at P5.js

Tulad ng ipinapahiwatig ng pamagat, ang web interface ay ginawa sa tulong ng p5.js. Para sa mga hindi pa nakakaalam nito, lubos kong inirerekumenda na pumunta ka at suriin ang website, dahil ito ay isang napakahusay na aklatan. Ito ay batay sa Pagproseso, madaling gamitin, pinapayagan kang makakuha ng mahusay na mga resulta nang napakabilis, at mahusay na dokumentado. Para sa lahat ng mga kadahilanang iyon ang pinili ko sa silid-aklatan na ito. Ginamit ko rin ang library ng quicksettings.js para sa mga menu, ang grafica.js na isa upang magbalangkas ng aking data, at ang p5serialport library upang makipag-usap sa Arduino UNO.

Hindi ako gagastos ng sobrang oras sa interface, dahil dinisenyo ko lang ito para sa preview ng data at kontrol sa mga setting, at dahil din hindi ito ang paksa ng aking eksperimento. Gayunpaman ipaliwanag ko sa mga sumusunod na bahagi ang iba't ibang mga hakbang upang magamit ang buong system, sa gayon ay ipinapaliwanag ang iba't ibang mga kontrol na magagamit.

Hakbang 4: Pag-setup ng System

Ang unang bagay ay i-download ang Arduino UNO at interface code dito kung hindi pa nagagawa. Maaari mong mai-program muli ang iyong Arduino UNO board na may sketch na "UNO_LS.ino" sa pamamagitan ng Arduino IDE.

Dapat mong na-download ang p5.serialcontrol software mula sa github repository nito. Kailangan mong makuha ang zip file na tumutugma sa iyong operating system (Sinubukan ko lamang ito sa Windows). I-extract ang zip sa isang folder, simulan ang maipapatupad na matatagpuan dito, at iwanan ito nang ganoon. Huwag subukang kumonekta sa anumang serial port, iwanan lamang itong tumatakbo sa background, gagamitin ito bilang isang relay.

Buksan ang folder na "Interface". Dapat kang makahanap ng isang file na pinangalanang "index.html". Buksan ito sa iyong browser, ito ay ang web interface.

At yun lang! Hindi mo kailangang mag-download ng labis na mga silid-aklatan, dapat isama ang lahat sa ibinigay kong package.

Hakbang 5: Koneksyon, Pag-configure at Pagkuha

Upang ikonekta ang interface sa Arduino UNO board, piliin lamang ang kaukulang port sa listahan at pindutin ang pindutang "Buksan". Kung matagumpay ang operasyon, ang mensahe na "estado" ay dapat magpakita ng isang bagay tulad ng "binuksan ang COMX".

Maaari mo na ngayong piliin ang iyong mga pagpipilian sa pagkuha. Una ay ang pagpili ng gilid. Inirerekumenda ko sa iyo na palaging gamitin ang "Pareho", dahil bibigyan ka nito ng pinakamahusay na representasyon ng tunay na signal. Kung ang setting na "Pareho" ay nabigo upang makuha ang signal (kung ang dalas ng signal ay masyadong mataas halimbawa), maaari mong subukan gamit ang setting na "Tumataas" o "Bumabagsak" na gilid, depende sa signal na sinusubukan mong makita.

Ang pangalawang setting ay ang dibisyon ng orasan. Bibigyan ka nito ng resolusyon kung saan magagawa mong makuha ang signal. Maaari kang pumili upang itakda ang kadahilanan ng paghahati sa alinman sa "8", "64", "256" at "1024". Ang Arduino UNO board ay gumagamit ng isang 16MHz quartz upang mai-orasan ang microcontroller, kaya ang dalas ng sampling ay "16MHz / division factor". Mag-ingat sa setting na ito, dahil matutukoy din nito kung gaano ka katagal makakakuha ng isang senyas. Tulad ng Timer1 ay isang 16bit timer, pinapayagan ang oras ng pagkuha bago ang overflow ay "(2 ^ 16) * (factor ng dibisyon) / 16MHz". Depende sa setting na pinili mo, saklaw ito sa pagitan ng ~ 33ms at 4.2s. Itago ang iyong pagpipilian sa iyong isipan, kakailanganin mo ito sa paglaon.

Ang huling setting ay ang canceller ng ingay. Hindi ako nagsagawa ng maraming pagsubok dito, at hindi mo kakailanganin ito sa 99% ng mga kaso, kaya't iwanan lamang itong naka-check. Para sa mga nagtataka pa rin tungkol dito, maaari kang maghanap para sa pagkansela ng ingay sa seksyong Timer / Counter1 ng datasheet ng ATMEGA328P.

Huwag kalimutan na ikonekta ang pin 8 ng Arduino UNO board sa iyong signal, at i-wire ang mga bakuran upang magkaroon ng parehong sanggunian ng boltahe para sa parehong pagsubok ng circuit at logic analyzer. Kung kailangan mo ng paghihiwalay sa lupa, o kailangan mong sukatin ang mga signal na may mga antas na naiiba sa 5V, malamang na kailangan mong magdagdag ng isang opto-isolator sa iyong circuit.

Kapag na-configure nang tama ang lahat, maaari mong pindutin ang pindutang "Kumuha".

Hakbang 6: Kunin ang Mga Resulta at Pag-export ng Data ng CSV

Kapag natapos ng iyong Arduino UNO ang isang pagkuha, awtomatiko nitong ibabalik ang data sa web interface, na magpaplano sa kanila. Maaari kang mag-zoom in o out gamit ang tamang slider, at maglakbay sa mga sample na may ilalim na isa.

Binibigyan ka lamang ng balangkas ng isang preview, at walang anumang mga tool sa pagtatasa ng data. Kaya, upang magsagawa ng karagdagang pagsusuri sa iyong data, kakailanganin mong i-import ito sa PulseView.

Ang unang hakbang ay upang i-export ang isang csv file na naglalaman ng lahat ng iyong data. Upang magawa ito, kailangan mo lamang mag-click sa pindutang "I-export" mula sa web interface. I-save ang iyong file sa isang kilalang lokasyon kapag na-prompt.

Ngayon buksan ang PulseView. Sa tuktok na menu bar, mag-click sa "Buksan" (icon ng folder), at piliin ang "I-import ang mga halagang pinaghiwalay ng Comma …". Piliin ang dating nabuong csv file na naglalaman ng iyong data.

Lilitaw ang isang maliit na bintana. Iwanan ang lahat ng ito, kailangan mo lamang baguhin ang setting na "Samplerate" alinsunod sa napili ng factor ng orasan para sa pagkuha. Ang dalas ng iyong samplerate ay "16MHz / (division factor)". Pagkatapos mag-click sa "Ok", dapat lumitaw ang iyong signal sa screen.

Hakbang 7: Pagsusuri sa Senyas ng PulseView

Nagtatampok ang PulseView ng maraming mga decoder ng protocol. Upang ma-access ang mga ito, mag-click sa "Magdagdag ng decoder ng protocol" sa tuktok na menu bar (pinaka tamang tool). Para sa aking eksperimento, nagpadala lamang ako ng isang simpleng mensahe ng UART sa 9600 bauds, kaya't hinanap ko ang "UART".

Magdaragdag ito ng isang channel na may isang tag sa kaliwa (tulad ng isa para sa iyong data). Sa pamamagitan ng pag-click sa tag, maaari mong baguhin ang mga setting ng decoder. Matapos mapili ang mga tama, nakuha ko ang parehong mensahe tulad ng ipinadala ng aking pansubok na aparato. Ipinapakita nito na ang buong system ay gumagana tulad ng inaasahan.

Hakbang 8: Konklusyon

Kahit na ang proyekto, sa simula, isang eksperimento, masaya ako sa mga resulta na nakuha ko. Nagawang mai-sample ang mga signal ng UART hanggang sa 115200 baud sa "Parehong" edge mode nang walang anumang problema, at nagawa ko ring umakyat sa 230400 na bauds sa "Falling" edge mode. Maaari mong makita ang aking pag-set up ng pagsubok sa larawan sa itaas.

Ang aking pagpapatupad ay may maraming mga drawbacks, nagsisimula sa pamamagitan ng ang katunayan na maaari lamang itong makuha ang isang senyas nang paisa-isa, dahil ang pin 8 lamang ng Arduino UNO ang "may kakayahan sa pag-capture ng capture". Kung naghahanap ka para sa isang Arduino logic analyzer na may higit pang mga channel, tingnan ang isa sa Catoblepas.

Hindi mo maaasahan ang isang Arduino UNO na makakakuha ng mga signal na may mataas na frequency (ilang MHz), dahil naka-relo lamang ito sa 16MHz (kung may gumawa man, interesado akong makita ang pamamaraan nito). Gayunpaman, humanga pa rin ako sa mga resulta na maaari nating makuha mula sa mikropono ng ATMEGA328P na ito.

Hindi sa palagay ko magagawa ko ang labis na trabaho sa code. Isinasagawa ko ang aking mga eksperimento, at nakuha ang mga resulta na hinahanap ko. Ngunit kung may nais na mag-ambag, huwag mag-atubiling baguhin at ipamahagi muli ang lahat o bahagi ng aking code.

Iyon ang aking unang Instructable, at isang mahaba sa palagay ko. Inaasahan kong ito ay naging isang nakawiwiling pagbabasa para sa iyo.

Ipaalam sa akin kung nakakita ka ng mga error, o kung mayroon kang anumang katanungan!