Embedded Universal Interface Board - USB/Bluetooth/WIFI-Steuerung - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

Ich stelle oft fest, dass ich Bibliotheken für neue eingebettete Module von Grund auf basierend auf dem Gerätedatenblatt erstelle. Beim Generieren der Bibliothek stecke ich in einem Zyklus aus Code, Kompilieren, Programmieren und Testen fest, um sicherzustellen, dass die Dinge funktionieren und fehlerfrei sind. Oft können die Kompilierungs- und Programmierzeiten viel länger sein als die Zeit, die zum Editieren des Codes benötigt wird, und daher wäre eine Möglichkeit, diese Schritte bei der Entwicklung wegzulassen, sehr praktisch.

Ich stelle auch oft fest, dass ich ein Embedded-Modul mit einem PC verbinden möchte. Wenn das Modul nicht speziell über einen USB-Anschluss verfügt, was oft der Fall ist, müssen Sie in der Regel einen überteuerten USB-Konverter kaufen, der eine einzelne Aufgabe wie nur SPI oder nur I2C erledigt.

Aus diesen Gründen habe ich mich entschieden, die universelle Schnittstellenkarte zu entwickeln. Es wurde entwickelt, um eine einfache PC-basierte Kommunikation mit eingebetteten Modulen zu ermöglichen.

Die eingebetteten Schnittstellenfunktionen des Boards, für das ich mich entschieden habe, umfassen.

• Digitale E/A
• I2C
• SPI
• UART
• PWM
• Servomotor
• ADC-Eingang
• DAC-Ausgang

All dies kann völlig unabhängig verwendet werden.

Die Schnittstellenkarte kann über eine USB-Verbindung zum PC gesteuert werden, verfügt aber auch über optionale WIFI- oder Bluetooth-Modulanschlüsse, um die Karte aus der Ferne oder in einem IoT-Szenario zu verwenden.

Durch die Verwendung von Standard-SIL-Stiftleisten mit 2,54 mm Rastermaß ist es möglich, Dupont-Kabelbuchsen direkt zwischen der Platine und dem eingebetteten Modul anzuschließen, was schnelle, zuverlässige und lötfreie Verbindungen ermöglicht.

Ich dachte auch darüber nach, Dinge wie CAN, LIN, H-Brücke usw. hinzuzufügen, aber diese können vielleicht später mit einer v2-Revision kommen.

Schritt 1: Design der Platine

Beim Entwerfen der Leiterplatte versuche ich, die Dinge so einfach wie möglich zu halten. Wenn Sie Boards von Hand bauen, ist es wichtig, nur Komponenten hinzuzufügen, wenn sie einen bestimmten Zweck erfüllen, und so viele interne Funktionen des Mikrocontrollers wie möglich zu verwenden.

Als ich meinen bevorzugten Elektroniklieferanten betrachtete, fand ich einen Chip, mit dem ich mich wohl fühlte, der die Funktionen hatte, nach denen ich suchte, und die zu einem vernünftigen Preis waren. Der Chip, auf dem ich gelandet bin, war der PIC18F24K50.

Mit den verfügbaren 23 I/O-Pins hat mir dies diese Funktionen ermöglicht

• Digitale E/A
• I2C
• SPI
• UART
• PWM x 2
• Servomotor x 6
• ADC-Eingang x 3
• DAC-Ausgang x 1
• E/A angesteuert von 5V oder 3V3
• Status-LED

Ein Nachteil des von mir gewählten ICs besteht darin, dass er nur über ein UART-Peripheriegerät verfügt. Wenn Sie die Bluetooth- oder Wifi-Steuerungsmethode verwenden, können Sie die UART-Verbindung nicht verwenden.

In den obigen Bildern sind der fertige Schaltplan und die Leiterplatte zu sehen.

Schritt 2: Entwerfen des Protokolls

Der erste Schritt beim Entwerfen des Protokolls besteht darin, zu entscheiden, was das Board konkret tun soll. Das Aufteilen von Dingen erhöht die Kontrolle, während das Zusammenfassen die Schnittstelle vereinfacht und den Kommunikationsverkehr zwischen dem Board und dem PC reduziert. Es ist ein Balance-Spiel und schwer zu perfektionieren.

Für jede Funktion des Boards sollten Sie alle Parameter und Rückgaben angeben. Zum Beispiel kann eine Funktion zum Lesen einer ADC-Eingabe einen Parameter haben, der angibt, welche Eingabe abgetastet werden soll, und einen Rückgabewert, der das Ergebnis enthält.

