maschinenliebe #1

1 / 2011

machina eX || Lasse Marburg || Jan Philip Steimel

Die maschine liebt euch.

maschinenliebe Zwei Bastelanleitungen voller Liebe f端r Crowdfounding & Open Hardware

Editorial

Wir wollten das schon lange machen. Dinge basteln, dokumentieren, wie wir das gebastelt haben und dann der Community etwas zurückgeben aus der wir soviel geschenkt bekommen haben: machina eX sagt mit maschinenliebe jetzt endlich Danke. Danke an die Open Source Hardware Gemeinde, die uns mit ihren Foren, ihren Tutorials und ihrer Anfängerfreundlichkeit überhaupt erst möglich gemacht haben, dass machina eX jetzt macht, was wir machen: Computerspiele in echt. Theatrale Point and Click Adventures mit entschärfbaren Zeitbomben, Zahlenschlössern, Computerhacks und Chemierätseln (ok, das Chemierätsel ist eher Public Domain als Open Source). Wir arbeiten mehr als efolgreich mit Arduino-Boards, die wahrscheinlich die wichtigste Open Source Erfindung aller Zeiten darstellen. Wir lieben, was gerade geschieht. Und wir haben zwar viel zu wenig Expertise um wirklich mitzumischen bei den großen Entwicklungen in der Freien Hard- und Software, aber wir können denen was mitgeben, die so wie wir, keine Ahnung von nichts aber große Lust auf Abenteuer haben.

Danke an unsere startnext-Förderer, denen diese Ausgabe gewidmet ist! Nur durch euch haben wir Anfang diesen Jahres unser Elektrozeug zusammenkaufen können um unsere erste transportable Point and Click Performance zu entwickeln.

Nur durch die Hilfe dieser zweier Webgemeinden (den Crowdfunderinnen und den Open Source Hardware-Bastlerinnen) konnte machina eX so erfolgreich werden und vom 100° Festival am Hebbel am Ufer zum Impulse Festival 2011 nach Düsseldorf und zu unzähligen weiteren Stationen eingeladen werden. machinenliebe soll ab sofort 1-2mal im Jahr Bastelanleitungen für Volllaien zur Verfügung stellen. Allesamt entstanden in den interreaktiven Theaterproduktionen von machina eX. Wir wollen euch ein bisschen Liebe zurückgeben für die Wärme die wir von euch bekommen haben. Denn: die maschine liebt euch!

INHALT

How to make a time bomb

4

Arduino und simples (De-)Multiplexing

12

Eine Spielbare Zeitbombe zum Selberentschärfen

impressum/copyright

alle in maschinenliebe #1 veröffentlichten fotografien, texte, codes, schaltpläne und illustrationen stehen unter Creative Commons Lizenz (cc) BY-NC-SA 2.0 Jan Philip Steimel / Lasse Marburg / machina ex mit Ausnahme der Fotografie oben auf S.3 (rechts oben): Diese steht unter Creative Commons Lizenz (cc) BY-NC-SA 2.0 Robin Junicke und den Schaltplänen und schematischen Darstellungen auf S. 19: Diese sind (c) by Björn Wahlström und Tomek Ness, und dürfen mit freundlicher Genehmigung der Autoren genutzt werden.

Du darfst (und sollst) das Werk bzw. den Inhalt vervielfältigen, verbreiten und öffentlich zugänglich machen Abwandlungen und Bearbeitungen des Werkes bzw. Inhaltes anfertigen Zu den folgenden Bedingungen: Namensnennung — Sie müssen den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen.

Keine kommerzielle Nutzung — Dieses Werk bzw. dieser Inhalt darf nicht für kommerzielle Zwecke verwendet werden.

Weitergabe unter gleichen Bedingungen — Wenn Sie das lizenzierte Werk bzw. den lizenzierten Inhalt bearbeiten oder in anderer Weise erkennbar als Grundlage für eigenes Schaffen verwenden, dürfen Sie die daraufhin neu entstandenen Werke bzw. Inhalte nur unter Verwendung von Lizenzbedingungen weitergeben, die mit denen dieses Lizenzvertrages identisch oder vergleichbar sind.

-3-

Machinenliebe.#no.1

HOW TO MAKE A TIMEBOMB von Lasse Marburg und Philip Steimel

Einkaufsliste: - 1x 4fach 7-Segement Display Kingbright CA56-11EWA oder ähnlich (gemeinsame Anode) - 1x 8 Digit Display LED Driver ICM7218A oder ähnlich (gemeinsame Anode) - 8x 4,7kOhm Widerstände - 4 verschiedene Farben Schaltlitze - Schaltdraht - Empfohlen: 2 solderless breadboards zum Testen der

Schaltungen - Arduino Duemilanove oder Uno - Stiftleisten (mind. 8, besser mehr, passend zu Buchsenleisten) - Buchsenleisten (mind. 8, besser mehr, passend zu Stiftleisten) - Kneifzange - Cutter

