Mikrocontroller

Boards

Optionen

Mikrocontroller gibt es in vielen verschiedenen Ausführungen. Die Boards unterscheiden sich dabei in Punkten wie Leistung, Anzahl und Art der Schnittstellen, eingebaute Sensoren und natürlich auch Kosten. Bekannte Produzenten sind zum Beispiel Arduino und Adafruit. Dabei handelt es sich um open-source Hardware-Hersteller, die Boards von guter Qualität zu erschwinglichen Preisen anbieten. Daneben gibt es aber noch sehr viel mehr Auswahlmöglichkeiten in diesem Bereich.

Welches Board für dein Projekt am besten geeignet ist, muss auf Grund deiner individuellen Bedürfnisse abgewogen werden. Einen guten Leitfaden dazu findest du hier.

Im weiteren Verlauf dieser Übersicht werden wir den Arduino Uno als spezifisches Beispiel nehmen. Dieser Controller wird auf Grund seiner angenehmen Grösse, guten Grundausstattung sowie dem Preis-Leistungs-Verhältnis oftmals als ideales Anfängermodel angepriesen. Die meisten Angaben lassen sich jedoch in gleicher oder leicht abgeänderter Form auch auf andere Boards anwenden.

Aufbau

Hier zeigen wir dir die wichtigsten Komponenten eines Mikrocontrollers:

(1) USB-Anschluss. Hierdurch wird der Arduino mit einem Computer verbunden, um den entsprechenden Code hochzuladen.

(2) Netzanschluss. Darüber wird das Board mit Strom versorgt, wenn es nicht an einen PC angeschlossen ist.

(3) Reset-Taste. Damit kann das Board bei Störungen manuell zurückgesetzt werden.

(4) Eingebautes LED. Kann durch die ID LED_BUILTIN angesteuert werden.

(5.a) Digitale In- und Output-Pins. Diese Anschlüsse können digitale Signale sowohl lesen als auch schreiben.
(5.b) Analoge Output Pins. Zusätzlich können Pins, die mit einem ~ gekennzeichnet sind, analoge Signale senden. Dies geschieht durch Pulse-width-Modulation (PWM).

(6) Analoge Input-Pins. Diese Anschlüsse können analoge Signale lesen.

(7) Spannungs-Pins. Hier können Spannungen von 3.3 V oder 5 V abgegriffen werden.

(8) Grund-Pins. Diese Pins fungieren als Grund, dem Spannungen zugeführt werden können.

(9) Mikrokontroller. Der eigentliche Chip, auf dem das Steuerprogramm gespeichert und ausgeführt wird.

Erweiternde Komponenten

Der Grundlegende Prozess im Physical Computing mit Mikrocontrollern sieht wie folg aus: Es werden Werte abgegriffen (Input), verarbeitet (Computation/Process) und schliesslich in einer neuen Form herausgespielt (Output).

Der Controller selbst kann dabei jedoch nur den mittleren Part übernehmen. Aus diesem Grund wird das System durch verschiedene In- und Output-Komponenten erweitert. Diese werden durch ein leitendes Material (meist Jumperwires) über die entsprechenden Pins mit dem Board verbunden.

Einige Beispiele für solche Erweiterungen:

Inputs

• Sensoren: In dieser Gruppe gibt es unzählige Bauteile, die unterschiedliche Gegebenheiten messen können. Von Optischen Komponenten wie Lichtmesser oder Kameras, über audiosensitive Teile wie Ultraschallsensoren bis hin zu haptischen Zusätzen wie Druck- oder Stretchsensoren – Und viele mehr!
• Digitale Schaltkontakte wie Switches und Knöpfe
• Analoge, verstellbare Widerstände wie Potentiometer
• Datenpakete (über Kabel-, WiFi- oder Bluetooth-Schnittstellen)

Outputs

• Leuchtdioden (LEDs) und Displays
• Lautsprecher
• Motoren und andere bewegliche Elektroteile

Dabei ist es wichtig zu beachten, ob es sich um digitale oder analoge Schnittstellen handelt. Digitale In- und Outputs sind binär. Dazu gehört beispielsweisse der Status eines Knopfes (gedrückt/nicht gedrückt) oder der eines LEDs (an/aus). Bei analogen Bauteilen erhalten oder senden wir ein Wert, der sich auf einem Spektrum befindet. So wird ein Lautstärke-Sensor je nach Geräuschpegel eine Zahl von 1 bis X senden und ein Motor kann innerhalb der Spanne eines bestimmten Winkels gedreht werden.

Durch diese Teile wird der Controller schliesslich zu einem Kleinstcomputer, der Daten aufnehmen, verarbeiten und weiterleiten kann. Wie die verschiedenen Komponenten mit dem Board verbunden werden müssen und welche Daten sie annehmen oder ausspielen, kann jeweils ihrer Dokumentation entnommen werden.

Programmierung

IDEs

Optionen

Um Code für einen Mikrocontroller zu schreiben und ihn anschliessend auf das Board zu laden, gibt es verschiedene Möglichkeiten. Über welchen Sprachen ein Controller programmiert werden kann, hängt vom Model ab. Hier findest du eine Übersicht über der gängigsten optionen. Im kreativen Physical-Computing ist es wohl die üblichste Variante, ein Board über Arduinos Integrated-Development-Environment (IDE) und durch Arduinos eigene Sprache (Sketch, C++ basiert) anzusteuern. Dieses System ist benutzerfreundlich und kommt mit dem Vorteil einer grossen, aktiven Community.

