Geïntegreerde universele interfacekaart - USB/Bluetooth/WIFI-bediening - Ajarnpa

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

Ik merk vaak dat ik bibliotheken voor nieuwe embedded modules helemaal opnieuw maak op basis van de datasheet van het apparaat. Bij het genereren van de bibliotheek merk ik dat ik vastloop in een cyclus van code, compileren, programmeren en testen om ervoor te zorgen dat dingen werken en vrij zijn van bugs. Vaak kunnen de compileer- en programmeertijden veel langer zijn dan de tijd die nodig is om de code te bewerken en dus zou een manier om deze stappen bij het ontwikkelen te verwijderen erg handig zijn.

Ik merk ook vaak dat ik een embedded module met een pc wil koppelen. Als de module niet specifiek een USB-aansluiting heeft, wat vaak het geval is, moet je over het algemeen een te dure USB-converter kopen die een enkele taak kan doen, zoals alleen SPI of alleen I2C.

Om deze redenen heb ik besloten om het universele interfacebord te maken. Het is ontworpen om eenvoudige pc-gebaseerde communicatie met ingebouwde modules mogelijk te maken.

De ingebouwde interfacefuncties van het bord waar ik voor gekozen heb, zijn onder meer.

• Digitale I/O
• I2C
• SPI
• UART
• PWM
• Servomotor
• ADC-ingang
• DAC-uitgang

Die allemaal volledig onafhankelijk kunnen worden gebruikt.

Het interfacebord kan worden bestuurd via een USB-verbinding met de pc, maar heeft ook optionele WIFI- of Bluetooth-moduleverbindingen zodat het bord op afstand of in een IoT-scenario kan worden gebruikt.

Door standaard 2,54 mm pitch SIL-headers te gebruiken, is het mogelijk om vrouwelijke dupont-kabels rechtstreeks aan te sluiten tussen het bord en de ingebouwde module, waardoor snelle, betrouwbare en soldeervrije verbindingen mogelijk zijn.

Ik heb ook nagedacht over het toevoegen van dingen als CAN, LIN, H-bridge etc, maar deze kunnen misschien later komen met een v2-revisie.

Stap 1: Het ontwerpen van de PCB

Bij het ontwerpen van de print probeer ik het graag zo eenvoudig mogelijk te houden. Als je boards met de hand gaat bouwen, is het belangrijk om alleen componenten toe te voegen als ze een specifiek doel hebben en zoveel mogelijk interne functies van de microcontroller te gebruiken.

Toen ik naar mijn favoriete elektronicaleverancier keek, vond ik een chip waar ik me goed bij voelde en die de functies had die ik zocht en tegen een redelijke prijs. De chip waarop ik belandde was de PIC18F24K50.

Met de beschikbare 23 I/O-pinnen kon ik deze functies gebruiken

• Digitale I/O
• I2C
• SPI
• UART
• PWM x 2
• Servomotor x 6"
• ADC-ingang x 3
• DAC-uitgang x 1
• I/O aangedreven van 5V of 3V3
• Status-LED

Een nadeel van de IC die ik heb gekozen, is dat deze maar één UART-randapparaat heeft en dat het gebruik van de Bluetooth- of Wifi-besturingsmethode ervoor zorgt dat je de UART-verbinding niet meer kunt gebruiken.

In de bovenstaande afbeeldingen worden het voltooide schema en de PCB weergegeven.

Stap 2: Het protocol ontwerpen

De eerste stap bij het ontwerpen van het protocol is beslissen wat u het bord specifiek moet kunnen doen. Door dingen op te splitsen, krijg je meer controle, terwijl het combineren van dingen de interface vereenvoudigt en het communicatieverkeer tussen het bord en de pc vermindert. Het is een evenwichtsspel en moeilijk te perfectioneren.

Voor elke functie van het bord moet u eventuele parameters en rendementen aangeven. Een functie voor het lezen van een ADC-invoer kan bijvoorbeeld een parameter hebben om aan te geven welke invoer moet worden bemonsterd en een retourwaarde die het resultaat bevat.