Downloaden: - Arduino-Entwicklungsumgebung (www.arduino.cc) Wir werden eine Bombe bauen. Eine Zeitbombe um genau zu sein. Eine USB-Zeitbombe um noch genauer zu sein. Also eine Bombe, die du an einen Computer anschließen kannst und die dann auf ein Signal von dem Computer wartet, um den Countdown zu beginnen. Eine Bombe, die man aber natürlich auch entschärfen kann, indem man vier bunte Kabel, die aus ihr herausragen, in die richtige Reihenfolge steckt. Was passiert, wenn die Zeit abgelaufen ist, überlassen wir dir. Genauso wie: was passiert, wenn man sie entschärft. Wir für unseren Teil, spielen Sounds ab: Einen lauten Knall und einen bösen Game-Over-Track, wenn sie explodiert und den geilen langen lauten machina ex-Soundtrack wenn die Kabel richtig stecken.

Unsere Bombe soll mit folgenden Features aufwarten: Ein selbstleuchtendes Display mit vier Ziffern (mm.ss), das vom zentralen Programm aus angesteuert und ausgelesen werden kann. Zudem vier Steckverbindungen, deren Steckposition vom zentralen Programm aus gelesen werden können. Natürlich soll sie außerdem extrem gefährlich aussehen.

Damit du einen Eindruck bekommst, wie wir das Case gestaltet haben, schau dir doch mal die Illustration #1 an.

Die zwei wesentlichen - mein junges Leben prägende Erkenntnisse, habe ich den Ereignissen des vergangenen Jahres im Kampf der Theaterwissenschaftler mit den Computern zu verdanken: Wenn du etwas umsetzen willst, das du prinzipiell für unmöglich hältst, schau mal bei google und: wenn du dich mit Elektrotechnik auseinandersetzt, erwarte nicht, dass dich die Probleme erwarten, die du erwartest.

Letztere Erkenntnis hat zwei Seiten und muss regel-

-4-

Die maschine liebt euch.

mäßig aufgefrischt werden.

Eine Bombenattrappe mit Sekundenzeiger und ein paar Drähten. Muss gehen. Beim Bauen der Story hat auch niemand je Zweifel geäußert. Warum wir trotzdem (erneut) Nächte in zu kleinen Zimmern zwischen Verzweiflung und Erleichterung, zwischen halben Hähnchen und skeptischen Leidensgenossen verbracht haben ,um ein paar LEDs in der richtigen Reihenfolge zum Leuchten zu bringen, darf mit freundlicher Genehmigung aus der folgenden Bastelanleitung herausgelesen werden:

