Arduino som en billig brödbräda FPGA: 5 steg (med bilder)

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

Att designa hårdvarulogikretsar kan vara kul. Det gamla skolans sätt att göra detta var med NAND -portar, på en brödbräda, anslutna med bygelkablar. Detta är fortfarande möjligt, men det tar inte mycket innan antalet portar går ur hand. Ett nyare alternativ är att använda en FPGA (Field Programmable Gate Array). Dessa marker kan koppla om sig själva till att bli en digital logikkrets som du kan designa, men är inte billiga och lättillgängliga. Jag kommer att visa hur denna FPGA kan ersättas med ett billigt Atmega -chip från en Arduino UNO, vilket effektivt sätter den digitala kretsen i ett DIP -paket, vilket är mycket brödbräda.

Steg 1: Utforma kretsen som "FPGA" kommer att representera

Jag bygger en 2 -bitars + 2 -bitars adderare. Den tar två par logiska ingångsstiften och matar ut en triplett av utgångsstiften.

För att göra detta med NAND -grindar, se schemat i bilden. Den behöver 14 NAND -portar. Jag använde 4 quad NAND gate TTL -chips och kopplade dem på brödbrädet.

Jag lade till några lysdioder (glöm inte de nuvarande begränsande motstånden) för att visa när ingångs- och utgångsstiften var på (höga) och när de var av (låga). För att driva ingångsstiften hoppade jag dem antingen till markskenan eller den positiva kraftskenan.

Denna krets fungerar, men den tar redan upp 4 TTL -chips och är ett råttbo av trådar. Om det behövdes fler bitar skulle det finnas fler brödbrädor och fler hoppare. Mycket snabbt skulle kretsens storlek gå ur hand.

På en sidoanteckning, när de arbetar med TTL -grindar matar de inte ut exakt 0V eller 5V som man kan förvänta sig. De matar ofta ut runt 3V för "hög", men den exakta spänningen ligger inom ett mycket brett intervall. Samma krets som använder CMOS -ekvivalenta chips skulle ha bättre exakt 0V till exakt 5V svängningar.

Steg 2: Ange FPGA

En FPGA är ett fantastiskt chip, som bokstavligen kan bli vilken kombination av logiska grindar som är anslutna i alla kombinationer. En designar "kretsen" på ett hårdvarudesignspråk (HDL). Det finns flera sådana språk, varav ett kallas Verilog.. V -filen på bilden är Verilog -ekvivalenten för tvåbitsadderaren.. Pch -filen nedanför är också nödvändig för att tilldela ingångs- och utgångsstiften som nämns i verilog -filen till riktiga hårdvarupinnar på chipet.