In mijn ontwerp is hier de lijst met functies die ik wilde opnemen:

• Digitale I/O

  • SetPin (PinNummer, Staat)
  • Staat = GetPin (Pinnummer)

• SPI

  • Initialiseren (SPI-modus)
  • DataIn = Overdracht (DataOut)
  • ControlChipSelect (kanaal, staat)
  • SetPrescaler (Tarief)

• I2C

  • Initialiseren ()
  • Begin ()
  • Herstarten ()
  • Stop ()
  • SlaveAck = Verzenden (DataOut)
  • DataIn = Ontvangen (Laatste)

• UART

  • Initialiseren()
  • TX-byte (gegevens uit)
  • BytesBeschikbaar = RX-telling ()
  • DataIn = RX-byte ()

  • Baud instellen (Baud)

• PWM

  • Inschakelen (kanaal)
  • Uitschakelen (kanaal)
  • SetFrequency (kanaal, frequentie)
  • GetMaxDuty (plicht)
  • Dienstplicht instellen (plicht)

• Servo

  • Inschakelen (kanaal)
  • Uitschakelen (kanaal)
  • Positie instellen (kanaal, positie)

• ADC

  ADC-voorbeeld = voorbeeld (kanaal)

• DAC

  • Inschakelen
  • Uitzetten
  • SetUitgang (Spanning)

• WIFI

  • SSID instellen (SSID)
  • Wachtwoord instellen (wachtwoord)
  • Status = ControleVerbindingsstatus ()
  • IP = GetIPAddress ()

Parameters worden tussen haakjes weergegeven en resultaten worden vóór het isgelijk-teken weergegeven.

Voordat ik begin met coderen, wijs ik elke functie een opdrachtcode toe die begint bij 128 (binair 0b10000000) en naar boven werkt. Ik documenteer het protocol volledig om ervoor te zorgen dat als mijn hoofd eenmaal in de code zit, ik een mooi document heb om naar terug te verwijzen. Het volledige protocoldocument voor dit project is bijgevoegd en bevat inkomende opdrachtcodes en bitbreedtes.

Stap 3: De firmware ontwerpen

Als het protocol eenmaal is vastgesteld, is het een kwestie van de functionaliteit op de hardware implementeren.

Ik gebruik een eenvoudige benadering van het type state-machine bij het ontwikkelen van slave-systemen om te proberen de potentiële opdracht en gegevensdoorvoer te maximaliseren, terwijl de firmware eenvoudig te begrijpen en te debuggen blijft. Een meer geavanceerd systeem zoals Modbus zou in plaats daarvan kunnen worden gebruikt als u betere interactie met andere aangesloten apparaten nodig heeft, maar dit voegt overhead toe, wat de zaken zal vertragen.

De toestandsmachine bestaat uit drie toestanden:

1) Wachten op opdrachten

2) Ontvangstparameters:

3) Beantwoorden

De drie toestanden werken als volgt samen:

1) We gaan door de inkomende bytes in de buffer totdat we een byte hebben met de meest significante bitset. Zodra we zo'n byte hebben ontvangen, vergelijken we deze met een lijst met bekende commando's. Als we een overeenkomst vinden, wijzen we het aantal parameterbytes toe en retourneren we bytes die overeenkomen met het protocol. Als er geen parameterbytes zijn, kunnen we de opdracht hier uitvoeren en ofwel naar toestand 3 gaan of toestand 1 herstarten. Als er parameterbytes zijn, gaan we naar toestand 2.

2) We gaan door de inkomende bytes en bewaren ze totdat we alle parameters hebben opgeslagen. Zodra we alle parameters hebben, voeren we de opdracht uit. Als er retourbytes zijn, gaan we naar fase 3. Als er geen retourbytes zijn om te verzenden, gaan we terug naar fase 1.

3) We gaan door de inkomende bytes en voor elke byte overschrijven we de echobyte met een geldige retourbyte. Zodra we alle retourbytes hebben verzonden, keren we terug naar fase 1.

Ik heb Flowcode gebruikt om de firmware te ontwerpen, omdat het mooi visueel laat zien wat ik aan het doen ben. Hetzelfde zou net zo goed kunnen worden gedaan in Arduino of andere embedded programmeertalen.