Das Hirn und seine Helfer (#4) Das Herzstück aller unserer Elektrotechnik oder besser: das Hirn ist das Arduino-Board. Ein Arduino ist ein Open Source-Microcontroller. Das ist, einfach gesagt: ein ganz kleiner, simpler Computer. Ohne Bildschirm. Ohne Tastatur. Die muss man selbst bauen (zum Beispiel in Form einer Zeitbombe). Aber dafür hat das Arduino einen USBStecker. Das ist toll, weil so kannst du es ganz einfach an deinen Computer anschließen und programmieren. Wenn „programmieren“ jetzt abgefahren schwer klingt: lies weiter. Das ist einfacher als man denkt und google und Arduino sind dicke Freunde. Wirklich! Das Arduino-Programm

erkläre ich dir später. Schauen wir mal weiter was wir sonst so brauchen: Um sieben LEDs anzusteuern, bräuchte man sieben schaltbare Stromgeber. Um 4 so genannte Sieben-Segment Displays anzusteuern (siehe Illustration #2) bräuchte man also 28 Stück davon. Mit dem Arduino allein kommen wir nicht aus, also brauchen wir ein weiteres Bauteil: Dass wir uns für den Mikrochip ICM7218A entschieden haben, liegt nicht daran, dass wir ihn für den besten hielten, sondern, dass er der einzige war dessen Einsatz für uns einigermaßen nachvollziehbar dokumentiert im Netz zu finden war.

Nichtsdestotrotz macht er seine Arbeit besser, als wir zu hoffen gewagt hätten.

Was der Chip macht ist recht einfach: Er liest digitale Signale vom Arduino (Illustration #3 und #4) und versteht welche Nummern das Arduino dargestellt haben will.

Dann verwaltet er die Stromzufuhr vom Arduino zu den LEDs des Displays und schaltet ganz schnell hintereinander die richtigen LEDs an und die anderen LEDs aus. Das geht so schnell, dass es aussieht als wären alle vier Ziffern gleichzeitig an. Ist aber gar nicht so. Der Chip arbeitet nur mit der Trägheit des Auges und spart damit einige Kabel-

-5-

Machinenliebe.#no.1

verbindungen. Kurz und gut also: Der 7218A-Chip übersetzt digitale Ziffern in Stromversorgung für das angeschlossene 7-Segment-Display. Er kann das für bis zu 8 Ziffern machen. Aber für unsere Bombe brauchen wir nur 4. Und ganz ehrlich: So haben wir auch schon genug Kabelsalat (wie du in Illustration #6 sehen kannst). Dabei musst du lediglich aufpassen wie du deine Displays beim Anschließen an den IC sortierst, sonst steuerst du die 4 Displays an, die du gar nicht angeschlossen hast.

Der 7218A und das 4-fach-Sieben-Segment sollten auf einander abgestimmt sein. Wir haben den Fehler gemacht und erst 4 einzelne große 7-Segment-Anzeigen gekauft, die einfach mehr Strom benötigt haben, als wir dem 7218A vom Arduino zur Verfügung stellen konnten. Als wir das verstanden hatten, vergriffen wir uns noch ein zweites Mal und kauften ein 7-Segment mit gemeinsamer Kathode. Das gute daran ist; du brauchst diese Fehler beim Einkaufen jetzt nicht mehr machen. Wenn du also einen anderen Chip oder ein anderes 7-Segment-Display kaufst: Achte darauf, dass beide mit „common anode“ ausgezeichnet sind und das 7-SegmentDisplay mit den 40mA des Arduinos auskommt.

Entschärft. (#5) Richtig cool fühlt man sich als Spielerin natürlich erst, wenn man die Bombe auch entschärft hat.

Dafür haben wir mittlerweile eine sehr schöne digitale Schaltung entworfen, die nur über das Arduino und ein paar Buchsen und Stiftleisten läuft: Um unsere eigenen Signalwege (Kabel, technischen Konstruktionen) sowie das Wohl des Zuschauers nicht zu gefährden, versuchen wir es tunlichst zu vermeiden, spitze Gegenstände, Scheren oder Zangen in der Ausstattung zu verwenden. So nahe es liegen mag: Die Bombe lässt sich nicht entschärfen, indem man das richtige Kabel durchtrennt! Vielmehr - und damit lässt sich auch das Rätseldesign interessanter gestalten - haben wir unserem Case vier Buchsen und vier farbige Drähte verpasst (s. Illustration #1 und #5), die, in der richtigen Anordnung miteinander verbunden Professor Hövel das Leben retten. Damit das Zentralprogramm mitbekommt, wann die Spieler mit einem ordentlichen Abspann belohnt werden dürfen, müssen

-6-

Die maschine liebt euch.

wir auslesen können, wann welches Kabel in welcher Buchse steckt. Das heißt, wir brauchen nicht nur die Information, ob der Stromkreis geschlossen oder offen ist, sondern müssen einen Weg finden herauszubekommen, welche von vier verschiedenen Eigenschaften der jeweils geschlossene Stromkreis hat. Das ist natürlich schwer, weil erstmal ja Strom da ist oder halt nicht.

Aber es gibt verschiedene Möglichkeiten Strom von Strom zu unterscheiden: Ursprünglich hatten wir eine analoge Lösung dafür vorgesehen, bei der wir uns die Analog-Eingänge des Arduino Boards zu nutzen machten. Wir veränderten mit unterschiedlichen Widerständen vor den einzelnen Kabeln, die Spannung auf den einzelnen parallel geschalteten Drähten. So konnten wir von jedem Draht am Arduino Input einen unterschiedlichen Wert zwischen 0 und 1024 (so viele Stufen hat der Analog-Digital-Wandler im Board) abfragen.

Das funktionierte erstmal auch sehr gut. Nur über die Zeit begannen die eigentlich recht starren Werte zu torkeln und wir mussten - statt uns gemütlich mit unserem Kaffee in der Hand zurückzulehnen - immer wieder per Hand nachkorrigieren. Ein Blick eines befreundeten Elektroingenieurs brachte ihm ein vergnügtes Grunzen

und uns eine bessere, viel einfachere und elegantere Idee: Digitale Abfrage.

In Illustration #5 siehst du, wie das aussieht: Die Widerstände sind hier bloß sogenannte pull-up- bzw. pull-downWiderstände, die sicherstellen, dass die digitalen Signale stabil bleiben, sie machen also erstmal nichts mit den Werten. Die analogen Eingänge des Arduinos nutzen wir hier auch als digitale Eingänge. Das folgende ArduinoSkript geht dann 4 digitale Ausgänge (an denen die Kabel mit den Steckern hängen) entlang, schaltet jeweils einen von denen AN (in Arduino-Code heißt das HIGH), während die anderen AUS (oder auch LOW) bleiben. Dann fragt der Code alle digitalen Inputs (an denen die Buchsen hängen), ob sie gerade ein Signal bekommen oder nicht und speichert das Signal anschließend in einer Variablen (einer Art Container für Information). Dann schaltet er den nächsten Draht auf HIGH und fragt wieder alle Inputs ab. Das Programm merkt sich also welche Drähte wo stecken und berichtet (printed) das der seriellen Schnittstelle, also in unserem Falle dem USB-Kabel, das wiederrum unserem Computer erzählt, wie es gerade um die Bombe steht. Das läuft, ähnlich wie bei den LEDs, so schnell ab, dass es wie gleichzeitig wirkt.

Um das Programm zum Laufen zu bringen, lade es über die Arduino-Software auf das Board. Das geht ziemlich

-7-

einfach. Die Einstellungen, die du vorher machen musst, kannst du auf der Arduino-homepage www.arduino.cc nachlesen. /* <-- Hinter diesen Zeichen beginnt ein Kommentar * Alles was hier steht gehรถrt nicht zum Programm und wird vom Arduino * Einfach ignoriert. * So kann man dem Code zusaetzliche Informationen hinzufuegen, die * nur vom Menschen lesbar sind. * * Mit diesen Zeichen wird der Kommentar beendet --> */ // <-- Alles was in der Zeile hinter // steht wird auch vom Arduino ignoriert // Zuordnung der #define kabelEINS #define kabelZWEI #define kabelDREI #define kabelVIER #define #define #define #define

buchseEINS buchseZWEI buchseDREI buchseVIER

PINS 10 11 12 13 14 15 16 17

// // // //

Analog Analog Analog Analog

boolean vier = 0; // Abfragen wo das erste Kabel steckt indem wir ein Signal auf den entsprechenden PIN geben // und dann an allen Buchsen fragen ob sie ein Signal bekommen digitalWrite(kabelEINS, HIGH); delay(10); // delay() erzeugt eine kurze Pause, damit wir sicher sein koennen, // dass der Pin ein Signal liefert bevor wir die Buchsen auslesen eins zwei drei vier

0 1 2 3

}

INPUT); INPUT); INPUT); INPUT);

digitalRead digitalRead digitalRead digitalRead

(buchseEINS); (buchseZWEI); (buchseDREI); (buchseVIER);

// Je nachdem welche Buchse nun ein Signal liefert schreiben wir // eine 1 in die entsprechende Variable if (eins == HIGH){ inEins = 1; } if (zwei == HIGH){ inZwei = 1; } if (drei == HIGH){ inDrei = 1; }

void setup() { // Welcher PIN soll welche Funktion erfuellen pinMode(kabelEINS, OUTPUT); pinMode(kabelZWEI, OUTPUT); pinMode(kabelDREI, OUTPUT); pinMode(kabelVIER, OUTPUT); pinMode(buchseEINS, pinMode(buchseZWEI, pinMode(buchseDREI, pinMode(buchseVIER,

= = = =

if (vier == HIGH){ inVier = 1; } digitalWrite(2, LOW); delay(10); // Nun widerholen wir den Vorgang mit den anderen 3 Kabeln digitalWrite(kabelZWEI,HIGH);

void loop() {

eins zwei drei vier

// Variablen in denen die information aus den PINs gespeichert wird // inEins speichert welches Kabel in der Buchse steckt usw. int inEins = 0; int inZwei = 0; int inDrei = 0; int inVier = 0;

= = = =

digitalRead digitalRead digitalRead digitalRead

if(eins == HIGH){ inEins = 2; } if(zwei == HIGH){ inZwei = 2; }

// eins bis vier speichern ob an der Buchse ein Signal anliegt oder nicht boolean eins = 0; boolean zwei = 0; boolean drei = 0;

if(drei == HIGH){ inDrei = 2; }

-8-

(buchseEINS); (buchseZWEI); (buchseDREI); (buchseVIER);

if(vier== HIGH){ inVier = 2; } digitalWrite(kabelZWEI,LOW);

// auswerten koennen. Wenn in der Buchse kein Kabel steckt wird // die Konsole 0 ausgeben.

Serial.print(„ Buchse 1: Kabel „); Serial.print(inEins); Serial.println();

delay(10);

Serial.print(„ Buchse 2: Kabel „); Serial.print(inZwei); Serial.println();

digitalWrite(kabelDREI,HIGH); eins zwei drei vier

= = = =

digitalRead digitalRead digitalRead digitalRead

(buchseEINS); (buchseZWEI); (buchseDREI); (buchseVIER);

Serial.print(„ Buchse 3: Kabel „); Serial.print(inDrei); Serial.println();

if(eins == HIGH){ inEins = 3; } }

if(zwei == HIGH){ inZwei = 3; } if(drei == HIGH){ inDrei = 3; } if(vier== HIGH){ inVier = 3; } digitalWrite(kabelDREI,LOW); delay(10); digitalWrite(kabelVIER,HIGH); eins zwei drei vier

= = = =

digitalRead digitalRead digitalRead digitalRead

(buchseEINS); (buchseZWEI); (buchseDREI); (buchseVIER);

if(eins == HIGH){ inZwei = 4; } if(zwei == HIGH){ inDrei = 4; } if(drei == HIGH){ inDrei = 4; } if(vier== HIGH){ inVier = 4; } digitalWrite(kabelVIER,LOW); // Jetzt wissen wir in welcher Buchse welches Kabel steckt. // Ueber unseren USB Anschluss senden wir die Daten an den // Rechner, wo wir sie z.B. in der Konsole des Arduino Programmes

Serial.print(„ Buchse 4: Kabel „); Serial.print(inVier); Serial.println();

Wir senden alle Informationen über das USB-Kabel des Arduinos zum MAX-Patch, in dem zu jeder Zeit abgefragt wird, in welcher Kombination die Drähte stecken, so dass eine bestimmte Kombination die Lichtstimmung, den Soundtrack und das Display unserer Bombe auf Sieg oder Explosion stellt.

Man könnte also zusammenfassend erklären, wie das Gesamtsystem der Zeitbombe funktioniert: Die Stecker leiten ein Signal vom Arduino zurück in das Arduino, so dass es ausmachen kann, in welcher Reihenfolge sie stecken. Das Arduino erzählt dann über die USB-Schnittstelle dem Zentralcomputer, wie die Kabel stecken, der entscheidet dann, ob der Countdown weiterläuft oder ob die Bombe entschärft ist und sendet die jeweiligen Informationen an das Arduino zurück. Das wiederum schickt die Informationen an den ICM7218A DisplayTreiber, der das Sieben-Segment schaltet und zum Leuchten bringt. Eine lange Kette, aber - so betrachtet - gar nicht so kompliziert, oder?

Die Korrelation zwischen Countdown und Drahtkombination ließe sich natürlich auch direkt auf dem Arduino realisieren, da es wie ein echter kleiner Computer einen eigenen Speicher und einen eigenen Prozessor hat. Um die Sache im Probenprozess dynamischer anpassen zu können, haben wir uns aber entschieden, das Display vom Zentralprogramm aus anzusteuern. So entstand - nicht ohne eine gewisse hämische Vorfreude - auch ein kleiner Codeabschnitt, der, je nachdem wie weit die Zeit fortgeschritten ist, den Countdown schneller gen Detonation zählen lässt, sobald mindestens einer der Drähte gezogen ist.

Wenn du den Code oben sehr sehr aufmerksam gelesen hast, wirst du bemerkt haben, dass das nur der Code für das Kabelrätsel ist. Das Programm für die ganze Bombe enthält diesen Code, aber auch einige zusätzliche Zeilen zur Kommunikation mit dem Computer und dem 7-Segment-Display und ist viel zu lang, um ihn hier abzudrucken. Du kannst ihn unter www.machinaex.de/phase0.zip zusammen mit einem kleinen MAX/

-9-

Machinenliebe.#no.1

Msp Programm herunterladen, indem du die Bombe abfragen und fernsteuern kannst.

Kabelsalat Bevor du dich jetzt an den Lötkolben setzt um die Bombe in ihrer schönsten Form für die Ewigkeit zusammenzubringen sollest du das Ganze natürlich testen.

Wenn du die Illustrationen #1 bis #5 genau liest, solltest du so unsere Bombe schon mal auf dem Steckbrett nachbauen können. Ich habe dir die Schaltpläne einzeln aufgezeichnet, damit du nicht ganz erstickst in dem Kabelsalat, den so ein Projekt mit sich bringt. Damit du aber mal siehst, wie der ganze Komplex zusammen wirkt, kannst du in Illustration #6 einmal einen Blick in den Schlund des Chaos werfen. Aber keine Angst. Wenn du alles nacheinander verkabelst und mit Geduld vorgehst, solltest du eine funktionierende USBZeitbombe bekommen, die du mit dem Arduino-Programm und unserem MAX-Patch zum ultimativen Partyknaller ausbauen kannst.

und lies Matthias Artikel über Dilletantismus: Da findest du einen sehr sehr weisen Satz, den du während des Zusammenbaus immer wieder bedenken solltest: Im Zweifelsfall einfach googlen.

Um zu überprüfen ob alles richtig steckt müssen wir zunächst ein Programm auf dem Arduino zum Laufen bringen, das dem IC sagt was er zu tun hat: Hier greifen wir in die Größte aller Trickkisten und hüten uns das ganze Schummeln zu nennen: Der Kernteil unseres Programmes ist ein Fundstück aus dem Internet: http://ardugonic.blogspot.com/2010/05/ driving-8-digits-7-segment-display-with.html Natürlich findest du den Code auch unter www.machinaex. de/phase0.zip ...ebenso wie die Verkabelung und die Identifizierung der Bauteile... „ardugo“ hat eine kompakte Methode (ein Programmabschnitt auf den man zugreifen kann) geschrieben, die die Steuerung des ICs koordiniert. Um etwas auf dem Display anzuzeigen müssen wir nur die write8digits() Methode aufrufen und ihr die gewünschte Zahl zwischen 9999 und 0000 übergeben und dann hoffen, dass wir alles richtig verbunden haben. Wenn dir das zuviel Programmierergefasel ist, schau einfach noch mal auf www.arduino.cc/learning nach.

Da bekommst du eine gute Einführung in die Grundstrukturen der Arduino-Programme.

An dieser Stelle also ein dickes Danke an „ardugo“ aus Barcelona. Ohne dich wüsste der Professor Hans Hövel aus unserem Stück 15.000 Gray nicht, wann sein letztes Stündchen geschlagen hat.

Wie du merkst gibt es beim Zusammenbau von Arduino, ICM7218A und 7-Segment-Displays einiges zu verkabeln.

Nimm dir vor dem endgültigen Verlöten ein wenig Zeit dir einen guten Plan zu machen, wie du die Bauteile anordnest, damit sie in dein Case passen und genug Platz für die einzelnen Lötverbindungen besteht. Zudem solltest du dir eine Reihenfolge überlegen nach der du die Kabel verbindest und wie lang welcher Draht dabei sein muss, es wird garantiert eng. Aber es ist machbar!

Wenn du verzweifelst, nimm dir doch das Buch zur Hand

-10-

Die maschine liebt euch.

-11-

(de)Multiplexing mit Arduino

von Philip Steimel auf Basis des Tutorials Analog Multiplexer/Demultiplexer 4051 von Tomek Ness ( http://www.arduino.cc/playground/Learning/4051 )

Abb.1

-12-

-13-

Einkaufsliste: - mind. 9 (besser mehr) 4051 Multiplexer in DIP16 (z.B. 4051L-D16-T ) - 8 bis 64 Buttons (je nachdem ob du es in voller Komplexität bauen willst oder nur die Grundlagen begreifen willst) - 8-64 Widerstände 1-10KOhm - Schaltdraht - 1 Arduino „Uno“ - evtl. 8-64 LEDs (wenn du auch die andere Richtung probieren willst oder sehen willst wann der Button gedrückt ist.)

Wozu zur Hölle ist ein Demultiplexer gut?

Ein Multiplexer/Demultiplexer macht es möglich über eine Leitung mehrere unterschiedliche Signale laufen zu lassen und sie danach noch auseinanderhalten zu können.

Wenn ich zum Beispiel einen kleinen Bildschirm bauen möchte, dessen Bild aus, sagen wir 64 Pixeln besteht (das wäre eine sehr kleine Auflösung, aber es wäre sicher interessant Spiele dafür zu programmieren). Sagen wir jeder Pixel wird durch eine LED gesteuert, die entweder an oder aus ist. Jetzt könnte ich natürlich jede LED einzeln verkabeln und an meinen Computer anschließen. Das ist nicht nur ganz schön viel Arbeit, ich müsste mir auch ganz schöne viele Ausgänge an den Computer anbringen, um alle 64 Kabel gleichzeitig zu bedienen.

Ich könnte aber auch einfach alle 64 LEDs hintereinander ansteuern. Wenn ich das schnell genug mache, sieht man das gar nicht. Und dann müsste es ja reichen wenn nur ein Kabel von meinem Computer zu den LEDs führt. Wenn ich das aber direkt so mache hab ich wieder ein Problem: Ich kann nur alle LEDs gleichzeitig an oder aus schalten, aber mir nicht aussuchen welche LEDs jetzt an sein sollen und welche aus. Also brauche ich eine Art Cowboy, der zur Richtigen Zeit die richtigen Gatter aufmacht, damit jedes Signal (AN oder AUS) an die richtige LED getrieben - äh - geleitet wird. Genau diese Aufgabe übernimmt ein Multiplexer. Demultiplexer nennt man das dann wenn es die andere Richtung geht: Wenn ich zum Beispiel 64 Knöpfe oder Tasten habe und die über eine Leitung zu meinem Computer (oder Arduino) gehen sollen. Eine richtige Tastatur würde ich so zwar auch nicht anschließen, weil es da wieder Probleme mit dem Timing gibt, aber das ist ein Problem mit dem wir uns hier nicht befassen brauchen.

Die beiden Beispiele habe ich, genau wie die Anleitung die jetzt folgt, aus Gründen der Verständlichkeit genommen.

Um ein Display zu bauen würde man normalerweise nicht so vorgehen, sondern mit einer LED-Matrix arbeiten.

Das ist aber ein ganz anderes Thema und hilft nicht viel beim Verstehen, was ein Demux tut. Ein weiterer Grund warum die Buttons zwar ein gut verständliches Beispiel abgeben aber auch etwas verschweigen ist folgendes: Ein Drucktaster kennt nur zwei Zustände (Gedrückt und nicht Gedrückt). Das tolle an dem 4051er ist aber dass er nicht nur für digitalWerte benutzt werden kann, sondern auch analoge Signale schaltet. D.h. du kannst in der folgenden Anleitung natürlich auch jeden Drucktaster durch

zum Beispiel einen Drehregler (Potentiometer) ersetzen ( in Abb. 5 siehst du einen Aufbau wo ich das zum Teil gemacht habe) und dessen Daten auslesen. Alle Werte werden sich dabei immer zwischen 0 und 1023 bewegen.

Dass das einen wesentlich mächtigeres Werkzeug ist als die simple Schaltung die wir zuerst einmal basteln werden, leuchtet da ein. Aber zu erst einmal wollen wir es simpel und übersichtlich halten, damit du alles verstehst und danach selbst weiterarbeiten kannst: Für machina eX zum Beispiel ist ein Demultiplexer schon sehr praktisch: Bei unseren Games passieren die meisten Sachen (Eingaben an Geräten) ja nacheinander und nicht gleichzeitig. So können wir dann zum Beispiel ein Telefon, die Uhrzeiger, das Zahlenschloss, den Schwesternpieper, den evil Supercomputer und und und einfach alle an einen Demultiplexer anschließen und alle in einen Analogeingang unseres Arduinos stecken. So haben wir dann noch Analoge Ausgänge frei um zum Beispiel unsere Kaffeemaschine feinzujustieren (Lasse ist nur immer noch nicht fertig mit dem Hack) oder zum Beispiel unsere Massagestühle zu bedienen oder... naja. ich denke du verstehst schon.

der 4051er Der Multiplexer/Demultiplexer den wir hier benutzen werden gibt es von vielen Firmen gib einfach HC4051 bei deinem Elektrohändler ein und nimm einen von den angebotenen. Sie sollten alle Funktionieren. Höchstens die PINs könnten vertauscht sein (ist bei mir bisher noch nicht vorgekommen).

Der 4051er kann 8 Ein- bzw. Ausgänge schalten. Das werden wir auch zuerst einmal machen, damit man sieht, wie der Chip so funktioniert. Danach gehen wir mit einem Trick auf 64 Kanäle. Dafür braucht man dann unseren ersten Chip und noch 8 weitere 4051er. Das gibt dann ganz schönen Kabelsalat. Es reicht aber auch wenn du erstmal nur zwei Chips benutzt. Das Prinzip (und der ArduinoCode) bleibt nämlich dasselbe, außer du willst noch mehr als 64Kanäle schalten. Das hab ich mich aber noch nicht getraut, weil ich bei sowas immer die Übersicht und dann die Geduld über die Kabel verliere... Aber vielleicht bist du ja zäher als ich...

Aber fangen wir erstmal an: Die große Abbildung da oben sieht ja ziemlich chaotisch aus, wenn man sie aber in ihre Einzelteile zerlegt, wird das schon ganz anders. Also lass dich bitte nicht von dem Wirrwarr abschrecken.

Wir wollen hier ersteinmal den 4051er Chip als Multiplexer benutzen. Das unterscheidet sich (beinahe) gar nicht vom Demultiplexen, sondern liest sich vielmehr nur genau verkehrt herum: Du kannst das nachvollziehen wenn du in Abb.1 von links nach rechts liest: Du hast ganz links unten einen von 64 Buttons. Der gibt ein Signal durch, wenn man ihn drückt und das nur solange wie man ihn gedrückt hält. Wir wollen jetzt mit nur

-14-

einem Arduino Board (ganz rechts zu sehen) alle 64 Buttons auslesen können. Zum Beispiel weil wir uns eine riesige Spezialtastatur bauen wollen. Dazu versorgen wir den Buttoneingang erstmal mit Strom (+) und leiten den Strom dann durch einen Widerstand zum Minuspol (-). Um den Status über das Arduino abzufragen, würden wir jetzt normalerweise vor dem Widerstand ein Kabel abzweigen lassen und in einen der Analog oder Digital-Inputs des Arduino-Boards leiten.

Das hat aber gar nicht genug Eingänge für alle unsere But-

Abb.2

Abb.3 -15-

tons, deshalb leiten wir (64x) den Ausgang des Buttons vor dem Widerstand zu einem der 8 4051er, die ich mal slaveschalter genannt habe. Der Button kann (wie man auch in der Abb.1 sehen kann) entweder zu den 4051er Pins 1,2,4,5,12, 13, 14, 15 oder 16 führen. Unser Beispielbutton z.B. mündet an Pin 1. Diese Pins sind die Input-Pins unseres slave-Multiplexers. Der (und seine 7 Geschwister) bekommen über die Pins 9, 10 und 11 vom Arduino-Board mitgeteilt, welchem Eingang er jetzt seine volle Aufmerksamkeit schenken soll um ihn dann an den Hub/Hauptschalter weiterzuleiten. Das macht der Slave-4051er dann auch und zwar via Pin 3 an einem der Input-Pins (1,2,4,5,12,13,14,15,16 in der Abb. ist es Pin 13) des Hauptschalters/Hubs. Der macht genau dassselbe wie die Slave-Schalter nur dass er eben nicht die direkten Signale von den Buttons verwaltet und weiterleitet, sondern die Signale der 8 Slave-4051er. Das macht für ihn gar keinen Unterschied, weil er die Signale einfach weiterleitet. Welchen der 8 Inputs er jetzt weiterleiten soll, bekommt er auch direkt vom Arduino mitgeteilt und zwar (man ahnt es schon) über die Pins 9,10 und 11.

Nur dass im Gegensatz zu den Slave-Schaltern deren Pins 9, 10 und 11 alle an denselben Arduino Output-Pins angeschlossen sind (in der Abb. sind es 13, 12 und 11), der Haupschalter seine ganz eigene „Telefonleitungen“ zum Arduino hat (nämlich auf die Pins 3, 4, und 5).

Das Arduino Board schickt dann quasi nur zwei Nummern (wenn auch ganzschön verschlüsselt, wie du unten im Arduino Code sehen wirst): Einmal an den Hub die Nummer des Slave-SChalters, der gerade wichtig ist (8 gibt es zur Auswahl). Und dann eine Zahl an alle Slave-Schalter: Nämlich die Nummer des Inputs der Abgefragt werden soll.

So kann er alle 64 Buttons adressieren und abfragen und das nur über einen Input (Analog-Pin 5 in der Abb.).

Das Arduino kann jetzt natürlich immer nur einen einzelnen Button gezielt ansprechen, würde dann mitgeteilt bekommen, ob der Button gerade gedrückt ist oder nicht, und kann sich dann erst dem nächsten Button widmen. Aber weil das Arduino-Board ein kleiner Computer ist und dafür auch schon ganz schön schnell, macht es genau diese Abfrage einfach immer und immer wieder nacheinander mit allen 64 Inputs. Das geht so schnell, dass wir die Verzögerung kaum wahrnehmen und uns deshalb einfach so verhalten können als würden alle 64 Buttons gleichzeitig abgefragt werden. Auch wenn dem eigentlich gar nicht so ist.

Damit das Arduino Board das auch alles so schön nacheinander macht, musst du nur noch den folgenden Code aufspielen (wie das geht, erfährst du auf der homepage von arduino.cc oder zum Beispiel im Büchlein „Getting Started with Arduino“ von Massimo Banzi): int r0 = 0; //value select pin at the 4051 (s0) int r1 = 0; //value select pin at the 4051 (s1) int r2 = 0; //value select pin at the 4051 (s2)

int row = 0; int count = 0; int int int int int int

row1 = row2 = row3 = binNul binOne binTwo

// storeing the bin code // just a count

0; 0; 0; [8] = {0, 0, 0, 0, 1, 1, 1, 1}; [8] = {0, 0, 1, 1, 0, 0, 1, 1}; [8] = {0, 1, 0, 1, 0, 1, 0, 1};

void setup(){ pinMode(13, OUTPUT); pinMode(12, OUTPUT); pinMode(11, OUTPUT); }

// s0 // s1 // s2

Serial.begin(9600);

void loop () { for (count=0; count<=7; count++) { row1 = binNul[count]; row2 = binOne[count]; row3 = binTwo[count]; r0 = row1; r1 = row2; r2 = row3; digitalWrite(13, r0); digitalWrite(12, r1); digitalWrite(11, r2); Serial.print(„ „); Serial.print(r0); Serial.print(r1); Serial.print(r2); Serial.print(„ „); Serial.print(analogRead(5)); Serial.print(„ „); Serial.print(„||“); delay (0);

}

if (count==7){ Serial.println(); }

}

Jetzt fragst du dich bestimmt: Und was passiert wenn ich den verdammten Button drücke? Bisher nämlich noch nichts, was du sehen kannst. In Abb. 2 und 3 habe ich einmal zwei Fotos gemacht von einem Aufbau mit nur einem Slave-4051er um es übersichtlich zu halten. In Abb.4 siehst du dann was passiert wenn ich einen der Buttons drücke während du den Serial Monitor in der Arduino-Entwicklungsumgebung geöffnet hast (bitte vergiss nicht die Baudrate unten rechts auf 9600 zu stellen sonst bekommst du nur ganz wirre zahlen und buchstaben zu sehen): Du kannst jetzt den Analog-Wert (0-1023) sehen, der beim

-16-

Arduino Input (A5) ankommt. Wenn du alles richtig verbunden hast, solltest du überall einen 0-Wert angezeigt bekommen, bis du einen Button drückst. Dann sollte der Wert auf über 0 nahe 1023 hüpfen. Und wenn du loslässt wieder zurück auf 0.

Damit hast du einen 64 Kanal Multiplexer gebaut. Was du damit anstellt, ist ganz dir überlassen. Du könntest noch 64 LEDs über den gleichen Aufbau ansteuern lassen und mit den einzelnen Buttons an und aus machen. Das wird aber eine Menge Kabelsalat geben. Oder du besorgst dir ein Sieben-Segment-Display und lässt dir anzeigen, welcher Button gerade gedrückt ist. Oder du baust damit dein eigenes Keyboard und machst geile elektronische Musik oder oder oder.... Denk dir was aus und schau dir auf jeden Fall noch das schöne Tutorial (mit übersichtlichem Schaltplan) von Tomek Ness unter http://www.arduino. cc/playground/Learning/4051 an. Da erfährst du auch wie einfach es ist den Aufbau hier zu einem DemultiplexerAufbau (z.B. für 64 einzeln ansteuerbare LEDs) umzufunktioniern.

Abb.5

Abb.4

-17-

Machina bedankt sich

-18-

7

4 3

6

Digital-Out-Pin

2

4051

5

s1

s2 y2

y3

y4

y5

y6

y7

1

2

3

4

5

6

7

8

z

s0

y1

4051

y0

Vcc [5v] Digital-In-Pin

4051 A

y0

s0

B

y1

s1

C

y2

s2

D

y3

E

y4

F

y5

G

y6

H

y7

y4

1

16

Vcc

y6

2

15

y2

z

3

14

y1

y7

4

13

y0

y5

5

12

y3

E

6

11

S0

Vee

7

10

S1

gnd

8

9

S2

Pin configuration

z

GND

(c) björn wahlström and thomas ness for Re-Memorize - k3 / 2005

8 Analog Inputs

Selected through 3 digital Outpins from the arduino

4051 A1

y0

s0

A2

y1

s1

A3

y2

s2

A4

y3

A5

y4

A6

y5

A7

y6

A8

y7

B1

y0

s0

B2

y1

s1

B3

y2

s2

B4

y3

B5

y4

B6

y5

B7

y6

B8

y7

z

1 Analog Output

A

4051

4051 z

B

A

y0

s0

B

y1

s1

C

y2

s2

D

y3

E

y4

F

y5

G

y6

H

y7

AnalogInPin

z

ANHANG ein paar Schaltpläne und schematische Darstellungen des 4051er Aufbaus, die uns Tomek Ness liebenswürdiger Weise zur Verfügung gestellt hat, und die euch vll eine bessere Übersicht geben als der Kabelsalat in der Illustration zum Demultiplexer...

4051 H1

y0

s0

H2

y1

s1

H3

y2

s2

H4

y3

H5

y4

H6

y5

H7

y6

H8

y7

z

H

DigitalOutPin

2

DigitalOutPin

3

5 6

4

7

(c) björn wahlström and thomas ness for Re-Memorize - k3 / 2005

-19-

dankt Robin Junicke // Tomek Ness // startnext.de // arduino.cc // iconodul // rena // fraujule // kochand //michael-kranixfeld // tino // mk089 // plastikbier //sebastian-standke //maiket //elCheffe //emmi59 //mehju //projektariel // mwmertens // rumpler //bogus-f-trumper

-20-