Arduino UNO Logic Sniffer: 8 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:21

Dette prosjektet startet som et enkelt eksperiment. Under min undersøkelse av ATMEGA328Ps datablad for et annet prosjekt, fant jeg noe ganske interessant. Timer1 Input Capture Unit. Det lar vår Arduino UNOs mikrokontroller oppdage en signalkant, lagre et tidsstempel og utløse et avbrudd, alt i maskinvare.

Jeg lurte på i hvilken applikasjon det kan være nyttig, og hvordan jeg kan teste det. Ettersom jeg ønsker å få en logisk analysator en stund nå, bestemte jeg meg for å prøve å implementere en i Arduino UNO -kortet, bare for å teste funksjonen og se om vi kan få gode resultater ut av det.

Jeg er ikke den eneste som hadde denne ideen, og du vil finne mange av dem ved bare å google "Arduino Logic Analyzer". I begynnelsen av prosjektet, da det bare begynte som et eksperiment, var jeg ikke engang klar over at folk allerede klarte det, og ble imponert over de gode resultatene de oppnådde med denne lille maskinvaren. Imidlertid kunne jeg ikke finne et annet prosjekt ved å bruke input capture -enheten, så hvis du allerede har sett dette, gi meg beskjed!

For å oppsummere, vil min logiske analysator:

• Ha en kanal,
• Ha et grafisk grensesnitt,
• Kommuniser med grensesnittet via USB,
• Kjør på et Arduino UNO -brett.

Den vil endelig ha en 800 -eksemplers minnedybde, og klarte å fange en 115200 bauds UART -melding (jeg testet den egentlig ikke ved høyere hastigheter).

Denne instruksen inneholder både "hvordan det fungerer" og "hvordan du bruker det" deler av dette prosjektet, så for de som ikke er interessert av den tekniske siden, kan du hoppe direkte til trinn 4.

Rekvisita

Jeg ønsket å holde analysatoren så enkel som mulig, så det krever veldig lite maskinvare.

Du vil trenge:

• Et Arduino UNO -kort (eller tilsvarende så lenge det er avhengig av ATMEGA328P MCU),
• En datamaskin,
• Noe å feilsøke (et annet Arduino UNO -bord fungerer fint for å gjøre noen tester).

Koden for både Arduino UNO og webgrensesnitt finner du her. Du trenger også p5.serialcontrol og PulseView -programvaren.

Trinn 1: Arbeidsprinsipp

Ideen er enkel. Du velger fangstinnstillingene, og klikker på "anskaff". Nettgrensesnittet sender dem til p5.serialcontrol -programvaren, som lar oss bruke det serielle grensesnittet fra en nettleser, ettersom det ikke har direkte tilgang til det. Programvaren p5.serialcontrol videresender deretter informasjonen til Arduino UNO -kortet, som fanger opp dataene, og sender dem tilbake til grensesnittet gjennom den samme banen.

Lett! Vel … Siden jeg egentlig ikke er god til programmering av grensesnitt mellom mennesker og maskiner eller webteknologier, er min absolutt litt stygg og buggy. Men det lar meg starte en fangst og hente dataene mine tilbake, som er det de er designet for, så jeg synes det er greit. For mer seriøst analysearbeid importerer jeg postene mine til PulseView, som er enkel å bruke og tilbyr et godt sett med funksjoner og protokolldekodere, som vi får se senere.

Arduino UNOs input capture -enhet kan konfigureres til å bruke forskjellige klokkeinndelinger, og dermed redusere oppløsningen, men øke forsinkelsen før overløp. Det kan også utløse stigende, fallende eller begge kanter for å begynne å fange dataene.

Trinn 2: Arduino UNO Sketch

Jeg skrev og kompilerte skissen med Arduino IDE. Jeg begynte først med å sette opp Timer1 i "Normal" driftsmodus ved å skrive til TCCR1A- og TCCR1B -registret i oppsettet (). Jeg lagde deretter noen funksjoner for å lette bruken i fremtiden, for eksempel den som skulle stille klokkedivisjonen med navnet "setTim1PSC ()". Jeg skrev også funksjoner for å aktivere og deaktivere Timer1 input capture unit og overløp avbryter.

Jeg la til "samples" -arrayen, som vil beholde dataene som er ervervet. Det er en global matrise som jeg setter til "flyktig" for å forhindre at kompilatoren foretar optimaliseringer og setter den i blits, slik den gjorde under min første samling. Jeg definerte det som en "uint16_t" matrise, ettersom Timer1 også er 16bit, med en lengde på 810. Vi slutter å fange på 800 verdier, men ettersom testen er gjort utenfor avbruddene av åpenbare hastighetshensyn, valgte jeg å beholde 10 flere verdier for å forhindre overløp. Med noen få ekstra variabler for resten av koden bruker skissen 1313 byte (88%) minne, og etterlater oss 235 byte ledig RAM. Vi har allerede et høyt minnebruk, og jeg ønsket ikke å legge til mer prøvekapasitet, da det kan forårsake merkelig atferd på grunn av for lite minneplass.

