Arduino UNO Logic Sniffer: 8 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:38

Detta projekt började som ett enkelt experiment. Under min forskning om ATMEGA328P: s datablad för ett annat projekt fann jag något ganska intressant. Timer1 Input Capture Unit. Det gör att vår Arduino UNO: s mikrokontroller kan upptäcka en signalkant, lagra en tidsstämpel och utlösa ett avbrott, allt i hårdvara.

Jag undrade då i vilken applikation det kan vara användbart och hur man testar det. Eftersom jag vill skaffa en logikanalysator ett tag nu bestämde jag mig för att försöka implementera en i min Arduino UNO -kort, bara för att testa funktionen och se om vi kan få bra resultat av den.

Jag är inte den enda som hade den här idén, och du hittar många av dem genom att bara googla "Arduino Logic Analyzer". I början av projektet, eftersom det bara började som ett experiment, var jag inte ens medveten om att folk redan klarade det och blev imponerad av de goda resultaten de uppnådde med denna lilla maskinvara. Jag kunde dock inte hitta ett annat projekt med hjälp av input capture -enheten, så om du redan har sett detta, låt mig veta!

För att sammanfatta kommer min logiska analysator att:

• Ha en kanal,
• Ha ett grafiskt gränssnitt,
• Kommunicera med gränssnittet via USB,
• Kör på en Arduino UNO -bräda.

Den kommer äntligen att ha ett 800 -provsminnesdjup och lyckades fånga ett 115200 bauds UART -meddelande (jag testade det inte riktigt vid högre hastigheter).

Denna instruerbara innehåller både "hur det fungerar" och "hur man använder det" delar av detta projekt, så för dem som inte är intresserade av den tekniska sidan kan du direkt hoppa till steg 4.

Tillbehör

Jag ville hålla analysatorn så enkel som möjligt, så det krävdes väldigt lite hårdvara.

Du kommer behöva:

• Ett Arduino UNO -kort (eller motsvarande så länge det är beroende av ATMEGA328P MCU),
• En dator,
• Något att felsöka (en annan Arduino UNO -styrelse fungerar bra för att göra några tester).

Koden för både Arduino UNO och webbgränssnitt finns här. Du behöver också p5.serialcontrol och PulseView -programvaran.

Steg 1: Arbetsprincip

Tanken är enkel. Du väljer inspelningsinställningarna och klickar på "förvärva". Webbgränssnittet skickar dem till p5.serialcontrol -programvaran, vilket gör att vi kan använda det seriella gränssnittet från en webbläsare, eftersom det inte kan komma åt det direkt. Programvaran p5.serialcontrol vidarebefordrar sedan informationen till Arduino UNO -kortet, som fångar data och skickar dem tillbaka till gränssnittet via samma sökväg.

Lätt! Tja … Eftersom jag inte är riktigt bra på programmering av gränssnitt mellan människor och maskiner eller webbteknik, är min visserligen lite ful och buggig. Men det tillåter mig att starta en fångst och hämta tillbaka mina data, vilket är vad den har utformats för, så jag tycker att det är bra. För mer seriöst analysarbete importerar jag mina poster till PulseView, som är lätt att använda och erbjuder en bra uppsättning funktioner och protokollavkodare, som vi kommer att se senare.

Arduino UNO: s input capture -enhet kan konfigureras för att använda olika klockindelningar, vilket minskar upplösningen, men ökar fördröjningen före överflöd. Det kan också utlösa stigande, fallande eller båda kanterna för att börja fånga data.

Steg 2: Arduino UNO Sketch

Jag skrev och sammanställde skissen med Arduino IDE. Jag började först med att ställa in Timer1 i "Normal" driftläge genom att skriva till dess TCCR1A- och TCCR1B -register i setup (). Jag gjorde sedan några funktioner för att underlätta användningen lite i framtiden, som den som ställde in klockindelningen med namnet "setTim1PSC ()". Jag skrev också funktioner för att aktivera och inaktivera Timer1 -ingångsfångarenheten och överflödsavbrott.

Jag lade till "samplings" -matrisen, som kommer att hålla de inhämtade data. Det är en global matris som jag ställde in på "volatile" för att förhindra att kompilatorn gör optimeringar och sätter den i flash, som den gjorde under mina första sammanställningar. Jag definierade det som en "uint16_t" -matris, eftersom Timer1 också är 16bit, med en längd på 810. Vi slutar fånga med 800 värden, men eftersom testet görs utanför avbrotten av uppenbara hastighetsskäl valde jag att behålla 10 fler värden för att förhindra överflöd. Med några extra variabler för resten av koden använder skissen 1313 byte (88%) minne, vilket ger oss 235 byte ledigt RAM -minne. Vi har redan en hög minnesanvändning och jag ville inte lägga till mer provkapacitet, eftersom det kan orsaka konstiga beteenden på grund av för lite minnesutrymme.

