Arduino als een goedkope breadboard FPGA - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Het ontwerpen van hardware-logische circuits kan leuk zijn. De ouderwetse manier om dit te doen was met NAND-poorten, op een breadboard, bedraad met jumperdraden. Dat kan nog, maar het duurt niet lang voordat het aantal poortjes uit de hand loopt. Een nieuwere optie is om een FPGA (Field Programmable Gate Array) te gebruiken. Deze chips kunnen zichzelf opnieuw bedraden om elk digitaal logisch circuit te worden dat je kunt ontwerpen, maar zijn niet goedkoop en gemakkelijk verkrijgbaar. Ik zal laten zien hoe deze FPGA kan worden vervangen door een goedkope Atmega-chip van een Arduino UNO, waardoor het digitale circuit effectief in een DIP-pakket wordt geplaatst, dat zeer breadboard-vriendelijk is.

Stap 1: Ontwerp het circuit dat de "FPGA" zal vertegenwoordigen

Ik zal een 2 bit + 2 bit opteller bouwen. Er zijn twee paar logische ingangspinnen nodig en er wordt één triplet uitgangspinnen uitgevoerd.

Om dit te doen met NAND-poorten, zie het schema in de afbeelding. Het heeft 14 NAND-poorten nodig. Ik heb 4 quad NAND-poort TTL-chips gebruikt en ze op het breadboard aangesloten.

Ik heb een aantal LED's toegevoegd (vergeet de stroombeperkende weerstanden niet) om te laten zien wanneer de ingangs- en uitgangspinnen aan waren (hoog) en wanneer ze uit waren (laag). Om de invoerpinnen aan te drijven, heb ik ze ofwel naar de grondrail of de positieve stroomrail gesprongen.

Dit circuit werkt, maar het neemt al 4 TTL-chips in beslag en is een rattennest van draden. Als er meer bits nodig waren, zouden er meer broodplanken en meer jumpers zijn. Al snel zou de omvang van het circuit uit de hand lopen.

Even terzijde, wanneer ze met TTL-poorten werken, geven ze niet precies 0V of 5V uit zoals je zou verwachten. Ze geven vaak ongeveer 3V af voor "hoog", maar de exacte spanning ligt in een zeer breed bereik. Hetzelfde circuit dat de CMOS-equivalente chips gebruikt, zou beter precies 0V tot precies 5V-schommelingen hebben.

Stap 2: Voer de FPGA in

Een FPGA is een fantastische chip, die letterlijk elke combinatie van logische poorten kan worden, met elkaar verbonden in elke combinatie. Men ontwerpt het "circuit" in een hardware-ontwerptaal (HDL). Er zijn meerdere van dergelijke talen, waarvan er één Verilog wordt genoemd. Het.v-bestand in de afbeelding is het Verilog-equivalent van de twee-bits opteller. Het.pch-bestand eronder is ook nodig om de invoer- en uitvoerpinnen die in het verilog-bestand worden genoemd, toe te wijzen aan echte hardwarepinnen op de chip.