In meinem Design ist hier die Liste der Funktionen, die ich aufnehmen wollte:

• Digitale E/A
  • SetPin (PinNumber, Zustand)
  • Status = GetPin (PinNumber)

• SPI

  • Initialisieren (SPI-Modus)
  • DataIn = Übertragung (DataOut)
  • ControlChipSelect (Kanal, Zustand)
  • SetPrescaler (Rate)

• I2C

  • Initialisieren ()
  • Start ()
  • Neu starten ()
  • Halt ()
  • SlaveAck = Senden (DataOut)
  • DataIn = Empfangen (letzte)

• UART

  • Initialisieren()
  • TX-Byte (DataOut)
  • BytesVerfügbar = RX-Anzahl ()
  • DataIn = RX-Byte ()
  • SetBaud (Baud)

• PWM

  • Aktivieren (Kanal)
  • Deaktivieren (Kanal)
  • SetFrequenz (Kanal, Frequenz)
  • GetMaxDuty (Pflicht)
  • SetDuty (Pflicht)

• Servo

  • Aktivieren (Kanal)
  • Deaktivieren (Kanal)
  • SetPosition (Kanal, Position)

• ADC

  ADCsample = Sample (Kanal)

• DAC

  • Aktivieren
  • Deaktivieren
  • SetOutput (Spannung)

• W-LAN

  • SetSSID (SSID)
  • Passwort festlegen (Passwort)
  • Status = Verbindungsstatus prüfen ()
  • IP = IPAdresse abrufen ()

Parameter werden in Klammern angezeigt und Rückgabewerte werden vor dem Gleichheitszeichen angezeigt.

Bevor ich mit dem Codieren beginne, weise ich jeder Funktion einen Befehlscode zu, beginnend bei 128 (binär 0b10000000) und aufwärts arbeitend. Ich dokumentiere das Protokoll vollständig, um sicherzustellen, dass ich, sobald mein Kopf im Code ist, ein schönes Dokument habe, auf das ich zurückgreifen kann. Das vollständige Protokolldokument für dieses Projekt ist beigefügt und enthält eingehende Befehlscodes und Bitbreiten.

Schritt 3: Entwerfen der Firmware

Sobald das Protokoll eingerichtet ist, geht es darum, die Funktionalität auf der Hardware zu implementieren.

Bei der Entwicklung von Slave-Systemen verfolge ich einen einfachen Ansatz vom Typ einer Zustandsmaschine, um zu versuchen, den potenziellen Befehls- und Datendurchsatz zu maximieren, während die Firmware einfach zu verstehen und zu debuggen ist. Ein fortschrittlicheres System wie Modbus könnte stattdessen verwendet werden, wenn Sie eine bessere Interaktion mit anderen angeschlossenen Geräten benötigen, aber dies erhöht den Overhead, der die Dinge verlangsamt.

Die Zustandsmaschine besteht aus drei Zuständen:

1) Warten auf Befehle

2) Empfangen von Parametern

3) Antwort

Die drei Zustände interagieren wie folgt:

1) Wir gehen die eingehenden Bytes im Puffer durch, bis wir ein Byte haben, bei dem das höchstwertige Bit gesetzt ist. Sobald wir ein solches Byte erhalten, vergleichen wir es mit einer Liste bekannter Befehle. Wenn wir eine Übereinstimmung finden, weisen wir die Anzahl der Parameterbytes und Rückgabebytes entsprechend dem Protokoll zu. Wenn keine Parameterbytes vorhanden sind, können wir den Befehl hier ausführen und entweder zu Zustand 3 springen oder Zustand 1 neu starten. Wenn Parameterbytes vorhanden sind, gehen wir zu Zustand 2 über.

2) Wir gehen die eingehenden Bytes durch und speichern sie, bis wir alle Parameter gespeichert haben. Sobald wir alle Parameter haben, führen wir den Befehl aus. Wenn es Rückgabebytes gibt, gehen wir zu Stufe 3. Wenn keine Rückgabebytes zu senden sind, kehren wir zu Stufe 1 zurück.

3) Wir gehen die eingehenden Bytes durch und überschreiben für jedes Byte das Echo-Byte mit einem gültigen Rückgabe-Byte. Nachdem wir alle Rückgabebytes gesendet haben, kehren wir zu Stufe 1 zurück.

Ich habe Flowcode verwendet, um die Firmware zu entwerfen, da sie visuell gut demonstriert, was ich tue. Das gleiche könnte genauso gut in Arduino oder anderen eingebetteten Programmiersprachen gemacht werden.