I min strävan att alltid öka exekveringshastigheten använde jag funktionspekare istället för if -satser inuti avbrottet, för att minska deras körningstid till ett minimum. Fångstappen kommer alltid att vara Arduino UNO nummer 8, eftersom den är den enda som är ansluten till Timer1: s input capture -enhet.

Fångstprocessen visas på bilden ovan. Det startar när Arduino UNO tar emot en giltig UART -dataram som innehåller de önskade inställningarna för inspelning. Vi bearbetar sedan dessa inställningar genom att konfigurera de rätta registren för att fånga på den valda kanten och använda rätt klockindelning. Vi aktiverar sedan PCINT0 (stiftbyte) avbrott för att detektera den första signalkanten. När vi får det återställer vi Timer1 -värdet, inaktiverar PCINT0 -avbrottet och aktiverar ICU (Input Capture Unit) -avbrott. Från det ögonblicket kommer varje fallande/stigande kant på signalen (beroende på vald konfiguration) att trigga inmatningsfångarenheten, vilket sparar en tidsstämpel för denna händelse i ICR1 -registret och utför ett avbrott. I detta avbrott lägger vi ICR1 -registervärdet i vår "samplings" -matris och ökar indexet för nästa fångst. När timern1 eller arrayen överflödar inaktiverar vi avbrottsavbrottet och skickar tillbaka data till webbgränssnittet via UART.

Jag bestämde mig för att använda ett stiftbytesavbrott för att utlösa fångsten, eftersom inmatningsenheten bara tillåter att fånga på den ena eller andra kanten, inte båda. Det orsakar också ett problem när du vill fånga båda kanterna. Min lösning har då att vända den bit som styr kantvalet i ingångsregistreringsregistret vid varje prov som hämtas. På det sättet tappar vi i exekveringshastigheten, men vi kan fortfarande använda input capture -enhetens funktioner.

Så, som du kanske har märkt, fångar vi inte riktigt varje prov med fasta tidsintervall, men vi fångar det ögonblick där en signalövergång sker. Om vi hade tagit ett prov vid varje klockcykel, även med den högsta klockindelningen, hade vi fyllt bufferten på cirka 0,1 sekunder, förutsatt att vi använde uint8_t -typen, som är den minsta i minnet utan att använda strukturer.

Steg 3: Webbgränssnitt och P5.js

Som titeln antyder gjordes webbgränssnittet med hjälp av p5.js. För dem som inte vet det redan rekommenderar jag dig starkt att gå och kolla webbplatsen, eftersom det är ett riktigt bra bibliotek. Den är baserad på bearbetning, är lätt att använda, låter dig få bra resultat mycket snabbt och är väl dokumenterad. Det är av alla skäl som jag valde detta bibliotek. Jag använde också quicksettings.js -biblioteket för menyerna, grafica.js -en för att plotta mina data och p5.serialport -biblioteket för att kommunicera med Arduino UNO.

Jag kommer inte att spendera för mycket tid på gränssnittet, eftersom jag just utformade det för förhandsgranskning av data och inställningskontroll, och också för att det inte alls var föremål för mitt experiment. Jag kommer dock att förklara i de följande delarna de olika stegen för att använda hela systemet, och därmed förklara de olika kontrollerna som finns.

Steg 4: Systeminstallation

Det första är att ladda ner Arduino UNO och gränssnittskoden här om det inte redan är gjort. Du kan sedan omprogrammera ditt Arduino UNO -kort med "UNO_LS.ino" -skissen genom Arduino IDE.

Du borde ha laddat ner programvaran p5.serialcontrol från dess github -arkiv. Du måste få zip -filen att matcha ditt operativsystem (jag testade den bara på Windows). Extrahera zip -filen i en mapp, starta den körbara filen som finns i den och låt den vara så. Försök inte ansluta till någon seriell port, låt den bara köras i bakgrunden, den kommer att användas som ett relä.

Öppna mappen "Interface". Du bör hitta en fil som heter "index.html". Öppna den i din webbläsare, det är webbgränssnittet.

Och det är allt! Du behöver inte ladda ner extra bibliotek, allt ska ingå i paketet som jag tillhandahållit.

Steg 5: Anslutning, konfiguration och förvärv

För att ansluta gränssnittet till Arduino UNO -kortet, välj bara motsvarande port i listan och tryck på "Öppna" -knappen. Om operationen lyckades bör meddelandet "tillstånd" visa ungefär "COMX öppnat".

Du kan nu välja dina inspelningsalternativ. Först är kantvalet. Jag rekommenderar dig att alltid använda "Båda", eftersom det ger dig den bästa representationen av den verkliga signalen. Om inställningen "Båda" inte lyckas fånga signalen (om exempelvis signalfrekvensen är för hög) kan du försöka med antingen inställningen "Stigande" eller "Fallande", beroende på vilken signal du försöker se.