In dit geval gebruik ik een Lattice Semiconductors iCEstick-ontwikkelbord (https://www.latticesemi.com/icestick). De eigenlijke FPGA-chip is een iCE40HX-1k, met iets meer dan 1000 poorten, die elk elke logische poort kunnen worden. Dat betekent dat elke poort een NAND-poort kan zijn, of een OF-poort, NIET-poort, NOR, XOR, enz. Bovendien kan elke poort meer dan twee ingangen verwerken. Dit is specifiek voor elke fabrikant, maar op de iCE40's kan elke poort 4 ingangen verwerken. Elke poort is dus veel beter in staat dan de 2 NAND-ingangen.

Ik moest de 4 invoerpinnen en de 3 uitvoerpinnen toewijzen aan respectievelijk fysieke pinnen 91, 90, 88, 87, 81, 80 en 79. Dit is specifiek voor de fpga-chip en het breakout-bord waarop deze zich bevindt, en hoe die pinnen zijn aangesloten op de PMOD-poort. Dit is beschikbaar in de datasheets van dit FPGA-bord.

Lattice biedt hun eigen gereedschapsketen voor het synthetiseren (het FPGA-equivalent van compilatie voor CPU's) circuits van Verilog, maar ik gebruikte de gratis open source gereedschapsketen icestorm (https://www.clifford.at/icestorm/). De installatie-instructies zijn beschikbaar op die site. Met icestorm geïnstalleerd en het verilog- en pcf-bestand, zijn de opdrachten om dit circuit op de FPGA te laden:

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

Dit werkt prima, maar inclusief verzending kost deze iCEstick ongeveer $ 30. Dit is niet de goedkoopste manier om een digitaal circuit te bouwen, maar het is krachtig. Het heeft meer dan 1000 poorten en voor dit kleine circuit worden er maar 3 gebruikt. Het NAND-poortequivalent gebruikte 14 poorten. Dit is te wijten aan het feit dat elke poort elke soort poort kan worden, en elke poort is eigenlijk een poort met 4 ingangen. Elke poort kan meer. Als je meer poorten nodig hebt, heeft de iCEstick een grotere broer met 8000 poorten, die ongeveer het dubbele kost. Andere fabrikanten hebben andere aanbiedingen, maar de prijs kan behoorlijk hoog worden.

Stap 3: Van FPGA naar Arduino

FPGA's zijn geweldig, maar kunnen duur zijn, moeilijk te verkrijgen en niet erg gebruiksvriendelijk. Een breadboard-vriendelijke en goedkope chip is de Atmega 328 P, die wordt geleverd in een nette DIP-verpakking, perfect voor breadboarden. Het is ook te krijgen voor ongeveer $ 4. Dit is het hart van de Arduino UNO. Je zou natuurlijk de hele UNO kunnen gebruiken, maar als je goedkoop bent, kunnen we de Atmega 328 P van de UNO halen en hem alleen gebruiken. Ik heb wel het UNO-bord gebruikt als programmeur voor de Atmega.

Op dit punt heb je nodig

1. Een Arduino UNO, met de verwijderbare Atmega 328P CPU.

2. Nog een Atmega 328P met de Arduino-bootloader voorgebrand, ter vervanging van degene die we uit de UNO gaan halen. (Optioneel ervan uitgaande dat je nog steeds een bruikbare UNO wilt hebben).

Het doel is om het verilog-bestand om te zetten in een arduino-project dat in de 328P kan worden geladen. Arduino is gebaseerd op C++. Handig is dat er een vertaler is van Verilog naar C++, genaamd Verilator (https://www.veripool.org/wiki/verilator). Verilator is bedoeld om te worden gebruikt door hardware-ontwerpers die hun ontwerpen moeten simuleren voordat ze die ontwerpen op dure hardware toepassen. Verilator Cross compileert de verilog naar C++, waarna de gebruiker een testharnas levert om gesimuleerde ingangssignalen te leveren en de uitgangssignalen vast te leggen. We gaan het gebruiken om het verilog-ontwerp in de Atmega 328P te proppen met behulp van de Arduino-gereedschapsketen.

Installeer eerst Verilator. Volg de instructies op

Installeer ook de Arduino IDE en test of deze via USB verbinding kan maken met de Arduino UNO.

We zullen hetzelfde verilog-bestand gebruiken als voor de FPGA, behalve dat de namen van de pinnen moeten worden gewijzigd. Ik heb een onderstrepingsteken (_) aan het begin van elk toegevoegd. Dit is nodig omdat de arduino-bibliotheken een headerbestand bevatten dat zaken als B0, B001, enz. vertaalt naar binaire getallen. De andere namen van de invoerpin zouden prima zijn zoals ze zijn, maar B0 en B1 zouden ervoor hebben gezorgd dat de build is mislukt.

Voer in de map met twoBitAdder.v en iCEstick.pcf het volgende uit:

verilator -Wall --cc twoBitAdder.v

Dit zal een submap maken met de naam obj_dir die verschillende nieuwe bestanden bevat. We hebben alleen de header- en cpp-bestanden nodig, VtwoBitAdder.h, VtwoBitAdder.cpp, VtwoBitAdder_Syms.h en VtwoBitAdder_Syms.cpp.

Maak in de Arduino IDE een nieuwe schets met de naam twoBitAdder.ino. Hiermee wordt het ino-bestand gemaakt in een nieuwe map, ook wel twoBitAdder genoemd, in uw Arduino-schetsboekmap. Kopieer uw VtwoBitAdder.h- en VtwoBitAdder.cpp-bestanden naar deze twoBitAdder-map in uw Arduino-map.

Kopieer nu de header-bestanden van de verilator-installatie.

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

kopieer ten slotte in de std c++-bibliotheek van https://github.com/maniacbug/StandardCplusplus. Volgens hun installatie-instructies Dit is net als een gewone Arduino-bibliotheek geïnstalleerd. Pak de inhoud van de distributie uit in de map 'bibliotheken' onder uw schetsboek. Mijn schetsboek bevindt zich bijvoorbeeld in /home/maniacbug/Source/Arduino, dus deze bibliotheek bevindt zich in /home/maniacbug/Bron/Arduino/libraries/StandardCplusplus.

Zorg ervoor dat u uw Arduino IDE reset nadat u deze hebt geïnstalleerd."

Vervang nu de inhoud van twoBitAdder.ino door die in deze stap. Dit is een testharnas dat verilator verwacht, dat de invoer- / uitvoerpinnen instelt, vervolgens in de lus, de invoerpinnen leest, ze naar de VtwoBitAdder (de vertaalde versie van ons circuit) voert en vervolgens de uitvoer van VtwoBitAdder leest en van toepassing is ze naar de uitgangspinnen.

Dit programma moet compileren en uitvoeren op de Arduino UNO.

Stap 4: Van Arduino naar DIP-chip op een breadboard

Nu het programma op de Arduino draait, hebben we het Arduino-bord zelf niet meer nodig. Het enige wat we nodig hebben is de CPU.

Verwijder de Atmega 328P voorzichtig uit de Arduino UNO-aansluiting en plaats optioneel de vervanging.

Zet de Atmega 328P op het breadboard. Leg het uiteinde met de divot naar boven op het broodplankje. Pin 1 is de pin linksboven. Pin 2 is de volgende naar beneden, en zo verder naar pin 14 die linksonder staat. Dan is pin 15 rechtsonder en pinnen 16 tot 28 tellen terug aan de rechterkant van de chip.

Sluit pinnen 8 en 22 aan op aarde.

Sluit pin 7 aan op VCC (+5V).

Sluit een 16Mhz kwartskristal aan tussen pin 9 en 10. Ook een kleine condensator (22pF) tussen pin 9 en aarde, en tussen pin 10 en aarde. Dit geeft de Atmega 328P de 16Mhz kloksnelheid. Er zijn elders instructies om de 328P te leren om in plaats daarvan zijn interne 8Mhz-klok te gebruiken, wat een paar onderdelen zou besparen, maar dat zou de processor vertragen.

De Arduino GPIO-poorten 5, 6, 7 en 8, die we voor de invoerpinnen hebben gebruikt, zijn eigenlijk de fysieke pinnen 11, 12, 13, 14 op de Atmega 328P. Dat zijn de vier onderste pinnen aan de linkerkant.

De Arduino GPIO-poorten 11, 10 en 9, die we voor de uitgangspinnen hebben gebruikt, zijn eigenlijk de fysieke pinnen 17, 16, 15 op de Atmega 328P. Dat zouden de onderste drie pinnen aan de rechterkant zijn.

Ik heb de LED's zoals voorheen op deze pinnen aangesloten.

Stap 5: Conclusie

TTL-chips werken, maar er zijn er veel nodig om iets te bouwen. FPGA's werken heel goed, maar zijn niet goedkoop. Als je kunt leven met minder IO-pinnen en een lagere snelheid, dan is een Atmega 328P misschien de chip voor jou.

Enkele dingen om in gedachten te houden:

FPGA:

Pro

- Kan signalen met hoge snelheid aan. Omdat er geen CPU is om de verwerking tot één instructie tegelijk te bottlenecken, is de beperkende factor de voortplantingsvertraging door de poorten op het gegeven circuit. In veel gevallen kan dit veel sneller zijn dan de klok die bij de chip wordt geleverd. Voor mijn ontwerp zou de berekende vertraging de twoBitAdder in staat hebben gesteld om te reageren op ongeveer 100 miljoen veranderingen in invoerwaarden per seconde (100 MHz), ook al is de ingebouwde klok slechts een 12 MHz-kristal.

- Naarmate het ontwerp complexer wordt, gaan de prestaties van de bestaande schakelingen niet (veel) achteruit. Omdat het toevoegen van circuits aan de stof simpelweg iets nieuws in ongebruikt onroerend goed plaatst, heeft dit geen invloed op bestaande circuits.

- Afhankelijk van de FPGA kan het aantal beschikbare IO-pinnen erg hoog zijn en zijn ze over het algemeen niet opgesloten voor een bepaald doel.

Con

- Kan duur en/of moeilijk verkrijgbaar zijn.

- Wordt meestal geleverd in een BGA-pakket dat een soort breakout-bord vereist om met de chip in elk amateurproject te werken. Als u het inbouwt in een ontwerp met een aangepaste meerlaagse SMT-PCB, is dit geen probleem.

- De meeste FPGA-fabrikanten leveren hun eigen closed source-ontwerpsoftware, die in sommige gevallen geld kan kosten, of een licentievervaldatum heeft.

Arduino als FPGA:

Pro

- Goedkoop en gemakkelijk te krijgen. Zoek gewoon naar atmega328p-pu op Amazon. Ze zouden ongeveer $ 4 / stuk moeten zijn. Verschillende verkopers verkopen ze in partijen van 3 of 4.

- Dit is een DIP-pakket, wat betekent dat het perfect op een breadboard past met zijn externe pinnen.

- Dit is een 5V-apparaat, dat de interface met andere 5V-apparaten gemakkelijk kan maken.

Con

- De ATMEGA328P heeft een beperkt aantal IO-pinnen (23) en een aantal daarvan is gereserveerd voor specifieke taken.

- Naarmate de complexiteit van het circuit toeneemt, neemt de hoeveelheid code die in de Arduino-lusmethode wordt uitgevoerd toe, wat betekent dat de duur van elke cyclus langer is.

- Zelfs als de complexiteit van het circuit laag is, vereist elke cyclus veel CPU-instructies om de invoerpinwaarden op te halen en uitvoerpinwaarden te schrijven en terug te keren naar de top van de lus. Met een kristal van 16 Mhz, zelfs bij één instructie per klokcyclus, zal de lus niet meer dan misschien 1 miljoen keer per seconde (1 Mhz) lopen. Voor de meeste amateur-elektronicaprojecten is dat echter veel sneller dan nodig.