Maak elke sensor uit een FPGA: 4 stappen

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

De meeste makers hebben minstens één keer in hun leven geprobeerd een thermometer te bouwen, misschien is degene die ze thuis hebben niet slim genoeg, of misschien denken ze dat ze het volgende NEST kunnen bouwen. Toch hadden ze op een gegeven moment een microcontroller met hun state-of-the-art software aangesloten op een temperatuursensor (en misschien andere sensoren: druk, licht). Tot nu toe is alles perfect, de software draait en de sensor detecteert. Laten we het testen!

Hmmmm … misschien moet hij de sensor opwarmen met een föhn en afkoelen met ijs, het werkt een tijdje. Maar het ziet er niet professioneel uit, de sensor verandert te snel van waarde als je hem opwarmt, hij wordt niet warmer dan een paar graden. Het project is een mislukking! Maar het algoritme is nieuw, houdt rekening met veel factoren, wat jammer dat hij bij dit stomme kleine ding is blijven steken.

Mijn oplossing is deze: laat een FPGA fungeren als een sensor met waarden gestreamd vanaf een pc (of opgeslagen in het geheugen, of ad-hoc gemaakt in de FPGA). Dus voor je kostbare MCU lijkt de FPGA op een sensor, maar niet op een sensor: welke sensor je maar wilt. Misschien besluit u dat u meer resolutie of snellere responstijd nodig heeft dan verwacht, dan moet u de sensor vervangen. Bestel het online, het zal binnen een paar dagen aankomen, of een paar maanden, wie weet. Respin je printplaat of bestel een module met de nieuwe sensor. Of … een paar klikken en de FPGA is geconfigureerd als uw gloednieuwe sensor en kan de exacte interne configuratie emuleren.

Op het moment van schrijven zou de FPGA kunnen fungeren als een LM75 met temperatuurgegevens opgeslagen in BRAM (op de FPGA).

Stap 1: De MCU

Mijn MCU naar keuze is een LPC4337 op een LPCXpresso. Daarbovenop heb ik een schild (LPC General Purpose Shield) met een display en een echte LM75 sensor. LPC4337 is een ARM Cortex M4 die draait op 200MHz en een kleinere Cortex M0 (hier niet gebruikt). De echte sensor is verbonden met I2C1-randapparatuur en onze virtuele wordt verbonden met I2C0. De bron is beschikbaar op mijn GitHub.

Hoe het te bouwen? Download LPCXpresso IDE samen met LPCOpen bibliotheek. Importeer die bibliotheek in de IDE en open het project ook vanuit GitHub. Alles moet worden geconfigureerd en u kunt klikken op "Debug" in de linkerbenedenhoek.

Het hele project is gebaseerd op een van de voorbeelden van de NXP (om te laten zien dat mijn project een echte sensor simuleert en geen speciale code aan de MCU-kant nodig heeft). In het hoofdbestand (iox_sensor.cpp genaamd) staat deze code:

#define SENSORS_ON_SHIELD

#if gedefinieerd(SENSORS_ON_SHIELD) #define SHIELD_I2C I2C1 #elif gedefinieerd(SENSORS_ON_FPGA) #define SHIELD_I2C I2C0 #endif

Door SENSOR_ON_SHIELD en SENSOR_OR_FPGA te wijzigen, kan de gebruiker tijdens het compileren overschakelen naar welke sensor moet worden gesproken, de echte of de virtuele, omdat ze zich op verschillende I2C-pinnen bevinden.

Stap 2: De FPGA

Mijn favoriete FPGA-bord is een Artix 7 gemaakt door Digilent, met een Xilinx Arty 7. Twee van de PMod-connectoren worden gebruikt, één voor debuggen en één voor de echte lading, de verbinding met het MCU-bord.

Nogmaals, de broncode voor de FPGA is beschikbaar op mijn GitHub (fpgaSide-map).

Hoe het te bouwen? Download, koop of open Xilinx Vivado IDE. Importeer de projectbestanden van GitHub. Een van de bestanden (content.coe) zijn de temperatuurgegevens in onbewerkte indeling die naar de nepsensor worden gestreamd. Er is ook een Excel-bestand met dezelfde naam dat helpt bij het converteren van door mensen leesbare temperatuurgegevens naar onbewerkte LM75-gegevens. Ik ben van plan dit te veranderen in een geautomatiseerd proces met een stukje software geschreven in Java, maar tot die tijd werkt deze oplossing. Synthese en implementatie zou enige tijd in beslag moeten nemen, houd hier rekening mee.

Stap 3: Hoe werkt het?

Zoals ik al zei, voor de MCU ziet de FPGA eruit als een sensor, meer bepaald een I2C-sensor. De uitgang van de I2C-randapparatuur wordt aangesloten op de ingang van de FPGA. Binnen de FPGA zijn er 3 hoofdcomponenten: - I2C-controller- I2C-apparaat- gegevens De I2C-controller ontvangt I2C-gegevens van de pinnen van de FPGA en stuurt deze naar de rest van de FPGA en doet hetzelfde in omgekeerde volgorde. Het onderhoudt een interne statusmachine voor het I2C-protocol (trouwens, hier is de documentatie ervoor). Wat stuurt dit onderdeel naar het I2C-apparaat? De momenteel ontvangen byte, positie van die byte in de huidige communicatie en of de MCU schrijft naar of leest van de FPGA. Het I2C-apparaat ontvangt de verzonden bytes en werkt de gesimuleerde interne structuur van de sensor bij. Het kan alleen de registeraanwijzer bijwerken of nieuwe gegevens opvragen bij de gegevensbron. De component Gegevens streamt nieuwe gegevenspunten. Momenteel is het slechts een ROM-geheugen waarvan het adres (ongeveer) twee keer per seconde wordt verhoogd.

Wat is mijn einddoel? Het is te zien op de tweede foto. Dat wil zeggen: maak het mogelijk dat meer I2C-apparaten (sensoren en andere) tegelijkertijd binnen de FPGA kunnen worden gesimuleerd. De gegevens aan de achterkant van de sensor worden in de FPGA in de cache opgeslagen en vanaf de pc via USB of Ethernet gestreamd. Ondersteuning van meer geavanceerde sensoren en andere I2C-apparaten (geheugen, LED-stuurprogramma's, enz.).

Stap 4: Alles samenbrengen

Dit is het moment om alles met elkaar te verbinden. Theoretisch is het eenvoudig: het mcu-bord heeft een PMod-connector (I2C0 & SSP0 (kan werken als SPI)). Het Artix-bord heeft 4 PMod-connectoren die je kunt gebruiken zoals je wilt. Ik kies connector D om met de MCU te praten en connector B om verbinding te maken met mijn Logic Analyser.

Waarschuwing

Je kunt de twee borden niet zomaar aan elkaar koppelen. Waarom? PMod is gebouwd om de aansluiting van een Master/Host-kaart (die stroom geeft) op een Slave/Sensor-kaart (die stroom krijgt) te vergemakkelijken. Maar in dit project geven beide boards stroom en als je de 3.3V-uitgang van het ene bord aansluit op de 3.3V-uitgang van het andere bord, kunnen er slechte dingen gebeuren. Maar misschien niet en je zou gewoon de parameters van de stroomrails van de FPGA kunnen veranderen (ze zijn zeer zorgvuldig ontworpen). Neem dit risico dus niet en verplaats de connector één pin naar links (en draai ook het FPGA-bord om) zoals te zien is in de bovenstaande afbeeldingen. Hier is de PMod-specificatie, je kunt het bestuderen, wat ik in korte woorden heb gedaan, is om de VCC's van de twee borden niet aan te sluiten.