Der erste Schritt besteht darin, die Kommunikation mit dem PC herzustellen. Dazu muss das Mikro so konfiguriert werden, dass es mit der richtigen Geschwindigkeit läuft, und wir müssen Code hinzufügen, um die USB- und UART-Peripheriegeräte anzusteuern. In Flowcode ist dies so einfach wie das Ziehen einer USB-Seriell-Komponente und einer UART-Komponente aus dem Comms-Komponentenmenü in das Projekt.

Wir fügen einen RX-Interrupt und einen Puffer hinzu, um eingehende Befehle auf dem UART abzufangen, und wir fragen regelmäßig den USB ab. Wir können dann in aller Ruhe den Puffer verarbeiten.

Das Flowcode-Projekt und der generierte C-Code sind angehängt.

Schritt 4: Schnittstelle über Flowcode

Die Flowcode-Simulation ist sehr leistungsfähig und ermöglicht es uns, eine Komponente zu erstellen, die mit dem Board kommuniziert. Beim Erstellen der Komponente können wir die Komponente jetzt einfach in unser Projekt ziehen und haben sofort die Boardfunktionen zur Verfügung. Als zusätzlichen Bonus kann jede vorhandene Komponente mit SPI-, I2C- oder UART-Peripherie in der Simulation verwendet werden und die Kommunikationsdaten können über eine Injektorkomponente an das Interface Board geleitet werden. Die beigefügten Bilder zeigen ein einfaches Programm zum Drucken einer Nachricht auf dem Display. Die Kommunikationsdaten, die über das Interface Board an die eigentliche Display-Hardware und den Komponentenaufbau mit I2C-Display, I2C-Injektor und Interface-Board-Komponenten gesendet werden.

Der neue SCADA-Modus für Flowcode 8.1 ist ein absoluter zusätzlicher Bonus, da wir dann ein Programm nehmen können, das etwas im Flowcode-Simulator tut, und es so exportieren, dass es auf jedem PC ohne Lizenzprobleme eigenständig läuft. Dies könnte für Projekte wie Prüfstände oder Sensorcluster großartig sein.

Ich verwende diesen SCADA-Modus, um das WIFI-Konfigurationstool zu erstellen, mit dem die SSID und das Passwort konfiguriert sowie die IP-Adresse des Moduls erfasst werden können. Dadurch kann ich alles über die USB-Verbindung einrichten und dann auf eine WIFI-Netzwerkverbindung übertragen, sobald alles läuft.

Einige Beispielprojekte sind beigefügt.

Schritt 5: Andere Schnittstellenmethoden

Neben Flowcode können Sie so ziemlich die Programmiersprache Ihrer Wahl verwenden, um mit dem Interface-Board zu kommunizieren. Wir haben Flowcode verwendet, da es bereits eine Teilebibliothek enthielt, die wir sofort zum Laufen bringen konnten, aber dies gilt auch für viele andere Sprachen.

Hier ist eine Liste von Sprachen und Methoden zur Kommunikation mit dem Interface Board.

Python - Verwenden einer seriellen Bibliothek zum Streamen von Daten an einen COM-Port oder eine IP-Adresse

Matlab - Verwenden von Dateibefehlen zum Streamen von Daten an einen COM-Port oder eine IP-Adresse

C++ / C# / VB - Verwenden Sie entweder eine vorgefertigte DLL, die direkt auf den COM-Port oder die Windows TCP/IP-API zugreift

Labview - Verwenden Sie entweder eine vorgefertigte DLL, die VISA Serial-Komponente oder die TCP/IP-Komponente

Wenn jemand die oben genannten Sprachen implementiert sehen möchte, lassen Sie es mich bitte wissen.

Schritt 6: Fertiges Produkt

Das fertige Produkt wird wahrscheinlich für die kommenden Jahre ein herausragendes Merkmal in meinem eingebetteten Werkzeugkasten sein. Es hat mir bereits geholfen, Komponenten für verschiedene Grove-Displays und -Sensoren zu entwickeln. Ich kann jetzt den Code vollständig festnageln, bevor ich auf irgendwelche Kompilierungs- oder Programmiertricks zurückgreifen kann.

Ich habe sogar einige Boards an Kollegen verteilt, damit auch diese ihren Arbeitsfluss verbessern können und diese sind sehr gut angekommen.

Vielen Dank für das Lesen meines Instructable Ich hoffe, Sie fanden es nützlich und hoffentlich wird es Sie inspirieren, Ihre eigenen Tools zu erstellen, um Ihre Produktivität zu beschleunigen.