Touchboard: Die berührungsempfindliche Märchentante
Das Bare Conductive Touchboard(öffnet im neuen Fenster) und die elektrisch leitfähige Farbe wurden Ende 2013 erfolgreich über Kickstarter(öffnet im neuen Fenster) finanziert – und spielten statt der geforderten 15.000 britischen Pfund mehr als 120.000 Pfund ein. Mittlerweile wird beides auch regulär verkauft. Anlass für uns, das multifunktionale Board und die Farbe in einem Projekt auszuprobieren: Wir wollen eine kleine Geschichte erzählen, in deren Verlauf der – eher jüngere – Zuhörer kleine Zeichnungen berühren muss. Entsprechend der Geschichte und der Benutzeraktion werden die Zeichnungen dabei unterschiedlich beleuchtet.
Wir haben uns dafür die Geschichte eines kleinen Eichhörnchens ausgesucht, das für den Winter Nüsse sammelt. Der Zuhörer soll durch Berührung etwa dem Eichhörnchen helfen, die Nuss zu finden oder die Sonne zum Leuchten bringen. Die Aufforderung dazu erhält er durch die gesprochene Erzählung.
Das Projekt umfasst eine ganze Reihe von Schritten: Zuerst müssen wir eine Zeichnung mit berührungsempfindlichen Sensoren auf eine halbtransparente Plexiglas-Scheibe auftragen. Dahinter platzieren wir LEDs, die situationsabhängig aufleuchten sollen. Die Erzählung muss eingesprochen und in Form von MP3-Dateien abgespeichert werden. Schließlich müssen wir noch ein Programm schreiben, das im richtigen Moment die MP3-Dateien abspielt sowie die LEDs ansteuert und die Sensoren überwacht.
Arduino mit mächtigen Freunden
Das Bare Conductive Touchboard ist ein Arduino-kompatibles Experimentierboard. Herzstück ist ein ATMega32U4-Mikrocontroller(öffnet im neuen Fenster) (32 KByte Flash-Speicher, 2,5 KByte RAM, 16 MHz). Ihm zur Seite stehen zwei weitere Chips, die für die besonderen Funktionen des Touchboards verantwortlich sind: ein Freescale MPR121(öffnet im neuen Fenster) für kapazitive, berührungsempfindliche Sensoren und ein VLSI VS1053B(öffnet im neuen Fenster) für die Wiedergabe von Sound-Dateien. Dazu kommen ein Kopfhörer-Ausgang, ein MicroSD-Karten-Slot und ein Anschluss für LiPo-Akkus, inklusive Ladefähigkeit.
Das Touchboard kann per Arduino-IDE programmiert werden, für die Tonwiedergabe und die Berührungssensorik stellt Bare Conductive entsprechende Bibliotheken für die Arduino-IDE zur Verfügung.
Experimente auch ohne Programmieren
Es ist aber gar nicht notwendig, sofort nach dem Auspacken des Boards die IDE anzuwerfen, den es kommt bereits vorprogrammiert beim Käufer an. Es ist nur notwendig, einen Kopfhörer oder Lautsprecher anzustecken und das Board mit Strom zu versorgen, und schon kann mit den großen Elektroden herumgespielt werden. Das Board kommt mit einer vorbespielten Micro-SD-Karte und spielt bei der Berührung eines der Elektroden eine zugeordnete MP3-Datei auf der Karte ab.
Wer nicht mehr als diese Funktion benötigt, muss lediglich die MP3-Dateien auf der Speicherkarte an einem PC durch eigene ersetzen. Leider liefert Bare Conductive keinen SD-Karten-Adapter mit.
Berührungsempfindliche Tintenkleckse
Das Board führt die berührungsempfindlichen Leitungen des Freescale-Chips in zwei Formen aus, einmal als große Elektroden auf der einen Seite des Boards und einmal als klassische Pin-Reihe. Über die großen Elektroden lassen sich problemlos Krokodilstecker anbringen. Im Sinne der Erfinder lassen sie sich auch mit ihrer elektrisch leitfähigen Farbe bemalen.
Die Farbe, die es derzeit nur in Schwarz gibt, erinnert in ihrer Konsistenz an Wandmalfarbe. Sie lässt sich mit einem Pinsel problemlos auftragen. Für sehr feine Striche ist sie allerdings zu zäh. Bare Conductive empfiehlt, Schablonen zu nutzen.
Die Farbe ist nicht so gut leitfähig wie zum Beispiel bei Circuitscribe . Allerdings ist sie auch nicht dafür gedacht, Stromkreise aufzumalen, sondern lediglich dafür, Potenzialunterschiede weiterzuleiten, die entstehen, wenn zum Beispiel die Finger die Farbe berühren oder in ihre Nähe kommen.
Vor- wie Nachteil der Farbe ist ihre Wasserlöslichkeit. Damit lässt sie sich zwar einfach entfernen, zum Beispiel von der Haut oder der Schablone. Doch leider reicht schon Hautschweiß, um Farbpartikel zu lösen, und beim ständigen Berühren fängt sie an, auf dem Untergrund zu verschmieren. Da die Sensorik aber auch schon bei Annäherung reagiert, ist es möglich, die Farbschicht ohne Funktionsverlust zum Beispiel mit Klarlack zu überziehen.
Es ist nicht notwendig, unbedingt die Farbe von Bare Conductive zu nutzen. An die Elektroden kann jede Art elektrisch leitfähigen Materials angeschlossen werden, von einem einfachen Draht über Alufolie bis hin zu elektrisch leitfähigen Stoffen.
Malen, bohren, kleben
Unser Projekt verlangt uns diesmal handwerklich mehr ab als frühere Projekte. Die "Hardware" unseres Erzähltableaus besteht aus drei Teilen: einer Plexiglas-Scheibe mit den Zeichnungen aus elektrisch leitfähiger Farbe, einer Sperrholzplatte als Träger für die LEDs und der Halterung, die beides zusammenhält.
Am Anfang steht die Umsetzung der Plexiglas-Scheibe mit den Zeichnungen. Dabei stellte sich zunächst die Schwierigkeit, dass niemand in der Redaktion sich das notwendige Freihand-Zeichentalent zu traute, zum anderen galt die Frage zu klären, wie die Zeichnungen später mit dem Touchboard verbunden werden.
Bare Conductive selbst empfiehlt den Einsatz von Schablonen, um die Farbe sauber aufzutragen. Da wir aber keine reinen geometrischen Formen aufzeichnen wollen, sondern recht freie Zeichnungen, können wir nicht einfach Teile mit Klebeband abkleben. Wir erwägen deshalb, die Zeichnungen am Computer zu erstellen und mit Hilfe eines Vektorprogramms wie Inkscape zusammenzusetzen und auf selbstklebende Folie aufzudrucken. Mit einem Cuttermesser könnten wir dann die gedruckten Umrisse entsprechend ausschneiden und uns so eine Schablone erstellen.
Diesen Weg gehen wir aber wegen des Aufwandes nur zur Hälfte, für den zweiten Teil nutzen wir die Transparenz der Plexiglasscheibe aus. Die Zeichnungen drucken wir auf normales Papier aus, das wir mit Klammern an der zugeschnittenen Scheibe befestigen. Dann stellen wir die Scheibe schräg auf und legten eine Lichtquelle dahinter – uns reicht die helle LED einer Handykamera im Taschenlampenmodus. So können wir die Vorlage mit dem Pinsel abmalen. Die Farbe benötigt ca. 15 Minuten zum Trocknen. Bei einer nicht saugfähigen Oberfläche wie unserer warten wir lieber ein paar Minuten länger.
Plexiglas verkabeln
Jetzt müssen wir noch einen Weg finden, die Zeichnungen mit dem Touchboard zu verbinden. Am einfachsten ist das mit Klingeldraht zu realisieren – doch wie den Klingeldraht mit den Zeichnungen verbinden und am Plexiglas befestigen?
In den Beispielen von Bare Conductive werden von Zeichnungen dünne Striche als Leitungen an den Rand geführt und von da zum Touchboard. Das wollen wir aber nicht so umsetzen. Zum einen finden wir es nicht elegant und zum anderen bleibt das Befestigungsproblem.
Wir wählen eine andere Variante. Mit einem kleinen Bohrer machen wir jeweils ein kleines Loch in die relativ breiten Umrisse der Zeichnungen. Dort stecken wir die vorbereiteten, an den Enden abisolierten Drähte durch und fixieren sie von der Rückseite großzügig mit Heißkleber. Die auf der Vorderseite überstehenden Drahtenden schneiden wir bündig ab. Die Löcher verfüllen wir schließlich großzügig mit Farbe. So ist der elektrische Kontakt zwischen Farbe und Draht hergestellt. An dieser Stelle empfiehlt es sich, die Enden der Drähte eindeutig zu markieren, damit die Verkabelung mit dem Touchboard und die Programmierung nicht zum Ratespiel ausarten.
Und es wird Licht
Nun steht die LED-Halterung an. Hierfür sägen wir 3mm-Sperrholz zurecht. Dann nehmen wir unsere Papiervorzeichnung vom ersten Bauschritt und stechen dort Löcher hinein, wo die LEDs später sitzen sollen. Das so präparierte Blatt legen wir auf das Brett und markieren so die Bohrlöcher für die LEDs.
Nach dem Bohren werden die LEDs in die Löcher im Brett eingesetzt und wieder großzügig mit Heißkleber fixiert. Vorher sollten die LEDs natürlich mit entsprechenden Anschlusskabeln verlötet und auch markiert werden.
Schließlich werden die beiden Scheiben in der Halterung eingesetzt. Die Halterung für die gesamte Konstruktion ist am einfachsten und schnellsten umgesetzt. Es handelt sich um zusammengeschraubte Alu-Extruder-Profile von Makerbeam(öffnet im neuen Fenster) .
Als letzte handwerkliche Tätigkeit verbleibt jetzt nur noch, auf dem Touchboard Buchsenleisten einzulöten. Denn leider – oder je nach Standpunkt zum Glück – kommt das Board vollkommen "nackt" daher.
Zeile für Zeile eingesprochen
Zentraler Bestandteil des Projektes ist die von der Märchentante gesprochene Erzählung. Diese schreiben wir zeilenweise auf und nummerieren sie durch. Jede Zeile wird dann einzeln aufgenommen und als MP3-Datei gespeichert. Die Dateinamen benennen wir entsprechend der Vorgaben einheitlich nach dem Schema TRACKxxx.mp3, wobei xxx der Satznummer entspricht. Schließlich kopieren wir die MP3-Datei auf der Micro-SD-Karte. Das Blatt mit den nummerierten Sätzen heben wir sorgfältig auf, denn wir werden es beim Programmieren des Drehbuchs noch benötigen.
Unerwartete Schwierigkeiten
Nun müssen nur noch die ganzen Drähte am Touchboard eingesteckt werden, und wir können mit dem Programmieren loslegen.
Unser erstes Testprogramm lässt uns aber erstmal komplett verzweifeln: Irgendwie funktioniert gar nichts. Erst mit den Touchboard-FAQ kommen wir dem Problem auf die Spur. Auf dem Board sind die Arduino-Pins mehrfach belegt und die zugehörigen Microcontroller-Anschlüsse werden auch zur Kommunikation mit den Zusatzchips verwendet. Wer also wie wir tatsächlich sämtliche Funktionen des Touchboards verwendet, kann nur noch einen Bruchteil aller GPIO-Pins nutzen. Leider fallen dadurch gerade auch jene Pins weg, an denen die PWM-Funktionalität angeboten wird, die wir aber gerade für unsere LED-Ansteuerung nutzen wollten. Das heißt übrigens auch, dass mit dem Touchboard längst nicht jedes Arduino-Shield funktioniert.
Die naheliegende Idee, die LED-Ansteuerung zu vereinfachen, wollen wir nicht umsetzen – darunter würde das Ambiente der ganzen Erzählung leiden. Die Alternative steht schließlich indirekt ebenfalls in den FAQ – durch die Doppelbelegung der Pins steht standardmäßig sowieso ein I2C-Bus zur Verfügung. So kramen wir kurzerhand noch einen Arduino heraus, um darüber die LED-Ansteuerung zu realisieren und ihn per I2C an das Touchboard anzubinden. Da dieser Teil nichts direkt mit unserem Projekt selbst zu tun hat, gehen wir darauf näher am Ende des Artikels ein. Hier machen wir erstmal mit dem Code auf dem Touchboard selbst weiter.
Ein Drehbuch in Codeform
Unser Programm auf dem Touchboard muss drei Dinge gleichzeitig koordinieren: die situationsabhängige Ansteuerung der LEDs, das Abspielen von MP3-Dateien im richtigen Moment und die Überwachung der berührungsempfindlichen Sensoren.
Die Umsetzung vereinfachen zwei Dinge: Zum einen läuft das Abspielen der MP3-Datei über die entsprechende Bibliothek von Bare Conductive weitgehend autonom, zum anderen befindet sich die Logik für die konkrete Ansteuerung jeder einzelnen LED auf dem Arduino und muss uns an dieser Stelle auch nicht weiter kümmern. Als Konsequenz müssen wir kein Multitasking selbst implementieren, sondern können uns weitgehend darauf beschränken, ein Drehbuch sequentiell abzuarbeiten. Das vollständige Arduino-Sketch für das Touchboard kann heruntergeladen werden.
Das Drehbuch besteht aus einer Folge von Zeilen ( ScriptLine ). Jede Zeile besitzt einen Zustand ( state ): Entweder wird veranlasst, eine MP3-Datei abzuspielen und parallel der Zustand der LEDs gesetzt ( STATE_PLAY ), oder es wird auf die Berührung eines Sensors gewartet und danach der Zustand der LEDs geändert ( STATE_TOUCH ).
Der zusammengesetzte Datentyp ScriptLine dient dazu, jede Drehbuchzeile zu speichern:
struct ScriptLine { byte state = STATE_PLAY; struct Pin pin[LEDS]; byte touch = 0; byte file = 1; int delay = 0; };Das Datenelement state repräsentiert die Art der Drehbuchzeile, das Array pin enthält Anweisungen, wie die LEDs angesteuert werden sollen. Ist es notwendig, auf einen Sensor zu reagieren, wird der betreffende Sensor mit Hilfe des Bitfeldes touch repräsentiert. Ein gesetztes Bit heißt: Der entsprechende Sensor muss berührt werden, bevor das Drehbuch weiter abgearbeitet wird. Soll hingegen eine MP3-Datei abgespielt werden, so enthält file die Nummer der MP3-Datei aus dem Einsprech-Skript und delay die Zeit in Millisekunden, die bis zur Ausführung der nächsten Drehbuchzeile gewartet werden soll – die Dauer entspricht meist der Spieldauer der MP3-Datei.
Mehr als Licht an und Licht aus
Im ScriptLine -Element wird die Ansteuerung der LEDs durch einen weiteren zusammengesetzten Datentyp repräsentiert. Das ist notwendig, da wir mehr als ein simples An und Aus bieten wollen. Tatsächlich können wir jede LED auf fünf verschiedene Arten ansteuern: an, aus, langsames Hellerwerden, langsames Dunklerwerden und eine konkrete, teilweise Helligkeit.
struct Pin { char mode = PC_MODE_LOW; char value = 0; };Der mode -Wert gibt an, wie die LED angesteuert werden soll, die Interpretation des value -Wertes hängt von mode ab. Soll die LED langsam dunkler oder heller werden, gibt er den Startwert vor, bei teilweiser Helligkeit den konkreten Helligkeitswert.
Mühsam nährt sich das Eichhörnchen
Unsere Zeichnung besteht aus einzelnen Elementen wie einem Baum, einem Eichhörnchen, einer Nuss und der Sonne. Diese selbst sind Sensoren, welche wir abhängig vom aktuellen Fortschritt der Geschichte auswerten müssen. Diesen Elementen sind auch LEDs zugeordnet, auch sie leuchten – oder eben nicht – abhängig vom Stand der Geschichte. Welche Sensoren und LEDs wann in der Geschichte relevant sind, beschreibt nun das Drehbuch.
Weite Teile des Programms bestehen deshalb aus der Definition des Drehbuchs mit Hilfe der ScriptLine -Elemente, es ist im Array script gespeichert. Die Einträge des Arrays werden hart-codiert ( struct ScriptLine script[SCRIPTLINES]; ), hier beispielhaft Zeile 12 und 13 des Drehbuchs:
script[12].state = STATE_TOUCH; script[12].touch = E_BUSH_1 | E_BUSH_2 | E_BUSH_3; script[12].pin[SQUIRREL].mode = PC_MODE_HIGH; script[12].pin[SUN].mode = PC_MODE_PWM; script[12].pin[SUN].value = 25; script[12].pin[NUT].mode = PC_MODE_HIGH; script[13].state = STATE_PLAY; script[13].file = 10; script[13].pin[SQUIRREL].mode = PC_MODE_HIGH; script[13].pin[SUN].mode = PC_MODE_PWM; script[13].pin[SUN].value = 50; script[13].pin[NUT].mode = PC_MODE_HIGH; script[13].delay = 2000; Die 12. Zeile weist an, auf eine Berührung eines der drei Büsche zu warten. Wurden sie berührt, wird die LED hinter dem Eichhörnchen angeschaltet, die LED hinter der Sonne leuchtet nur mit einem Bruchteil der Leuchtkraft und so weiter. Nach der Berührung wird direkt die 13. Zeile ausgeführt – in welcher die MP3-Datei Nummer 12 abgespielt wird und unter anderem die Sonne etwas heller erscheinen soll. Außerdem soll 2 Sekunden gewartet werden, bevor die nächste Drehbuchzeile ausgewertet wird.
In beiden Drehbuchzeilen wird der LED-Eintrag für die Nuss ( NUT ) gesetzt, obwohl er sich eigentlich nicht ändert. Das ist aber notwendig, da das zugrundeliegende Element standardmäßig mit PC_MODE_LOW initialisiert wurde, die LED würde automatisch beim Aufruf der 13. Zeile ausgeschaltet werden.
Der Speicher ist begrenzt
Unser Drehbuch besteht aus 17 ScriptLine -Elementen. Das erscheint wenig, der Speicherbedarf sollte aber nicht unterschätzt werden; der Mikrocontroller hat nur 2,5 Kbyte RAM. Tatsächlich sind wir in einer ersten Variante der ScriptLine -Implementierung bei weniger ScriptLine -Zeilen an diese Grenze gestoßen. Das liegt auch daran, dass die eingebundenen Bibliotheken selbst noch einmal rund 600 Byte Speicher im Betrieb anfordern.
In der Folge haben wir alle Datentypen im ScriptLine -Element noch einmal sorgfältig bedacht. Den größten Erfolg brachte allerdings eine Umstellung des touch -Elementes von einem Array mit den Sensorzuweisungen auf ein Bitfeld. Das spart zwar enorm Speicher, leider ist dadurch für Anfänger der Code für die Sensor-Auswertung aber weniger transparent.
Nichtsdestotrotz, auch mit der Umstellung dürfte nach spätestens 21 oder 22 Scriptzeilen Schluss sein. Ein echter Befreiungsschlag wäre die Speicherung des Drehbuches in einer Datei auf der Micro-SD-Karte. Das würde aber zu einem wesentlichen Code-Umbau führen und soll hier nicht weiter verfolgt werden.
Musik abspielen
Das eigentliche Programm ist nicht weiter kompliziert. In einer Schleife werden die Drehbuchzeilen abgearbeitet, und abhängig vom Zustand wird entweder eine MP3-Datei abgespielt oder auf eine Sensoreneingabe gewartet:
void loop() { if(STATE_TOUCH == loopState) { waitForTouch(); } else { playMp3(); } }Die playMp3() -Funktion ist dank der MP3-Bibliothek ( SFEMP3Shield(öffnet im neuen Fenster) ) bemerkenswert einfach:
void playMp3() { while(MP3player.isPlaying()) {} MP3player.playTrack(script[currentline].file); setLeds(); delay(script[currentline].delay); incrementScript(); }Am Anfang erfolgt eine Prüfung, ob bereits eine Datei abgespielt wird. Wenn ja, ist die weitere Programmausführung erst einmal blockiert. Wenn nicht beziehungsweise nicht mehr, wird die im Drehbuchskript vermerkte Datei abgespielt. Da das Abspielen der MP3-Datei im Hintergrund abläuft und die Programmausführung nicht blockiert, wird über setLeds() gleichzeitig der Zustand der LEDs entsprechend gesetzt. Zum Schluss wird noch gewartet, wenn das Drehbuch dies erzwingt, und danach die nächste Drehbuchzeile aktiviert.
Auf die Sensoren warten
Die waitForTouch() -Funktion ist etwas länger, aber nur wenig. Die verwendete Bibliothek MPR121(öffnet im neuen Fenster) reduziert den Aufwand deutlich, die Berührungssensoren auszuwerten. Sie besteht aus zwei Teilen. Zuerst wird ermittelt, welche Sensoren berührt wurden, dann geprüft, ob die Berührungen die Bedingungen erfüllen, um zur nächsten Drehbuchzeile zu springen:
void waitForTouch() { byte touches = 0; if(MPR121.touchStatusChanged()){ MPR121.updateTouchData(); for(int i=0; ELECTRODES > i; i++){ if(MPR121.isNewRelease(i)) { touches = touches | ceil(pow(2, i)); } } } if(touches & script[currentline].touch) { setLeds(); delay(script[currentline].delay); incrementScript(); } }Zuerst wird geprüft, ob überhaupt ein Sensorkontakt stattfand ( touchStatusChanged ), wenn ja, müssen wir die Sensordaten holen ( updateTouchData ).
In einer Schleife prüfen wir dann für jede der Sensorelektroden, ob eine Berührung vermerkt wurde. Ist das der Fall, wird in einem Bitfeld ein entsprechendes Bit gesetzt. Der entsprechende Code erscheint etwas merkwürdig: touches = touches | ceil(pow(2, i));
Wir nutzen dabei aus, dass die Nummer der Elektrode direkt mit der Position im Bitfeld korrespondiert, daher erhalten wir mit pow(2, ᐸnummerᐳ) eine Zahl, deren binäre Darstellung genau eine 1 an der entsprechenden Stelle im Bitfeld hat. Das ceil() ist notwendig, weil pow() eine Fließkommazahl liefert, wir aber eine Ganzzahl benötigen.
Das so erzeugte Bitfeld vergleichen wir mit der Bedingung in der aktuellen Drehbuch-Zeile. Ist sie erfüllt, werden auch hier die LEDs angesteuert und es wird zur nächsten Drehbuch-Zeile gewechselt.
LEDs ansteuern
Bislang haben wir die Funktion setLeds() nur aufgerufen. Werfen wir einen näheren Blick darauf, obwohl es dort eigentlich nicht viel zu sehen gibt:
void setLeds() { for(int i = 0; LEDS > i; i++) { send_cmd( i, script[currentline].pin[i].mode, script[currentline].pin[i].value ); } }Es werden die pin -Einträge der aktuellen Drehbuch-Zeile durchlaufen und dabei eine send_cmd -Funktion aufgerufen. Zur Erinnerung: Die tatsächliche Ansteuerung der LEDs übernimmt ein angeschlossener Arduino, send_cmd() ist dafür zuständig, dem Arduino zu sagen, wie er die LEDs ansteuern soll:
void send_cmd(char pin, char mode, char value) { Wire.beginTransmission(23); char cmd[3]; cmd[0] = pin; cmd[1] = mode; cmd[2] = value; Wire.write(cmd, 3); Wire.endTransmission(); }Der Arduino ist als I2C-Slave am Touchboard angebunden. Über die Wire-Bibliothek(öffnet im neuen Fenster) können wir Kommandos über ein selbst definiertes Protokoll verschicken. Unser Protokoll ist sehr einfach aufgebaut: Wir können lediglich ein Kommandopaket, bestehend aus drei 8-bit-Werten, versenden. Der erste Wert ist die Nummer des anzusprechenden Pins (= LED), danach folgt die Angabe, was mit dieser LED passieren soll und zum Schluss ein Wert, dessen Interpretation vom Kommando abhängig ist.
Der Arduino als Leuchtsklave
Kommen wir damit zum Arduino. Er wurde am I2C-Bus als Slave angeschlossen, nimmt darüber selbstdefinierte Kommandos an und setzt diese entsprechend um. Das entsprechende Programm besteht also grob aus zwei Teilen: dem Empfang von I2C-Botschaften und der eigentlichen Logik zur LED-Ansteuerung. Das vollständige Sketch für den Arduino kann heruntergeladen werden.
Zentrales Verwaltungselement ist auch hier wieder ein Array, diesmal mit dem zusammengesetzten Datentyp Pin_Control , jeder Array-Eintrag repräsentiert einen GPIO-Pin des Arduino – und damit die entsprechend angebundene LED:
struct Pin_Control { int pin; int mode; int value; int diff; };Der Eintrag pin entspricht der jeweiligen Pin-Nummer. Der mode -Eintrag ist identisch mit den Varianten der LED-Ansteuerung beim Touchboard-Programm, wie auch value . Der diff -Wert dient zur internen Verwaltung.
Das Array wird über initPinControl für jeden GPIO-Pin initialisiert – standardmäßig ist jede LED aus ( PC_MODE_LOW ).
Dieses Array wird kontinuierlich über die Funktion processPins() ausgewertet. Sie durchläuft alle Einträge und ruft die entsprechenden Funktionen wie digitalWrite() und analogWrite() auf, um die Pins zu regulieren. Hier ausschnittsweise gezeigt:
void processPins() { for(int i = 1; PINS >= i; i++) { switch(pins[i].mode) { ... case PC_MODE_PWM : analogWrite(pins[i].pin, pins[i].value); break; case PC_MODE_RISE : analogWrite(pins[i].pin, pins[i].value); if(255 == pins[i].value) { pins[i].mode = PC_MODE_HIGH; } else { pins[i].value = pins[i].value + pins[i].diff; } break; … } } }Kommandos empfangen
Nun fehlt nur noch der Teil, der auch tatsächlich die Werte im Array ändert. Das passiert, sobald ein Kommando über die I2C empfangen wird. Dafür haben wir mit Hilfe der Wire-Bibliothek die Callback-Funktion receiveEvent() registriert:
void receiveEvent(int count) { int pin = 0; pin = Wire.read(); pins[pin].mode = Wire.read(); pins[pin].value = Wire.read(); }Das überlieferte Kommando wird einfach Byte für Byte eingelesen und der entsprechende Parameter zugewiesen. Auf eine weitergehende Logik, die Zustandsänderungen im Array sofort auch in der LED-Ansteuerung umzusetzen, verzichten wir. Da das Programm keinen blockierenden Code enthält, können wir sicher sein, dass die processPins -Funktion sowieso innerhalb kürzester Zeit wieder aufgerufen wird.
Arduino und Touchboard verbinden
Um die physische I2C-Verbindung herzustellen, müssen per Kabel auf dem Touchboard die GPIO-Pins 2 und 3 mit den Analog-Pins 1 und 2 des Arduino-Boards verbunden werden. Außerdem muss eine gemeinsame Masseverbindung hergestellt werden.
Im Prinzip könnten wir den Arduino auch gleich über das Touchboard mit Strom versorgen. Leider reicht hierfür der gelieferte Strom des Touchboards nicht aus – bereits, wenn keine der LEDs leuchtet. Deswegen müssen wir den Arduino ebenfalls per USB mit Strom versorgen, wie auch das Touchboard.
Wollen wir dieses Problem eleganter lösen, gibt es eine Option: statt eines vollständigen Arduinos nur einen nackten, genügsameren Atmel-Microcontroller-Chip als IO-Expander zu nutzen. Doch die Möglichkeiten, die sich daraus ergeben und wie dieser entsprechend programmiert werden kann, sind Stoff genug für einen eigenen Artikel.
Fazit
Unsere Märchentante bestand aus einer ganze Reihe von Bausteinen: Es galt Sensoren anzufertigen und sie korrekt auszuwerten, mehrere LEDs auf verschiedene Arten anzusteuern und zum richtigen Zeitpunkt MP3-Dateien abzuspielen. Schon bei einem "richtigen" Computer wäre das keine simple Aufgabe, mit einem Microcontroller wird die Aufgabe eine Herausforderung.
Mit dem Touchboard und insbesondere den fertigen Software-Bibliotheken war das Projekt aber nicht schwer umzusetzen. Lösbare Schwierigkeiten ergaben sich aus der Limitierung der GPIO-Pins und dem kleinen RAM.
Mit rund 60 Euro (zum Beispiel bei Watterott(öffnet im neuen Fenster) und Tinkersoup(öffnet im neuen Fenster) ) erscheint das Touchboard alles andere als ein preisgünstiger Arduino-Klon. Wer allerdings die Kosten für einen Arduino plus Sensor- und MP3-Zusatzschild hochrechnet, kommt nicht billiger weg – und benötigt mehr Platz und muss sich um die Integration Gedanken machen.
Außerdem stammt die Arduino-Bibliothek für den Sensor-Chip MPR121 von Bare Conductive, ohne das Touchboard gäbe es die in den letzten Monaten erschienenen MPR121-Breakout-Boards und -Shields überhaupt nicht.
- Anzeige Hier geht es zum Arduino Uno R4 Minima bei Amazon Wenn Sie auf diesen Link klicken und darüber einkaufen, erhält Golem eine kleine Provision. Dies ändert nichts am Preis der Artikel.