I det här fallet använder jag en Lattice Semiconductors iCEstick utvecklingskort (https://www.latticesemi.com/icestick). Själva FPGA-chipet är ett iCE40HX-1k, med lite över 1000 grindar, som var och en kan bli vilken logikport som helst. Det betyder att varje grind kan vara en NAND -grind, eller en ELLER -grind, INTE grind, NOR, XOR, etc. Dessutom kan varje grind hantera mer än två ingångar. Detta är specifikt för varje tillverkare, men på iCE40 kan varje grind hantera 4 ingångar. Således är varje grind mycket mer kapabel än de två ingångarna NAND -portar.

Jag var tvungen att tilldela de fyra ingångs tallarna och de tre utgångsstiften till de fysiska stiften 91, 90, 88, 87, 81, 80 och 79. Detta är specifikt för fpga -chipet och utbrottskortet det är på och hur dessa stift är anslutna till PMOD -porten. Detta är tillgängligt i databladet för detta FPGA -kort.

Lattice tillhandahåller sin egen verktygskedja för att syntetisera (FPGA motsvarar kompilering för CPU: er) kretsar från Verilog, men jag använde gratis open source tool chain chain icestorm (https://www.clifford.at/icestorm/). Installationsanvisningarna finns på den webbplatsen. Med isstorm installerad och verilog- och pcf -filen är kommandona för att ladda denna krets till FPGA:

yosys -p "synth_ice40 -blif twoBitAdder.v" twoBitAdder.blif

arachne -pnr -d 1k -p iCEstick.pcf twoBitAdder.blif -o twoBitAdder.asc

icepack twoBitAdder.asc twoBitAdder.bin

iceprog twoBitAdder.bin

Detta fungerar bra, men att inkludera leverans av denna iCEstick kommer att kosta cirka $ 30. Detta är inte det billigaste sättet att bygga en digital krets, men det är kraftfullt. Den har över 1000 grindar och för denna lilla krets använder den bara 3 av dem. NAND -portekvivalenten använde 14 grindar. Detta beror på det faktum att varje gate kan bli vilken typ av gate som helst, och varje gate är faktiskt en 4 input gate. Varje grind kan göra mer. Om du behöver fler grindar har iCEstick en storebror med 8000 grindar, det kostar ungefär dubbelt. Andra tillverkare har andra erbjudanden men priset kan bli ganska brant.

Steg 3: Från FPGA till Arduino

FPGA är bra, men kan vara dyrt, svårt att få tag på och är inte särskilt brödvänligt. Ett brödbrädvänligt och billigt chip är Atmega 328 P, som kommer i ett snyggt DIP -paket, perfekt för brädbräda. Det kan också fås för cirka $ 4. Detta är hjärtat i Arduino UNO. Du kan naturligtvis använda hela UNO, men var billig, vi kan dra Atmega 328 P från UNO och använda den själv. Jag använde dock UNO -kortet som programmerare för Atmega.

Vid denna tidpunkt behöver du

1. En Arduino UNO, med avtagbar Atmega 328P CPU.

2. En annan Atmega 328P med Arduino bootloader förbränd, för att ersätta den vi ska ta ut ur UNO. (Valfritt förutsatt att du fortfarande vill ha en användbar UNO).

Målet är att konvertera verilog -filen till ett arduino -projekt som kan laddas in i 328P. Arduino är baserat på C ++. Det finns bekvämt en översättare från Verilog till C ++, kallad Verilator (https://www.veripool.org/wiki/verilator). Verilator är avsett att användas av hårdvarudesigners som behöver simulera sina mönster innan de överlämnar dessa mönster till dyr hårdvara. Verilator cross kompilerar veriloggen till C ++, sedan tillhandahåller användaren en testkabel för att tillhandahålla simulerade insignaler och registrera utsignalerna. Vi kommer att använda den för att klämma in verilogdesignen i Atmega 328P med hjälp av Arduino -verktygskedjan.

Installera först Verilator. Följ instruktionerna på

Installera också Arduino IDE och testa att den kan ansluta till Arduino UNO via USB.

Vi kommer att använda samma verilog -fil som för FPGA, förutom att namnen på stiften måste ändras. Jag lade till en understrykning (_) i början av varje. Detta behövs eftersom arduino -biblioteken innehåller en rubrikfil som översätter saker som B0, B001, etc, till binära tal. De andra namnen på inmatningsstiftet hade varit bra som de är, men B0 och B1 skulle ha orsakat att byggnaden misslyckades.

Kör följande i katalogen som innehåller twoBitAdder.v och iCEstick.pcf:

verilator -Wall --cc twoBitAdder.v

Detta skapar en underkatalog som heter obj_dir som innehåller flera nya filer. Vi behöver bara header- och cpp -filerna, VtwoBitAdder.h, VtwoBitAdder.cpp, VtwoBitAdder_Syms.h och VtwoBitAdder_Syms.cpp.

Skapa en ny skiss i Arduino IDE som heter twoBitAdder.ino. Detta skapar ino -filen i en ny katalog som också kallas twoBitAdder, inuti din Arduino -skissbokskatalog. Kopiera dina VtwoBitAdder.h- och VtwoBitAdder.cpp -filer till denna twoBitAdder -mapp i din Arduino -mapp.

Kopiera nu rubrikfilerna från verilatorinstallationen.

cp/usr/local/share/verilator/include/verilated*.

Slutligen kopiera i std c ++ biblioteket från https://github.com/maniacbug/StandardCplusplus. Enligt deras installationsinstruktioner "Detta installeras precis som ett vanligt Arduino -bibliotek. Packa upp innehållet i distributionen i mappen" bibliotek "under din skissbok. Min skissbok är till exempel på/home/maniacbug/Source/Arduino, så det här biblioteket är i/home/galning/Källa/Arduino/bibliotek/StandardCplusplus.

Var noga med att återställa din Arduino IDE efter installationen."

Ersätt nu innehållet i twoBitAdder.ino med det som finns i detta steg. Detta är en testkabel som verilatorn förväntar sig, som ställer in ingångs-/utgångsstiften, sedan i slingan, läser ingångsstiften, matar dem till VtwoBitAdder (den översatta versionen av vår krets), läser sedan utgångarna från VtwoBitAdder och applicerar dem till utgångsstiften.

Detta program bör sammanställa och köra på Arduino UNO.

Steg 4: Från Arduino till DIP Chip på ett brödbräda

Nu när programmet körs på Arduino behöver vi inte längre själva Arduino -kortet. Allt vi behöver är CPU: n.

Ta försiktigt ut Atmega 328P från Arduino UNO -uttaget och sätt eventuellt i den.

Lägg Atmega 328P på brödbrädan. Lägg slutet med divoten pekande upp på brödbrädet. Stift 1 är den övre vänstra stiftet. Stift 2 är nästa ner, och så vidare till stift 14 som finns längst ner till vänster. Då är stift 15 längst ner till höger, och stift 16 till 28 räknar tillbaka upp på högra sidan av chipet.

Anslut stift 8 och 22 till jord.

Anslut stift 7 till VCC (+5V).

Anslut en 16Mhz kvartskristall mellan stiften 9 och 10. Även en liten kondensator (22pF) mellan stift 9 och jord, och mellan stift 10 och jord. Detta ger Atmega 328P 16Mhz klockhastighet. Det finns instruktioner någon annanstans om att lära 328P att istället använda sin interna 8Mhz -klocka vilket skulle spara ett par delar, men det skulle sakta ner processorn.

Arduino GPIO -portarna 5, 6, 7 och 8, som vi använde för ingångsstiften är faktiskt de fysiska stiften 11, 12, 13, 14 på Atmega 328P. Det skulle vara de fyra nedre stiften till vänster.

Arduino GPIO -portarna 11, 10 och 9, som vi använde för utgångsstiften är faktiskt de fysiska stiften 17, 16, 15 på Atmega 328P. Det skulle vara de tre nedre stiften till höger.

Jag kopplade upp lysdioderna till dessa stift som tidigare.

Steg 5: Slutsats

TTL -chips fungerar, men det krävs många av dem för att bygga någonting. FPGA fungerar riktigt bra, men är inte billiga. Om du kan leva med färre IO -stift och lägre hastighet kan en Atmega 328P vara chipet för dig.

Några saker att tänka på:

FPGA:

Proffs

- Kan hantera höghastighetssignaler. Eftersom det inte finns någon CPU för flaskhalsbearbetning ner till en instruktion i taget, är den begränsande faktorn utbredningsfördröjningen genom grindarna på den givna kretsen. I många fall kan detta vara mycket snabbare än klockan som medföljer chipet. För min design skulle den beräknade fördröjningen ha gjort det möjligt för twoBitAdder att svara på cirka 100 miljoner förändringar i ingångsvärden per sekund (100Mhz) även om inbyggd klocka bara är en 12Mhz kristall.

- När designen blir mer komplex försämras inte prestandan för de befintliga kretsarna (mycket). Eftersom att lägga till kretsar till tyget helt enkelt är att sätta något nytt i oanvänd fastighet, påverkar det inte befintliga kretsar.

- Beroende på FPGA kan antalet tillgängliga IO -stift vara mycket högt, och de är i allmänhet inte låsta till något särskilt syfte.

Lura

- Kan vara dyrt och/eller svårt att få tag på.

- Vanligtvis kommer det i ett BGA -paket som kräver någon form av utbrottskort för att arbeta med chipet i alla amatörprojekt. Om du bygger det till en design med en anpassad flerskiktad SMT-kretskort är detta inget problem.

- De flesta FPGA -tillverkare tillhandahåller sin egen programvara med sluten källkod, som i vissa fall kan kosta pengar eller ha ett licensutgångsdatum.

Arduino som en FPGA:

Proffs

- Billigt och lätt att få. Sök bara efter atmega328p-pu på Amazon. De borde vara cirka $ 4/styck. Flera säljare säljer dem i massor av 3 eller 4.

- Detta är ett DIP -paket, vilket betyder att det passar perfekt på en brödbräda med sina yttre stift.

- Detta är en 5V -enhet, som kan göra gränssnittet med andra 5V -enheter enkelt.

Lura

- ATMEGA328P har ett begränsat antal IO -stift (23), och flera av dem är reserverade för specifika uppgifter.

- När kretsens komplexitet ökar ökar mängden kod som körs i Arduino loop -metoden, vilket innebär att varaktigheten för varje cykel är längre.

- Även om kretsens komplexitet är låg, kräver varje cykel många CPU -instruktioner för att hämta ingångsstiftvärdena och skriva utgångsstiftvärden och återgå till toppen av slingan. Med en 16Mhz kristall, även vid en instruktion per klockcykel, kommer slingan inte att gå mer än kanske 1 miljon gånger per sekund (1Mhz). För de flesta amatörelektronikprojekt är det dock mycket snabbare än det behövs.