I min søken etter å alltid øke kjøringshastigheten brukte jeg funksjonspekere i stedet for hvis setninger inne i avbruddene, for å redusere utførelsestiden til et minimum. Fangstappen vil alltid være Arduino UNO nummer 8, siden den er den eneste som er koblet til Timer1s input capture -enhet.

Opptaksprosessen er vist på bildet ovenfor. Den starter når Arduino UNO mottar en gyldig UART -dataramme, som inneholder de ønskede fangstinnstillingene. Vi behandler deretter disse innstillingene ved å konfigurere de riktige registerene for å fange på den valgte kanten, og bruke den riktige klokkedivisjonen. Vi aktiverer deretter PCINT0 (pin change) avbrudd for å oppdage den første signalkanten. Når vi får det, tilbakestiller vi Timer1 -verdien, deaktiverer PCINT0 -avbruddet og aktiverer ICU (Input Capture Unit) -avbrudd. Fra det øyeblikket vil enhver fallende/stigende kant på signalet (avhengig av valgt konfigurasjon) utløse inngangsfanger -enheten, og dermed lagre et tidsstempel for denne hendelsen i ICR1 -registeret og utføre et avbrudd. I dette avbruddet setter vi ICR1 -registerverdien i "prøver" -arrayen vår, og øker indeksen for neste fangst. Når Timer1 eller matrisen flyter over, deaktiverer vi fangstavbruddet og sender dataene tilbake til webgrensesnittet via UART.

Jeg bestemte meg for å bruke en pin -change interrupt for å utløse fangst, ettersom input capture -enheten bare tillater å fange på den ene eller den andre kanten, ikke begge deler. Det forårsaker også et problem når du vil fange begge kantene. Min løsning har da vært å snu biten som styrer kantvalget i inputregistreringsregistret ved hver prøve som hentes. På den måten mister vi kjøringshastigheten, men vi kan fortsatt bruke funksjonene for input capture -enhet.

Så, som du kanskje har lagt merke til, fanger vi ikke egentlig hver prøve med faste tidsintervaller, men vi fanger øyeblikket hvor en signalovergang skjer. Hvis vi hadde tatt en prøve i hver klokkesyklus, selv med den høyeste klokkedivisjonen, ville vi fylt bufferen på omtrent 0,1 sekunder, forutsatt at vi brukte uint8_t -typen, som er den minste i minnet uten å bruke strukturer.

Trinn 3: Webgrensesnitt og P5.js

Som tittelen tilsier, ble webgrensesnittet laget ved hjelp av p5.js. For de som ikke vet det allerede, anbefaler jeg deg å gå og sjekke nettstedet, siden det er et veldig godt bibliotek. Den er basert på prosessering, er enkel å bruke, lar deg få gode resultater veldig raskt og er godt dokumentert. Det er av alle grunnene at jeg valgte dette biblioteket. Jeg brukte også quicksettings.js -biblioteket til menyene, grafica.js -en til å plotte dataene mine og p5.serialport -biblioteket for å kommunisere med Arduino UNO.

Jeg vil ikke bruke for mye tid på grensesnittet, ettersom jeg nettopp designet det for forhåndsvisning av data og innstillingskontroll, og også fordi det ikke var gjenstand for eksperimentet mitt i det hele tatt. Jeg vil imidlertid forklare i de følgende delene de forskjellige trinnene for å bruke hele systemet, og dermed forklare de forskjellige kontrollene som er tilgjengelige.

Trinn 4: Systemoppsett

Det første er å laste ned Arduino UNO og grensesnittkoden her hvis det ikke allerede er gjort. Du kan deretter omprogrammere Arduino UNO -kortet ditt med "UNO_LS.ino" -skissen gjennom Arduino IDE.

Du burde ha lastet ned programvaren p5.serialcontrol fra github -depotet. Du må få zip -filen som samsvarer med operativsystemet ditt (jeg testet den bare på Windows). Pakk ut zip -filen i en mappe, start den kjørbare filen som finnes i den, og la den være slik. Ikke prøv å koble til en seriell port, bare la den kjøre i bakgrunnen, den vil bli brukt som et relé.

Åpne "Interface" -mappen. Du bør finne en fil som heter "index.html". Åpne den i nettleseren din, det er nettgrensesnittet.

Og det er det! Du trenger ikke å laste ned ekstra biblioteker, alt skal være inkludert i pakken jeg ga.

Trinn 5: Tilkobling, konfigurasjon og oppkjøp

For å koble grensesnittet til Arduino UNO -kortet, bare velg den tilhørende porten i listen og trykk på "Åpne" -knappen. Hvis operasjonen var vellykket, skulle meldingen "tilstand" vise noe som "COMX åpnet".

Du kan nå velge opptaksalternativer. Først er kantvalget. Jeg anbefaler deg å alltid bruke "Begge", da det vil gi deg den beste representasjonen av det virkelige signalet. Hvis innstillingen "Begge" ikke klarer å fange signalet (hvis for eksempel signalfrekvensen er for høy), kan du prøve med enten "stigende" eller "fallende" kantinnstilling, avhengig av signalet du prøver å se.

