POV-Globe mit XMC2Go
von Lenny Doyle
In diesem Artikel möchte ich euch meinen POV Globe vorstellen, den ich für den XMC Design Contest 2014 gebaut habe. Ich werde nicht jedes Detail erklären und so ist es keine Schritt für Schritt Anleitung, aber da das mein erstes größeres Mikrocontroller-Projekt ist haben sich viele Einsteigerfragen, gerade im Hinblick auf den XMC1100 und DAVE, gestellt, deren Antworten hier hoffentlich einigen Einsteigern helfen können. Viel Spaß beim Lesen.
Überblick
Ein POV-Globe besteht aus einer Spalte von LEDs, welche so um eine Achse rotieren, dass sie eine Kugeloberfläche abbilden. Durch zeitlich koordiniertes Ansteuern der LEDs kann man dabei relativ einfach darauf Bilder generieren. Meinen POV-Globe habe ich zusätzlich mit einer seriellen Schnittstelle (aktuell über einen HC-06 Bluetooth-Chip)ausgestattet, um Einzelbilder vom PC aus übertragen zu können.
- Controller: XMC2Go (XMC1100 uC)
- LEDs: 40x RGB (5050-PLCCs), 3bit Farbtiefe (keine PWM-Helligkeit)
- Ring: 3D-gedruckter Ring, 190mm Durchmesser
- Serieller Anschluss für Übertragung von Einzelbildern
- Programmiert in C mit Infineon DAVE Apps
- PC-Steuerprogramm in Visual C#
Aufbau
Fangen wir mit dem Kern an, der Elektronik. Als Controller habe ich den XMC2Go gewählt, weil er schön klein ist, alle meine Anforderungen erfüllt hat und natürlich weil es dazu einen Wettbewerb gab. Dieser steuert über insgesamt 7 Pins kaskadierte 74HCT595-ICs an, welche direkt die insgesamt 40 LEDs treiben. Die LEDs und Schieberegister sind auf einer selbst designten und hergestellten dünnen Platine untergebracht, welche über den Ring gekrümmt ist. Die Anbindung an den Controller und die Versorgungsleitungen sind zum Platzsparen alle als fliegende Verdrahtung entstanden, zugegeben nicht sehr elegant aber flexibel. Versorgt wird die ganze Einheit über einen selbst konstruierten Schleifring. Die Drehachse ist dafür hohl und führt die Kabel, am unteren Ende sind dann Abschnitte eines dickeren Rohrs als Schleifringe angeschlossen, vom Sockel kommen gefederte Drähte als Abnehmer. Um Spannungsschwankungen zu vermeiden (und als Auswuchtgewicht :) ) ist noch ein Elko vorhanden. Der Sockel sowie der Antrieb sind sehr provisorisch entstanden, vorwiegend aus Teilen eines alten HP-Multifunktionsdruckers. Leider ist die Konstruktion daher weder besonders genau noch besonders stabil sodass der Ring trotz grober Auswuchtung noch zu schwingen anfängt im Betrieb. Um das zu beheben werde ich den Sockel demnächst aus Holz neu bauen und den Ring besser auswuchten, jedoch fehlt dank Klausurenphase gerade die Zeit. Stabilisiert wird das ganze etwas durch eine zweite Aufhängung oben.
Elektronik
Auch wenn das nicht geplant war, sieht meine Umsetzung der Elektronik etwas ähnlich aus wie die von Forenmitglied „Fornax“ vorgestellte Version unter POV-Display. Dabei werden immer jeweils vier LEDs je Schieberegister gegen VCC und vier gegen Masse geschaltet, damit im Höchstbetrieb der Maximalstrom von 70mA durch VCC/GND des Schieberegisters beachtet wird. Ich habe mich gegen eine eventuell einfachere Verdrahtung von WS4812B-LEDs entschieden, da ich mit Schieberegistern evtl. flexibler bin, das PWM sowieso zu langsam wäre für die Rotation und ich dank deren 24bit-Farbtiefe 8mal so viele (großteils unnötige) Pulse senden müsste.
Der Rest des Schaltplans ist eigentlich nichts Besonderes, die LED-Vorwiderstände habe ich für 5V berechnet und durch etwas ausprobieren die subjektive Helligkeit der R-, G- und B-LEDs auf ein gleiches Niveau gebracht. Die Aufteilung der 40x3(RGB) Einzel-LEDs auf insg. 15 Schieberegister hat mir einiges Kopfzerbrechen bereitet, ich habe mich wie folgt entschieden:
- Die Platine sollte so simpel wie möglich werden und musste einseitig sein, daher sollten sich möglichst wenige Leitungen kreuzen. Daher sind die R, G und B Pins immer direkt nebeneinander, die LED-Pins daher z.T. über 2 Schieberegister verteilt. Außerdem ist bei meinen LEDs die rote in der Mitte, daher ist die Reihenfolge immer GRB statt RGB, auch im Speicher. Um wenigstens diese Reihenfolge einzuhalten, habe ich ein paar Leiterbahnkreuzungen in Kauf genommen (siehe Platine).
- Die Invertierung einiger Anschlüsse (gegen VCC geschaltete LEDs) ist einfacher/nur in Software zu kompensieren.
- Essentiell ist der Controller ja ein Grafik-RAM mit Ausgabe, d.h. die Speicherung der Bilddaten sollte möglichst kompakt geschehen und so, dass die Ausgabe schnell und unkompliziert erfolgen kann. Dafür habe ich immer 3 Schieberegister kaskadiert, sodass diese jeweils 8 LEDs steuern, und 5 solcher Module parallel angesteuert. Das hat auch das Design der Platine vereinfacht (ich habe nur ein „Modul“ designt und 5 Mal hergestellt).
In einem Takt werden also immer 5 Bits ausgegeben und an die 5 Module verteilt, im nächsten Takt die nächsten 5 Bits usw. Um die Ausgabe simpel zu machen werden die 5 aktuellen Bits in einer Variablen gespeichert und parallel ausgegeben. Für den nächsten Takt wird die Variable einfach um 5 geshiftet und die 5 nächsten Bits werden ausgegeben. Da der XMC ein 32-bit Controller ist, konnte ich somit max. 5x6 = 30bit in ein uint32_t speichern, das sind 5x2 LEDs mit je einem Bit für R, G und B. Somit besteht eine Bildspalte aus 4 uint32_t Variablen, um es mir im Kopf vorstellen zu können habe ich möglichst immer die Bitreihenfolge MSB zu LSB beibehalten, also:
D3 (MSB) 39G, 38G, 37G,36G,35G,39R, 38R, … …, 26B, 25B, 24B
D2 23G, 22R, 22B, … …, 18B, 17B, 16B
D1 15G, 14R, 13B, … …, 10B, 9B, 8B
D0 (LSB) 7G, 6R, 5B, … …, 2B, 1B, 0B
LED0 ist die Unterste (Südpol der Kugel).
Somit liegt minimaler Rechenaufwand beim Controller bei der Ausgabe, der Rechenaufwand wurde auf die Generierung der Bilder verlagert (welches am PC mit einem Konverter geschieht). Für die Ansteuerung fehlten dann nur noch 2 Dinge: Der Schleifring für die Versorgung, die Kommunikation mit dem PC und ein Synchronisationssignal, damit die Kugel ihre Drehzahl schätzen kann und das Bild steht. Den Schleifring habe ich selbst gebaut (siehe Mechanik), für das Sync-Signal habe ich eine IR-Lichtschranke verwendet, welche ich aus besagtem defektem Drucker ausgebaut habe. Der Ausgang ist ein lichtempfindlicher Transistor, d.h. man kann das Signal direkt an einen uC-Pin anschließen. Über einen Interrupt synchronisiert dieser dann die Umdrehungen. Eine Motosteuerung habe ich noch nicht gebaut, aktuell läuft der Motor einfach über ein Steckernetzteil, die Drehzahl ist schließlich durch das Sync unkritisch.
Platine designen
Nachdem diese Eckdaten also festgemacht und der Schaltplan erstellt war, ging es an die Platine. Zuerst hatte ich eine Ringscheibe geplant, auf welcher die LEDs seitlich montiert werden, da hier im Forum nicht sicher war ob sich Platinen biegen lassen, aber es hat doch hervorragend geklappt! Ich habe mir bei Conrad die 0.5mm Bungard Epoxy-Platine geholt und einmal damit einmal experimentiert. Ein Biegeradius von < 8cm ist definitiv leicht erreichbar. Bestückt habe ich das ganze erst später, d.h. die Platinen müssen gut und fest mit dem Ring verbunden sein, um Spannungen zu vermeiden. Da das mein erstes Projekt mit KiCad war (Platine zu lang für Eagle Lite-Lizenz), hier einige Dinge auf die ich gestoßen bin, die hoffentlich jemandem helfen.
- Ich fand es erst abschreckend, aber man muss durch und dann lernt man es mögen.
- Die Anleitungen im Internet passen nicht auf meine Version, die Menüs sind woanders oder heißen anders. Im Zweifel muss man einfach Google anschmeißen, es gibt fast jede Option doch irgendwo.
- Die Library finde ich nach wie vor verwirrend: Die Suchfunktion ist etwas unübersichtlich, ich habe immer die komplette Library aufgemacht und das Teil per Hand gewählt, dass ich suchte
- SMD-Footprints sind nicht so viele vorhanden, aber für meine Zwecke hat‘s gereicht.
- Die 5050-PLCC LEDs gab es nicht, ich habe über Google gesucht und diese Library verwendet: https://github.com/open-project/kicadlibrary
Für eine komplette Freeware alles in allem aber echt passabel, gut dass es sowas gibt.
Platine herstellen
Auch das war für mich eine Premiere, ich habe mich für das Tonertransfer-Verfahren entschieden, ich finde das simpel und für meine Zwecke mehr als ausreichend. Insgesamt habe ich einen Protypen und 5 Module hergestellt, 4 davon jeweils zu zweit auf eine Platine, mehr wäre zu lang für Euro-Platinen. Erfahrungen die ich dabei gesammelt habe:
- Ich hätte Reichelt-Papier nehmen sollen :) Da ich keins da hatte, habe ich Conrad-Fotopapier genommen und Laser-Folien probiert.
- Auf einer Folie muss man natürlich keine Papierreste abrubbeln, allerdings habe ich nach einigen Versuchen aufgegeben, da immer minimale Tonerreste nicht übertragen wurden
- Das Fotopapier ist auch höchst ungeeignet. Hier im Wiki ist glaube ich dieses erwähnt mit dem Hinweis > 45min einweichen, aber auch das half nicht beim Ablösen, da die Glanzbeschichtung des Papiers immer auf der Patine klebte und in kleinen Zwischenräumen (ab ca. 15mil) nicht mehr einfach rausging. Mit der Zahnbürste habe ich dann auch immer Pads mitgenommen.
- Man kann das Layout für ca. 5 Sec anbügeln, dabei wird kein Toner übertragen aber das Papier/ die Folie hängt fest, optimal um die Positionierung zu checken
- Schlussendlich habe ich unter meinen (schlechten) Anfangsbedingungen folgendes Optimum gefunden: Papier, 5sec andrücken, 110sec bügeln mit maximal draufdrücken (!) und dann: Papier NICHT einweichen, sondern trocken während noch sehr heiß abziehen. Ich war erstaunt wie gut das geklappt hat, 2-3 minimale Ausbesserungen mit dem Folienstift und das Ergebnis ist perfekt.
- Man muss wirklich mit sehr viel Kraft aufdrücken, damit man das Fotopapier trocken abziehen kann. Die Zeit war dann gar nicht so kritisch (+- 15sec)
- Ich bin mir nicht sicher, aber ich glaube das Abziehergebnis verschlechterte sich schnell beim Abkühlen, also recht schnell noch heiß abziehen
Geätzt habe ich dann mit Natriumpersulfat, wohl angeblich nicht das schnellste aber mit Geduld (ca. 40min) wunderbares Ergebnis.
Mechanik
Für die mechanische Konstruktion habe ich möglichst viele vorhandene Dinge verwendet, abgesehen von dem Ring und der Achse mit Schleifring ist wenig Planung in den Sockel gegangen. Die Grundplatte dient zur Stabilisierung durch ihr Gewicht, die meisten anderen Sachen habe ich aus Plastik-Gehäuseteilen des defekten Druckers gebaut, da dies hervorragend von Hand zu bearbeiten ist, auch ohne teure Werkstattausstattung. Achse und Lager Um die Achse drehbar zu lagern habe ich einfach 2 Gleitlager aus Plastikstücken gebaut, eines ist auf der Bodenplatte, das andere auf der Ebene welche den Motor hält. Um das Schwingen etwas zu reduzieren habe ich später noch ein provisorisches Lager oben, am anderen Ende der Achse, gebaut. Am Fuß der Achse habe ich ein Metallblech auf der Bodenplatte befestigt, die Achse hat einen kleinen reibungsärmeren Fuß bekommen sodass hier Verluste hoffentlich minimiert werden. Aufgrund des Spiels meiner selbstgebastelten Gleitlager und der verbleibenden Unwucht des Ringes ist diese Konstruktion leider nicht laufruhig und stabil, ich werde den Sockel demnächst daher aus Holz noch einmal neu bauen und evtl. 2 Kugellager einsetzen, um die Achse zu lagern.
Schleifring
Ein etwas komplizierterer Teil der Konstruktion war der Schleifring, welcher bei mir insgesamt 4 Leitungen durchführt und komplett von Hand gebaut ist. Ich hatte mich für 4 Leitungen entschieden, damit während des Betriebs seriell mit dem PC kommunizieren könnte um Bilder zu laden etc. Wenn der Ring steht, ist die Verbindungsqualität gut genug für eine In-Situ-USB-Programmierung, allerdings gibt es bei der Rotation immer kleinere Aussetzer, sodass eine USB-Verbindung unmöglich ist, bei RS232 mit Baud 115200 gehen sind 1-2Bytes pro 1000Byte fehlerhaft. Mit geringerer Baudrate und/ oder Fehlercheck-Mechanismen wäre so durchaus eine gute Kommunikation möglich, ich habe jedoch einen eleganteren Ausweg gewählt: einen HC-06 Bluetooth Chip. Eventuell kann diese Qualität allerdings z.B. durch Kohlebürsten aus einem Motor verbessert werden, werde ich bei Gelegenheit probieren. Die Konstruktion der Ringe war relativ einfach, ich habe die Hauptachse als ersten Ring und damit Masse verwendet, die anderen Ringe durch einen Schrumpfschlauch isoliert darauf geschoben (mit etwas Kraft, daher verrutschen sie nicht mehr und brauchen keine extra Befestigung) und kleine Löcher für die Kabeldurchführung in die Achse gebohrt. Für die Gegenseite, die Abnehmer, hatte ich zuerst kleine Metallbleche gesägt und auf einem Plastikwinkel befestigt (s. Fotos), allerdings konnte ich die Verbindungsqualität noch wesentlich verbessern durch abisolierte Schaltdrähte, welche ich auf die Metallblechfedern gespannt habe. Auch am Plastikwinkel festgemacht habe ich dann einen breiten Draht, um die Lichtschranke auszulösen. Diese ist direkt am Schleifring mit VCC und GND verbunden (inkl. Vorwiderstand), sodass nur ein Kabel für das Ausgangssignal durch die Achse geführt werden muss. Bemerkungen hierzu
- Die IR-Lichtschranke habe ich auch aus dem Drucker ausgebaut, durch Analyse der ursprünglichen Platine und einem beliebigen IR-Lichtschranken Datenblatt habe ich die Pinbelegung und den Vorwiderstandswert herausfinden können
- Die Kabeldurchführung war recht kniffelig zu bauen, da die Drähte oben und unten durch Löcher aus der Achse geführt werden. Dazu kann man sich mit einer Draht-Öse helfen. Aber Vorsicht: da die Bohrlöcher von innen scharf sind, muss man kleinere Schwächen in der Kabelisolierung danach in Kauf nehmen
- Man kann vorsichtig auch nachträglich Löcher in die Achse bohren ohne die Kabel zu beschädigen, bei mir geht alles noch nach 3-4 Nachbohrungen
Antrieb
Hierfür habe ich zwei verschieden Motoren aus dem Drucker ausprobiert und mich für den kleineren entschieden. Über den vorhandenen Keilriemen konnte ich die Achse mit einer ungefähr 1:1.5 bis 1:2 Übersetzung antreiben. Das Gegenzahnrad habe ich mit einer Schraube an der Achse befestigt. Der Motor wird aktuell einfach über ein Steckernetzteil versorgt, in einem Update werde ich vielleicht eine Motorsteuerung bauen, um den gesamten Globe von einem Netzteil versorgen zu können.
Der Ring
Das Highlight der mechanischen Konstruktion ist der Ring selbst, welchen ich bei der Fachschaft Mathe der TU München 3D-drucken konnte (Link s.u.). Daher habe ich einfach einen sinnvollen Radius berechnet, um die 40 LEDs in gutem Abstand unterzubringen (mit etwas Platz nahe der Achse am Nord- und Südpol und 7mm LED-Abstand ergab dies 95mm Außendurchmesser). Das Material ist ABS.
Zum Erstellen des 3D-Modells habe ich Solid Edge verwendet, bei den Export-Optionen für .stl-Dateien muss man nur auf eine sinnvolle Auflösung achten, damit der Kreis nicht eckig wird. Mit der Freeware 3D-Tool-Free kann man die stl-Datei noch einmal überprüfen, der Rest wird den Druckern überlassen. Die haben für mich dann noch 2 Stützstrukturen eingebaut, da Überhänge von 90deg ja nicht druckbar sind. Diese entfernt man nach dem Druck einfach mit Messer und Feile.
Die Bohrungen für die Befestigung der Platinen und der Achse habe ich erst nachträglich gemacht, da ich die Maße nicht berechnet habe sondern einfach bei anliegender Platine gebohrt habe.
Befestigung der Platine
Die Platinen sind dünn genug um ohne Probleme auf den Ringradius von 95mm gebogen zu werden, jedoch stehen sie dann natürlich unter einiger Spannung. Daher habe ich, von der Mitte aus anfangend, Stück für Stück die Platinen zuerst angelegt, die Löcher oben und unten gebohrt, und dann die Platinen mit etwas Heißkleber und dann gut mit den Schrauben fixiert. Das Ergebnis seht ihr rechts. Das Bestücken habe ich erst danach gemacht, ich glaube nicht dass man die bereits bestückten Platinen im selben Maß biegen kann, und sollte sowieso nicht.
Befestigung und Verdrahtung Rest
Alles wird vernetzt über einfache Drähte, für den Controller habe ich keine eigene Platine entwickelt. Neben den Drähten zu den LED-Modulen gibt es noch das Bluetooth-Modul und natürlich die durchgeführten Versorgungskabel, welche einfach über Buchsenleisten auf die Controllerpins verbunden wurden. Das Versorgungskabel hat einen Stecker, sodass bisher der Ring wieder vollständig auseinandernehmbar ist, man muss nur die Kabel durch die Achse führen.
Software
Kommen wir zum interessanten Teil: die Software. Die Kernfunktionalität ist eigentlich recht simpel aufgebaut, auch die UART-Kommunikation ist so simpel wie möglich gehalten. Ich will mich daher hier auf eine kleine Einführung in die Entwicklungsumgebung DAVE fokussieren.
| Main() |
|---|
| Init()
while(1) { UART Handling } |
| SyncISR() |
|---|
|
| SysTick() |
|---|
| Spalte darstellen
oder LEDs ausschalten abwechselnd |
In der Main()-Funktion werden nach dem Initialisieren alle UART-Dinge behandelt, auf die Anzeige selbst hat sie aber keinen Einfluss mehr. Die SyncISR ist an den IR-Lichtschranken-Pin gebunden und hat eine höhere Priorität als der SysTick. Hier wird bestimmt, wie lange die letzte Umdrehung dauerte, und der neue SysTick auf 1/160tel dieses Wertes gesetzt. Außerdem wird die Spalte synchronisiert, also entweder Spalte 0 oder im Scrolling Modus die nächste richtige Spalte.
Der SysTick übernimmt dann die eigentliche Anzeige, bei jedem zweiten Durchlauf wird die nächste Spalte ausgegeben, bei jedem anderen die LEDs deaktiviert, sodass Punkte statt Streifen auf dem Globe entstehen.
Für die Kommunikation mit dem PC werden in der Main()-Funktion die Eingangsdaten am UART gelesen und interpretiert. Aktuell sind folgende Befehle implementiert:
- Ping. Ist die Kugel erreichbar? Gibt einfach ein ACK zurück
- Ticks. Gibt ein ACK und die letzte Umdrehungszeit in Ticks aus (muss in ms umgerechnet werden) damit kann die FPS am PC berechnet werden
- SetColAddress. Setzt die Spalte, in die als nächstes RAM-Inhalt geschrieben wird (nicht die angezeigte Spalte, ähnlich wie z.B. beim HD44780-Protokoll). Hier wird ACK und die neue Adresse ausgegeben
- Read. Gibt ein ACK und die komplette Bildspalte, auf die die Ram Adresse gerade zeigt, zurück als 16 bytes
- Write. Nimmt 16 byte entgegen und schreibt sie an die aktuelle Ram Adresse. Beide Funktionen zählen die RAM-Adresse automatisch hoch, sodass kein extra Befehl dafür nötig ist.
- ScrollCW,Off,CCW: Setzt den Scrolling Modus, also ob sich das Bild langsam über den Globe dreht auf Uhrzeigersinn, aus, Gegenuhrzeigersinn
Für die Kommunikation mit dem Globe habe ich außerdem ein kleines C#-Programm geschrieben, welches ein Bild laden und konvertieren kann, und es dann über die serielle Schnittstelle auf den Globe überträgt.
Detailaufbau Programm
Als XMC-Anfänger stand ich erst einmal vor einem relativ großen Berg an neuen Informationen. Auch wenn diese nicht sehr einfach und übersichtlich zu finden sind, sind Guides usw. doch schon in ausreichender Zahl vorhanden. Gute Quellen waren:
- XMC2Go Beispielprogramm + Präsentation dazu. Hier wird nicht erklärt wie oder warum, aber man bekommt schnell ein Blinken auf den Controller
- Beispielcodesammlung von Infineon
- Datenblatt: Auch wenn es alleine für den kleinen XMC1100 bereits 800 Seiten hat, ist es sehr detailliert und ich habe beim Lesen viel gelernt
- DAVE Apps: Auch wenn nicht immer eine passende da ist, kann man den generierten Code einer ähnlichen App anschauen und übernehmen, um z.B. einen Timer korrekt zu initialisieren.
DAVE Apps sind die große Neuerung die Infineon uns mit den XMC-Controllern bringt. Obwohl ich gerne „das Rad neu erfinde“, um herauszufinden was der Controller unter der Haube arbeitet habe ich doch Gefallen an den Apps gefunden. Apps sind umfangreiche Code-Generator-Templates, die man einfach zusammenklicken und einzeln konfigurieren kann, und man spart sich so doch sehr viel Zeit bei der Initialisierung von simplen Dingen wie IO Pins etc. Um ein Programm auf Apps-Basis zu erstellen wählt man in DAVE ein neues DAVE-CE Projekt, damit wird schon einmal die richtige Struktur angelegt und man kann gleich mit der Konfiguration loslegen. Für mein Projekt brauchte ich folgende Apps [inkl. Konfiguration]:
- UART001/0 für Kommunikation [FullDuplex, 115200baud, 8bit+0parity+1stop, 32byte FIFO beide Richtungen, Interrupts nicht benutzt (UART nur in Main)]
- [CLK002/0 für Systemclock auf 32MHz, PCLK 32MHz einstellen] automatisch durch UART001
- IO004/0 für Register-SCK [Output Push-pull]
- IO004/1 für Register-RCK (Latch) [Output Push-pull]
- IO003/0 für 5 Datenleitungen [5 Pins, Output Push-pull]
- (IO004/2 für Status-LED zum Debug, optional [Output Push-pull, Default High])
- IO002/0 für IR Sync Interrupt Pin [Pull up Input da opt. Transistor gegen Masse geschaltet, Standard Hysterese]
- ERU001/0 für ETL Konfiguration [ERS In B, Rising Edge, not sticky]
- ERU002/0 für OGU Konfiguration [Pattern disable, SR-Generierung ON_TRIGGER]
- NVIC002/0 für IR Sync Interrupt [Priorität 0 (höchste), Enable at startup, Name „SyncIRQ_Handler“]
- Die letzten 3 Dinge sind für die Konfiguration der sehr umfangreichen und mächtigen Event-Verteilungs-Module des XMC-Core. Die ETL und OGU sind teil der ERU, welche Events und Signale in einer Kreuzmatrix verteilt und an beispielsweise die UART Module oder Interrupts weitergibt
Damit ist schonmal ein sehr großer Teil der Initialisierung für mein Projekt abgeschlossen. (Für das gesamte Einrichten dieser Einstellungen habe ich weniger als eine Stunde gebraucht nachdem ich wusste was ich brauche, in dieser Zeit hätte ich niemals alle diese Dinge selbst geschrieben).
Danach müssen außerdem noch die Pins etc. zugewiesen werden, welches über das Pin Assignment geht.
Zuletzt kann man zwischen bestimmten Apps auch Hardware-Verbindungen einstellen, so kann man die Verbindung von Input-Pin über die ERU bis zum Interrupt-Node festlegen. Welcher Pin dabei mit welchem Interrupt verbunden werden kann, kann man dem Datenblatt entnehmen. Ich plane hierzu ein kleines Tutorial für die Website. Zusätzlich zu den DAVE-Apps fehlten mir nur noch wenige Zusatzfunktionen, welche ich in 3 Dateien ausgelagert habe:
- Helpers.c/.h: Hilfsfunktionen wie delay(), das gibt es eigentlich nicht im XMC-Core
- Stopwatch.c/h: Initialisiert einen Timer und benutzt diesen zum Zählen wie eine Stoppuhr. So kann der Globe die Zeit einer Umdrehung für den Sync messen
- Povdisplay.c/.h: Hier ist alles gebündelt was mit dem eigentlichen Anzeigen und auch dem Grafik-RAM zu tun hat. Dies könnte man als komplett eigenständige Klasse umsetzen, die Main() greift nur über wenige Funktionen indirekt auf die Daten zu
Im Anhang findet ihr den gesamten Code als DAVE-Projekt, und außerdem mein C#-Projekt. Bei Fragen und Anregungen könnt ihr mir einfach schreiben (Nutzer le-do).