Den andra inställningen är klockindelningen. Det ger dig den upplösning vid vilken du kommer att kunna fånga signalen. Du kan välja att ställa in divisionsfaktorn med antingen "8", "64", "256" och "1024". Arduino UNO -kortet använder en 16MHz kvarts för att klocka mikrokontrollern, så samplingsfrekvensen blir "16MHz/divisionsfaktor". Var försiktig med den här inställningen, eftersom den också avgör hur länge du kommer att kunna fånga en signal. Eftersom timern1 är en 16 -bitars timer, är den inspelningstid som tillåts före överflödet "(2^16)*(divisionsfaktor)/16MHz". Beroende på vilken inställning du valt kommer den att sträcka sig mellan ~ 33ms och 4,2s. Ha ditt val i åtanke, du kommer att behöva det senare.

Den sista inställningen är brusreduceraren. Jag testade inte mycket på det, och du kommer inte att behöva det i 99% av fallen, så lämna det helt okontrollerat. För dem som fortfarande är nyfikna på det kan du söka efter brusreduceraren i avsnittet Timer/Counter1 i ATMEGA328P: s datablad.

Glöm inte att ansluta Arduino UNO -kortets stift 8 till din signal och koppla ihop jordarna för att ha samma spänningsreferens för både testkretsen och logikanalysatorn. Om du behöver markisolering eller måste mäta signaler med olika nivåer än 5V, måste du förmodligen lägga till en opto-isolator i din krets.

När allt är korrekt konfigurerat kan du trycka på "Förvärva" -knappen.

Steg 6: Fånga resultat och CSV -dataexport

När din Arduino UNO avslutat en inspelning skickar den automatiskt tillbaka data till webbgränssnittet, som kommer att plotta dem. Du kan zooma in eller ut med det högra reglaget och resa genom proverna med det nedre.

Handlingen ger dig bara en förhandsvisning och har inga dataanalysverktyg. För att kunna göra ytterligare analyser av dina data måste du importera dem till PulseView.

Det första steget är att exportera en csv -fil som innehåller all din data. För att göra det behöver du bara klicka på knappen "Exportera" från webbgränssnittet. Spara filen på en känd plats när du uppmanas.

Öppna nu PulseView. Klicka på "Öppna" (mappikon) i det övre menyraden och välj "Importera kommaseparerade värden …". Välj den tidigare genererade csv -filen som innehåller dina data.

Ett litet fönster visas. Låt allt vara som det är, du behöver bara ändra inställningen "Samplerate" enligt klockindelningsfaktorn som valts för fångst. Din samplingsfrekvens kommer att vara "16MHz/(divisionsfaktor)". Klicka sedan på "Ok", din signal ska visas på skärmen.

Steg 7: PulseView -signalanalys

PulseView har många protokollavkodare. För att komma åt dem, klicka på "Lägg till protokollavkodare" i den övre menyraden (högst till höger). För mitt experiment skickade jag precis ett enkelt UART -meddelande vid 9600 bauds, så jag sökte efter "UART".

Det kommer att lägga till en kanal med en tagg till vänster (precis som den för dina data). Genom att klicka på taggen kan du ändra avkodarens inställningar. Efter att ha valt rätt kunde jag hämta samma meddelande som det som skickades av min testenhet. Detta visar att hela systemet fungerar som förväntat.

Steg 8: Slutsats

Även om projektet i början var ett experiment är jag nöjd med resultaten jag fick. Jag kunde prova UART -signaler på upp till 115200 bauds i "Båda" kantläget utan problem, och jag lyckades till och med gå upp till 230400 bauds i "Falling" edge -läge. Du kan se min testinställning på bilden ovan.

Min implementering har flera nackdelar, som börjar med det faktum att den bara kan fånga en signal i taget, eftersom endast Arduino UNO: s pin 8 är "input capture kapabel". Om du letar efter en Arduino -logikanalysator med fler kanaler, kolla Catoblepas en.

Du kan inte förvänta dig att en Arduino UNO ska kunna fånga signaler med höga frekvenser (vissa MHz), eftersom den bara klockas till 16MHz (om någon gjorde det skulle jag vara intresserad av att se dess metod). Jag är dock fortfarande imponerad av resultaten vi kan få ut av denna ATMEGA328P mikrokontroller.

Jag tror inte att jag kommer att göra mycket arbete med koden. Jag genomförde mina experiment och fick de resultat jag letade efter. Men om någon vill bidra kan du modifiera och omfördela hela eller delar av min kod.

Det var min första instruerbara, och en lång tror jag. Jag hoppas att det har varit en intressant läsning för dig.

Låt mig veta om du hittar fel, eller om du har några frågor!