Den andre innstillingen er klokkeinndeling. Det vil gi deg oppløsningen der du vil kunne fange signalet. Du kan velge å sette divisjonsfaktoren med enten "8", "64", "256" og "1024". Arduino UNO -kortet bruker en 16MHz kvarts for å klokke mikrokontrolleren, så samplingsfrekvensen vil være "16MHz/divisjonsfaktor". Vær forsiktig med denne innstillingen, da den også bestemmer hvor lenge du vil kunne fange et signal. Siden Timer1 er en 16 -biters timer, vil fangsttiden som er tillatt før overløp være "(2^16)*(divisjonsfaktor)/16MHz". Avhengig av innstillingen du valgte, vil den variere mellom ~ 33ms og 4,2s. Hold ditt valg i tankene dine, du trenger det senere.

Den siste innstillingen er støydemping. Jeg testet ikke mye på det, og du trenger det ikke i 99% av tilfellene, så la det være ukontrollert. For de som fremdeles er nysgjerrige på det, kan du søke etter støyreduksjonen i Timer/Counter1 -delen av ATMEGA328Ps datablad.

Ikke glem å koble Arduino UNO -kortets pin 8 til signalet ditt, og koble jordene sammen for å ha samme spenningsreferanse for både testkretsen og logikkanalysatoren. Hvis du trenger bakkeisolasjon, eller måler signaler med forskjellige nivåer enn 5V, må du sannsynligvis legge til en opto-isolator i kretsen din.

Når alt er konfigurert riktig, kan du trykke på "Skaff" -knappen.

Trinn 6: Registrer resultater og eksport av CSV -data

Når din Arduino UNO er ferdig med en fangst, sender den automatisk dataene tilbake til webgrensesnittet, som plotter dem. Du kan zoome inn eller ut med høyre glidebryter, og reise gjennom prøvene med den nederste.

Plottet gir deg bare en forhåndsvisning, og har ingen dataanalyseverktøy. For å kunne foreta ytterligere analyse av dataene dine må du importere dem til PulseView.

Det første trinnet er å eksportere en csv -fil som inneholder alle dataene dine. For å gjøre det trenger du bare å klikke på "Eksporter" -knappen fra webgrensesnittet. Lagre filen på et kjent sted når du blir bedt om det.

Åpne nå PulseView. Klikk på "Åpne" (mappeikon) på den øverste menylinjen, og velg "Importer kommaseparerte verdier …". Velg den tidligere genererte csv -filen som inneholder dataene dine.

Et lite vindu vil vises. La alt være som det er, du trenger bare å endre "Samplerate" -innstillingen i henhold til klokkedelingsfaktoren som er valgt for fangst. Samplingsfrekvensen din vil være "16MHz/(divisjonsfaktor)". Klikk deretter på "Ok", signalet ditt skal vises på skjermen.

Trinn 7: PulseView -signalanalyse

PulseView har mange protokolldekodere. For å få tilgang til dem, klikk på "Legg til protokolldekoder" i den øverste menylinjen (verktøyet til høyre). For mitt eksperiment sendte jeg nettopp en enkel UART -melding på 9600 bauds, så jeg søkte etter "UART".

Den vil legge til en kanal med en tagg til venstre (akkurat som den for dataene dine). Ved å klikke på taggen kan du endre dekoderens innstillinger. Etter å ha valgt de riktige, kunne jeg hente den samme meldingen som den som ble sendt av min testenhet. Dette viser at hele systemet fungerer som forventet.

Trinn 8: Konklusjon

Selv om prosjektet i begynnelsen var et eksperiment, er jeg fornøyd med resultatene jeg fikk. Jeg var i stand til å prøve UART -signaler på opptil 115200 bauds i "Begge" kantmodus uten problemer, og jeg klarte til og med å gå opp til 230400 bauds i "Falling" kantmodus. Du kan se testoppsettet mitt på bildet ovenfor.

Implementeringen min har flere ulemper, og starter med at den bare kan fange ett signal om gangen, siden bare Arduino UNOs pin 8 er "input capture capable". Hvis du søker etter en Arduino logisk analysator med flere kanaler, kan du sjekke Catoblepas sin.

Du kan ikke forvente at en Arduino UNO kan fange signaler med høye frekvenser (noen MHz), da den bare er klokket til 16MHz (hvis noen gjorde det, ville jeg være interessert i å se metoden). Imidlertid er jeg fortsatt imponert over resultatene vi kan få ut av denne ATMEGA328P mikrokontrolleren.

Jeg tror ikke at jeg kommer til å gjøre mye arbeid med koden. Jeg utførte eksperimentene mine og fikk resultatene jeg lette etter. Men hvis noen vil bidra, kan du endre og distribuere hele eller deler av koden min.

Det var min første Instructable, og en lang tror jeg. Jeg håper det har vært interessant lesning for deg.

Gi meg beskjed hvis du finner feil, eller hvis du har spørsmål!