De eerste stap is het tot stand brengen van communicatie met de pc. Om dit te doen, moet de micro worden geconfigureerd om op de juiste snelheid te werken en moeten we code toevoegen om de USB- en UART-randapparatuur aan te sturen. In Flowcode is dit net zo eenvoudig als het naar het project slepen van een USB Serial-component en een UART-component uit het Comms-componentmenu.

We voegen een RX-interrupt en buffer toe om binnenkomende commando's op de UART op te vangen en we pollen regelmatig de USB. We kunnen dan op ons gemak de buffer verwerken.

Het Flowcode-project en de gegenereerde C-code zijn bijgevoegd.

Stap 4: Interfacing via Flowcode

De Flowcode-simulatie is zeer krachtig en stelt ons in staat een component te maken om met het bord te praten. Bij het maken van het onderdeel kunnen we het onderdeel nu eenvoudig naar ons project slepen en hebben we direct de bordfuncties beschikbaar. Als een toegevoegde bonus kan elk bestaand onderdeel met een SPI-, I2C- of UART-randapparaat in de simulatie worden gebruikt en kunnen de communicatiegegevens via een injectoronderdeel naar de interfacekaart worden geleid. De bijgevoegde afbeeldingen tonen een eenvoudig programma om een bericht op het display af te drukken. De communicatiegegevens die via de interfacekaart worden verzonden naar de eigenlijke beeldschermhardware en de componentconfiguratie met I2C-display, I2C-injector en interfacekaartcomponenten.

De nieuwe SCADA-modus voor Flowcode 8.1 is een absolute toegevoegde bonus omdat we dan een programma kunnen nemen dat iets doet in de Flowcode-simulator en dit kunnen exporteren zodat het stand-alone op elke pc kan draaien zonder licentieproblemen. Dit kan geweldig zijn voor projecten zoals testopstellingen of sensorclusters.

Ik gebruik deze SCADA-modus om de WIFI-configuratietool te maken die kan worden gebruikt om de SSID en het wachtwoord te configureren en om het IP-adres van de module te verzamelen. Hierdoor kan ik alles instellen met behulp van de USB-verbinding en vervolgens overzetten naar een WIFI-netwerkverbinding zodra alles draait.

Enkele voorbeeldprojecten zijn bijgevoegd.

Stap 5: Andere interfacemethoden

Naast Flowcode kunt u vrijwel uw programmeertaal naar keuze gebruiken om met het interfacebord te communiceren. We gebruikten Flowcode omdat het al een bibliotheek met onderdelen had die we meteen aan de slag konden, maar dit geldt ook voor veel andere talen.

Hier is een lijst met talen en methoden om met de interfacekaart te communiceren.

Python - Een seriële bibliotheek gebruiken om gegevens naar een COM-poort of IP-adres te streamen

Matlab - Bestandsopdrachten gebruiken om gegevens naar een COM-poort of IP-adres te streamen

C++ / C# / VB - Met behulp van een vooraf geschreven DLL, directe toegang tot de COM-poort of Windows TCP/IP API

Labview - Met behulp van een vooraf geschreven DLL, de VISA Serial-component of de TCP/IP-component

Als iemand de bovenstaande talen geïmplementeerd zou willen zien, laat het me dan weten.

Stap 6: Afgewerkt product

Het eindproduct zal waarschijnlijk de komende jaren een prominente rol spelen in mijn ingebouwde gereedschapskist. Het heeft me al geholpen om componenten te ontwikkelen voor verschillende Grove-displays en sensoren. Ik kan nu de code volledig onder de knie krijgen voordat ik mijn toevlucht neem tot compilaties of programmeertrucs.

Ik heb zelfs wat borden uitgedeeld aan collega's zodat ook zij hun workflow kunnen verbeteren en deze zijn zeer goed ontvangen.

Bedankt voor het lezen van mijn Instructable. Ik hoop dat je het nuttig vond en hopelijk zal het je inspireren om je eigen tools te maken om je productiviteit te verhogen.