Daher werden wir uns im Folgenden auf diese Variante beschränken.

Einrichten

Als erstes musst du dafür die Arduino IDE herunterladen.

Bevor es losgeht, musst du noch zwei Voreinstellungen treffen. Wenn du den Reiter «Tools» anwählst, siehst du eine Auswahl mit dem Namen «Boards». Dort musst du den Mikrocontroller, mit dem du arbeiten willst, auswählen. Falls du dein Board nicht findest, kannst du durch den «Boards Manager» weitere Optionen herunterladen.

Als nächstes wählst du den korrekten Port deines Computers aus. Hierfür sollte dein Controller bereits über ein Kabel mit deiner Maschine verbunden sein. Unter der Einstellung «Port» solltest du nun sehen, an welchem Anschluss dein Board hängt. Wähle diesen aus.

Danach bist du bereit, loszulegen.

Wichtige Funktionen

Eine In-Depth-Einführung in die Arduino-Sprache und DIE findest du hier.

Im Nachfolgenden werden wir nur die wichtigsten Funktionen, die du zum Programmieren eines Mikrocontrollers benötigst, anschauen.

Datentypen und -strukturen

Anfangs wirst du meist folgende Datentypen benutzen:

• Integer (int): Ganze Zahlen
• Floating-Point Number (float): Zahlen mit Bruchteil
• Charakter (char): Zeichenwert

Bezüglich Datenstrukturen wird in Arduino oft mit Arrays gearbeitet. Diese erlauben es dir, mehrere Elemente desselben Datentyps in einer Liste unterzubringen.

Diese Variablen sind das erste, das du in deinem Script definierts – noch vor dem setup().

void setup() & void loop()

Wenn du ein neues Projekt in der Arduino-DIE öffnest, wird dein File diese zwei Funktionen bereits enthalten. In ihnen wirst du den Grossteil deines Codes platzieren.

Ins Setup packst du alle Tasks, die nur einmal, am Beginn des Scrips, ausgeführt werden sollen. Dazu gehören Dinge wie die Serial-Kommunikation (siehe: Serial.begin() & Serial.print()) aufzusetzen oder deine Pins zu definieren (siehe: pinMode()).

Die Loop-Funktion hingegen, wird, wie der Name vermuten lässt, permanent wiederholt. Hier platzierst du den Teil deines Codes, der perpetuell ausgeführt werden soll. Ein Besipiel dafür ist das lesen und beschreiben deiner Pins (siehe: xRead() & xWrite()).

pinMode()

Mit der Funktion pinMode(Pin Nummer, Modus) bestimmst du – du hast es bereits geahnt – den Modus eines Pins. Dabei musst du innerhalb der Funktion festlegen, welchen Pin du definieren willst und ob du ihn als INPUT oder OUTPUT aufsetzt.

xRead() & xWrite()

Diese Funktionen werden benutzt, um Werte von Pins abzulesen oder sie zu beschreiben.

• digitalRead(Pin Nummer) liest den Wert eines digitalen Pins aus.
• digitalWrite(Pin Nummer, Wert) schreibt einen HIGH- oder LOW-Wert an einen digitalen Pin.
• analogRead(Pin Nummer) schreibt einen Wert zwischen 0 und 1023 an einen analogen Pin.
• analogWrite(Pin Nummer, Wert) liest den Wert eines analogen Pins aus.

Serial.begin() & Serial.println()

Serial-Kommunikation ist dazu da, Werte aus deinem System herauszulesen und bei Gegebenheit weiterzuleiten.

Damit das funktioniert, musst du die Kommunikation zuerst implementieren. Dazu verwendest du in deinem Setup die Funktion Serial.begin(Baudrate). Die Baudrate ist die Schrittgeschwindigkeit in der Nachrichten empfangen werden. Je nachdem mit was für Komponenten du arbeitest, sind verschiedene Raten empfehlenswert oder sogar notwendig. Informationen dazu findest du jeweils in der entsprechenden Dokumentation.

Um die empfangenen Daten nun auszulesen, verwendest du die Funktion Serial.println(Wert). Diese printet den Wert, den du ihr vorgibst in die Arduino-Console – jeweils auf einer neuen Linie.

Upload

Hast du dein Programm geschrieben, kannst du es durch einen Klick auf das Verify-Symbol (1) testen. Erst, wenn du dort keine Fehlermeldung angezeigt bekommst, solltest du den Code auf dein Board laden (2).

Um die Funktionalität deines Programmes zu überwachen, kannst du nun den Serial-Monitor aufmachen. Dafür klickst du das Symbol mit der Lupe (3). Alles, was du mit Serial.println(Wert) herausspielst, wird nun hier erscheinen. Falls du jedoch einen fehlerhaften Output antriffst, stelle sicher, dass die Baudrate des Monitors (4) mit der Rate in deiner Serial.begin(Baudrate)-Funktion übereinstimmt.

Einfache Projekte

Um ein erstes Gefühl dafür zu bekommen, wie all diese Komponenten nun zusammenspielen, empfehlen wir dir, gleich mit einem einfachen Beispiel einzusteigen. Eine gute Auswahl findest du zum Beispiel hier. Die Boards sowie die Kleinteile, die du für solche Projekte benötigst, findest du in der MediaDock-Ausleihe sowie unserem Shop.