.. index:: Arduino .. _Elektronik mit Arduinos: Elektronik mit Arduinos ======================= Arduinos sind kleine Entwickler-Boards, die einen programmierbaren Mikrocontroller enthalten; sie lassen sich via USB mit einem Computer verbinden und lassen sich bei entsprechender Programmierung für vielseitige Elektronik-Projekte einsetzen. .. figure:: pics/arduino/arduino-uno.png :name: fig-arduino-uno :alt: fig-arduino-uno :align: center :width: 50% Das Entwicklerboard Arduino UNO. .. only:: html :download:`SVG: Arduino UNO ` Einen Mikrocontroller kann man sich allgemein als einen winzigen Computer vorstellen; er vereinigt eine Recheneinheit (CPU), einen Arbeitsspeicher, einen permanenten Speicher, eine USB-Schnittstelle, einen Display-Controller sowie einen Analog-Digital-Wandler auf einem einzigen Bauteil. Selbstverständlich ist ein Mikrocontroller, was die Performance anbelangt, nicht mit einem "echten" Computer zu vergleichen; für einfache Sensor- oder Steuerungs-Schaltungen reichen Mikrocontroller jedoch meist völlig aus. Im folgenden werden verschiedene Projekte für Arduino-UNO-Boards vorgestellt. Diese "klassischen" Arduinos enthalten den Mikrocontroller "ATmega328", der optional sogar vom Arduino-Board entnommen und direkt in elektronische Schaltungen eingebaut werden kann. Da ein ATmega328 als Baustein nur etwa drei Euro kostet, kann man Arduino-Boards also auch als Programmier-Hilfe für diese Bausteine nutzen. .. index:: Arduino; Pin-Belegung, Pulsweiten-Modulation (PWM) .. _Aufbau eines Arduino UNO im Detail: .. rubric:: Aufbau eines Arduino UNO im Detail In der folgenden Abbildung sind die wichtigsten Komponenten eines Arduino UNO mit kurzen Beschreibungen aufgelistet. .. figure:: pics/arduino/arduino-uno-mit-beschreibung.png :name: fig-arduino-uno-mit-beschreibung :alt: fig-arduino-uno mit-beschreibung :align: center :width: 90% Das Entwicklerboard Arduino UNO im Detail. .. only:: html :download:`SVG: Arduino UNO mit Beschreibung ` Über die Pin-Leisten auf beiden Seiten des Arduinos kann dieser mittels Jumper-Kabeln mit externen Elektronik-Komponenten beziehungsweise einer Steckplatine verbunden werden: * Die analogen Pins ``A0`` bis ``A5`` sind als Sensor-Eingänge zum Messen von Spannungswerten zwischen :math:`\unit[0]{V}` und :math:`\unit[5]{V}` geeignet; durch einen eingebauten Analog-Digital-Wandler werden die gemessenen Spannungswerte auf einem Zahlenbereich von ``0`` (keine Spannung) bis ``1023`` (maximale Spannung, also :math:`\unit[5]{V}`) abgebildet. * Die digitalen Pins ``0`` bis ``13`` können ebenfalls als Sensor-Eingänge festgelegt werden: Eine anliegende Spannung von :math:`\unit[>2,5]{V}` wird als ``HIGH`` (Zahlenwert ``1``), eine niedrigere Spannung als ``LOW`` (Zahlenwert ``0``) interpretiert. * Die digitalen Pins ``0`` bis ``13`` können zudem als digitale Spannungs-Ausgänge festgelegt werden: Sie geben im Modus ``HIGH`` eine Spannung von etwa :math:`\unit[5]{V}`, im Modus ``LOW`` eine Spannung von :math:`\unit[0]{V}` aus. Die Stromstärke ist dabei allerdings auf :math:`\unit[40]{mA}` begrenzt; gegebenenfalls wird die Spannung der Pins automatisch herab geregelt, um diese Begrenzung zu erreichen. Eine Besonderheit stellt der Digital-Pin ``13`` dar: Dort ist der Ausgabe-Strom auf nur :math:`\unit[20]{mA}` begrenzt, so dass dort eine LED direkt (ohne Vorwiderstand) angeschlossen werden kann (direkt neben Pin ``13`` ist ein ``GND``-Pin, so dass dafür nicht einmal eine Steckplatine nötig ist). Bei neueren Versionen des Arduino UNO ist zwischen Pin ``13`` und ``GND`` sogar eine SMD-LED fest eingebaut. * Die mit dem Tilde-Zeichen ``~`` versehenen Pins (``3``, ``5``, ``6``, ``9``, ``10``, ``11``) können, wenn sie als Ausgabe-Pins festgelegt werden, zudem mittels einer so genannter Pulsweiten-Modulation (PWM) sehr schnell zwischen :math:`\unit[0]{V}` und :math:`\unit[5]{V}` hin und her wechseln. Man kann dabei Werte zwischen ``0`` und ``255`` angeben, wobei ``0`` für "immer aus" und ``255`` für "immer an" steht. [#]_ Die übrigen Anschlüsse des Boards (AREF- und ICSP-Header) sind für eine normale Benutzung nicht von Bedeutung. .. index:: Arduino; Software (IDE) .. _Installation der Arduino-Software: Installation der Arduino-Software --------------------------------- Damit ein Arduino die gewünschte Funktion erfüllen kann, muss er programmiert werden. Dafür benötigt man lediglich die gleichnamige Arduino-Entwicklungsumgebung und/oder das Programm "Fritzing" (optional, aber empfohlen). Unter Linux Mint / Ubuntu lassen sich diese beiden Programme folgendermaßen installieren: .. code-block:: sh # Software-Pakete installieren: sudo aptitude install arduino fritzing # Benutzer zur Gruppe "dialout" hinzufügen: sudo usermod -aG dialout BENUTZERNAME Das Hinzufügen des angegebenen Benutzers zur Gruppe ``dialout`` ist nötig, damit dieser vom Linux-System notwendige Schreibrechte erhält: Schließt man ein Arduino-Board via USB am Computer an, so benötigt man diese Schreibrechte, um mittels des so genannten "Seriellen Ports" Code an den Arduino senden zu können. [#]_ **Wichtig:** Die Rechte-Anpassung erfordert einen erneuten Login des Benutzers, um wirksam zu werden! Nach der Installation kann die Arduino-Software aus einer Shell heraus mittels ``arduino`` oder über ``Startmenü -> Entwicklung -> Arduino IDE`` gestartet werden. .. figure:: pics/arduino/arduino-ide.png :name: fig-arduino-ide :alt: fig-arduino-ide :align: center :width: 50% Die Arduino-Entwicklungsumgebung. Im Hauptfenster des Programms kann wie mit einem Texteditor Quellcode eingegeben werden. Unten links wird die Nummer der aktuellen Zeile im Quellcode eingeblendet, unten rechts das derzeit ausgewählte Arduino-Board (Standard: Arduino UNO); ein anderes Arduino-Board über das Menü ``Tool -> Boards`` ausgewählt werden. * Hat man den gewünschten Quellcode eingegeben, so kann man diesen mittels des ``Überprüfen``-Icons in der Symbolleiste auf Syntax-Fehler testen. .. image:: pics/arduino/arduino-symbol-check.png :align: center * Wurde der Syntax-Check ohne Fehlermeldung durchlaufen, so kann man den Code kompilieren und an das Arduino-Board senden. Hierzu genügt ein Klick auf das ``Upload``-Icon in der Symbolleiste: "Überprüfen"-Icons in der Symbolleiste auf Syntax-Fehler testen. .. image:: pics/arduino/arduino-symbol-upload.png :align: center Der Syntax-Check ist optional, man kann auch unmittelbar auf das Upload-Icon klicken, wenn man den Code kompilieren und an das Arduino-Board senden möchte. Falls während des Kompilierens oder des Sendens ein Fehler auftritt, so werden im unteren Teil des Arduino-Fensters entsprechende Meldungen ausgegeben, die bei der Fehlersuche hilfreich sein können. .. rubric:: INO: Arduino aus einer Shell heraus ansteuern (optional) Die Arduino-IDE ist zwar einfach zu bedienen; wer allerdings einen so komfortablen Editor wie :ref:`Vim ` in Kombination mit dem :ref:`Vicle-Plugin ` und :ref:`tmux ` gewohnt ist, der wird auf seine gewohnte Umgebung kaum verzichten wollen. Unter Linux müssen hierfür folgende Pakete installiert werden: .. code-block:: sh sudo aptitude install picocom python-setuptools sudo easy_install ino Das Hauptprogramm, das die Kommunikation mit dem Arduino übernimmt, heißt `Ino `__; momentan gibt es allerdings nur eine Variante für Python2. Hat man die obigen Pakete installiert, so kann man, wie im `Quickstart-Tutorial (en.): `__ ausführlich beschrieben, ein neues Projekt anlegen: .. code-block:: sh # Projekt-Ordner erstellen: mkdir arduino-projekte # In den Projekt-Ordner wechseln: cd arduino-projekte # Projekt initiieren: ino init -t blink Durch die obigen Anweisungen wird im Projekt-Ordner ein ``lib``-Verzeichnis für mögliche externe Programm-Bibliotheken sowie ein ``src``-Verzeichnis für den eigentlichen Quellcode des Projekts angelegt. In diesem Verzeichnis wird durch den Aufruf von ``ino init`` automatisch die Datei ``sketch.ino`` neu angelegt; durch die optionale Angabe von ``-t blink`` enthält diese Datei ein minimales Beispielprogramm; bei einem Aufruf von ``ino init`` ohne weitere Argumente enthält diese Datei lediglich eine leere ``setup()`` und ``loop()``-Funktion als Template. Um ein Arduino-Programm (häufig auch "Sketch" genannt) zu kompilieren, kann man im Projekt-Ordner folgendes eingeben: .. code-block:: sh # Projekt kompillieren: ino build Wurde der Kompilierungs-Vorgang erfolgreich durchlaufen, so kann man das Programm anschließend auf den Arduino hochladen: .. code-block:: sh # Projekt auf Arduino hochladen: ino upload Fertig! Wurde der oben optional gewählte Beispielcode ``blink`` nicht verändert, so beginnt die im Arduino am Pin 13 fest eingebaute LED zu blinken. Möchte man ein anderes Arduino-Board als ein Arduino-UNO nutzen, so kann man die unterstützten Typen mittels ``ino list-models`` anzeigen und beispielsweise bei Verwendung eines Arduino Mega 2560 mittels ``ino build -m mega2560`` als Ziel festlegen; das gleiche gilt für die Einstellung einen anderen seriellen Ports, der beispielsweise mittels ``ino upload -m mega2560 -p /dev/ttyACM1`` festgelegt werden kann. Wie im `Quickstart-Tutorial `__ beschrieben, kann hierfür auch eine Konfigurations-Datei im Projektordner angelegt werden. Weitere Hilfe zu Ino erhält man, indem man ``ino --help`` oder beispielsweise ``ino build --help`` für eine Beschreibung des Build-Subprogramms eingibt. .. _Hallo Welt mit Arduino: .. _Arduino-Programmbeispiel: .. _Ein erstes Arduino-Programmbeispiel: Erste Arduino-Programmbeispiele ------------------------------- Das erste Beispiel in jeder Programmiersprache ist es, einfach den Text "Hallo Welt" auf dem Bildschirm auszugeben. Arduinos kommunizieren allerdings weniger mit dem Computer-Bildschirm als vielmehr bevorzugt mit anderen elektronischen Komponenten. Ein einfaches Minimal-Beispiel ist also beispielsweise eine einzelne LED zum Blinken zu bringen. .. _Blinken einer LED: Blinken einer LED ^^^^^^^^^^^^^^^^^ In der Arduino-IDE kann man über das Menü ``Datei -> Beispiele`` einige Beispiel-Quellcode-Dateien laden. Unter der Rubrik ``01.Basics`` findet sich beispielsweise der Eintrag "Blink" mit folgendem Inhalt: .. code-block:: c :linenos: // Pin 13 has an LED connected on most Arduino boards. // give it a name: int led = 13; // the setup routine runs once when you press reset: void setup() { // initialize the digital pin as an output. pinMode(led, OUTPUT); } // the loop routine runs over and over again forever: void loop() { digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalWrite(led, LOW); // turn the LED off by making the voltage LOW delay(1000); // wait for a second } Jeder Text, der hinter einem doppelten Schrägstrich-Zeichen ``//`` erscheint, wird vom Compiler ignoriert und dient somit lediglich als Kommentar für sich selbst und/oder andere Programmierer. Allgemein werden die Arduino-Programme mit einer Syntax geschrieben, die auf der Programmiersprache :ref:`C ` aufbaut; beispielsweise muss daher jede einzelne Anweisung mit einem Strichpunkt-Zeichen beendet werden. Eine Besonderheit ist, dass *jedes* Arduino-Programm eine Funktion ``setup()`` und eine Funktion ``loop()`` beinhalten muss: * Die Funktion ``setup()`` wird einmalig nach dem Aufspielen eines neuen Programms sowie bei jedem Neustart des Arduinos ausgeführt. * Die Funktion ``loop()`` beinhaltet Code, der anschließend in einer Endlos-Schleife ausgeführt wird: Ist die letzte Zeile der ``loop()``-Funktion erreicht, so wird anschließend wieder die erste Zeile dieser Funktion ausgeführt. Die Funktionsblöcke der ``setup()``- beziehungsweise ``loop()``-Funktion müssen nicht zwingend Code beinhalten; lässt man beide Blöcke leer und überträgt dieses Programm auf den Arduino, so wird jedes vorherige Programm gelöscht, und der Arduino ist "wie neu". [#]_ Im obigen Beispiel wird innerhalb der ``setup()``-Funktion mittels der vordefinierten ``pinMode()``-Funktion der Digital-Pin ``13`` als Ausgabe-Pin festgelegt (``OUTPUT``). Innerhalb der ``loop()``-Funktion wird an diesem dann mittels der ebenfalls vordefinierten ``digitalwrite()``-Funktion die Ausgangs-Spannung abwechselnd an- und ausgeschaltet. Damit dies für das menschliche Auge wahrnehmbar wird -- ein Arduino kann rund :math:`20\,000` Zeilen Code je Sekunde ausführen -- wird mittels der ``delay()``-Funktion das Programm immer wieder um die angegebene Anzahl an Milli-Sekunden unterbrochen. .. _Einfache Sensor-Schaltungen: Einfache Sensor-Schaltungen ^^^^^^^^^^^^^^^^^^^^^^^^^^^ In diesem Abschnitt soll zunächst die Verwendung eines Tasters als digitalem Sensor, später dann die Verwendung eines Potentiometers als analogem Sensor kurz vorgestellt werden. .. _Taster als Digital-Sensor: .. rubric:: Taster als Digital-Sensor In der Arduino-IDE kann man über das Menü ``Datei -> Beispiele`` ein Beispielprogramm für die Verwendung eines Eingabe-Tasters laden Unter der Rubrik ``01.Basics`` findet sich ein Eintrag "DigitalReadSerial" mit folgendem Inhalt: [#]_ .. code-block:: c :linenos: /* DigitalReadSerial Reads a digital input on pin 2, prints the result to the serial monitor This example code is in the public domain. */ // digital pin 2 has a pushbutton attached to it. Give it a name: int pushButton = 2; // the setup routine runs once when you press reset: void setup() { // initialize serial communication at 9600 bits per second: Serial.begin(9600); // make the pushbutton's pin an input: pinMode(pushButton, INPUT); } // the loop routine runs over and over again forever: void loop() { // read the input pin: int buttonState = digitalRead(pushButton); // print out the state of the button: Serial.println(buttonState); delay(1); // delay in between reads for stability } Die zugehörige Schaltung sieht etwa folgendermaßen aus: .. image:: pics/arduino/digitalsensor-taster.png :align: center :width: 90% Der digitale ``Pin 2``, der in diesem Beispiel als Sensor-Eingang verwendet werden soll, ist einerseits über einen :math:`\unit[10]{k \Omega}`-Widerstand mit ``GND``, andererseits über den Eingabetaster mit der Spannung ``VCC`` (:math:`\unit[5]{V}`) verbunden. Diese Schaltung stellt letztlich einen :ref:`Spannungsteiler ` dar, wobei der Taster die Rolle des ersten Widerstands :math:`R_1` übernimmt: * Ist der Taster gedrückt, so beträgt sein Widerstandswert nahezu :math:`R_1 = \unit[0]{\Omega}`; fast die gesamte die gesamte anliegende Spannung fällt somit über dem Widerstand :math:`R_2 = \unit[10]{k \Omega}`, also zwischen dem mit ``Pin 2`` verbundenen Punkt und ``GND`` ab. Am ``Pin 2`` wird somit eine Spannung von :math:`\unit[>2,5]{V}` gemessen, was beim Einlesen mittels der ``digitalRead()``-Funktion den Wert ``HIGH`` beziehungsweise ``1`` liefert. * Ist der Taster nicht gedrückt, so beträgt sein Widerstandswert nahezu :math:`R_1 = \infty`. Würde man den ``Pin 2`` nicht über einen Widerstand mittels ``GND`` verbinden, so hinge der Anschluss gewissermaßen "in der Luft" -- die ``digitalRead()``-Funktion würde dann zufällig entweder den Wert ``HIGH`` (``1``) oder ``LOW`` (``0``) ausgeben. Durch den Widerstand und den so geschlossenen Stromkreis ist ``Pin 2`` hingegen mit ``GND`` verbunden, und die ``digitalRead()``-Funktion gibt verlässlich den Wert ``LOW`` beziehungsweise ``0`` aus. .. _Potentiometer als Analog-Sensor: .. rubric:: Potentiometer als Analog-Sensor Über das Menü ``Datei -> Beispiele`` kann man unter der Rubrik ``01.Basics`` ebenfalls ein Beispielprogramm für die Verwendung eines Potentiometers als Analog-Sensors abrufen. Das Beispiel "AnalogReadSerial" hat folgenden Inhalt: .. code-block:: c /* AnalogReadSerial Reads an analog input on pin 0, prints the result to the serial monitor. Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground. This example code is in the public domain. */ // the setup routine runs once when you press reset: void setup() { // initialize serial communication at 9600 bits per second: Serial.begin(9600); } // the loop routine runs over and over again forever: void loop() { // read the input on analog pin 0: int sensorValue = analogRead(A0); // print out the value you read: Serial.println(sensorValue); delay(1); // delay in between reads for stability } Die zugehörige Schaltung sieht etwa folgendermaßen aus: .. image:: pics/arduino/analogsensor-potentiometer.png :align: center :width: 90% .. rubric:: INO: Ausgabe des seriellen Monitors in einer Shell (optional) Auch der so genannte "Serielle Monitor" ist über die Shell erreichbar. Um dies zu testen, kann man hierfür das Beispiel-Programm in der Datei ``src/sketch.ino`` durch folgenden Code ersetzen: .. code-block:: c void setup() { Serial.begin(9600); } void loop() { Serial.println(millis()); delay(1000); } Ruft man wiederum ``ino build`` und ``ino upload`` auf, so kann man sich anschließend über folgenden Aufruf die Ausgabe des seriellen Monitors anzeigen lassen: .. code-block:: sh # Programm kompillieren und hochladen: ino build && ino init # Seriellen Monitor starten ino serial Man bekommt mit dem obigen Beispielcode damit angezeigt, wie viele Millisekunden seit dem letzten Aufruf des seriellen Monitors vergangen sind. Der serielle Monitor kann durch die Tastenkombination ``Ctrl a Ctrl x`` wieder beendet werden. Arduino-Programmierung ---------------------- Im folgenden Abschnitt wird die für das Programmieren eines Arduinos notwendige Syntax schrittweise, aber möglichst knapp vorgestellt. .. _Definition von Variablen: .. rubric:: Definition von Variablen Variablen sind dafür da, um bestimmte Werte (Zahlen oder Zeichenketten) zu speichern und an einer oder mehreren anderen Stellen im Programm wieder abrufen zu können. Bei der Definition einer Variablen wie in Zeile ``3`` des obigen Programmbeispiels muss angegeben werden, welchen Datentyp die Variable speichern soll. +------------------+------------+-------------------------------------------+------------------------------------------+ | Typ | Bits/Bytes | Umfang | Beschreibung | +------------------+------------+-------------------------------------------+------------------------------------------+ | ``boolean`` | 1 Bit | ``0`` bis ``1`` | Falsch oder Wahr | +------------------+------------+-------------------------------------------+------------------------------------------+ | ``byte`` | 1 Byte | ``0`` bis ``255`` | Natürliche Zahl | +------------------+------------+--------------------+----------------------+------------------------------------------+ | ``int`` | 2 Bytes | ``-32\,768`` bis ``+32\,767`` | Ganze Zahl mit Vorzeichen | +------------------+------------+-------------------------------------------+------------------------------------------+ | ``unsigned int`` | 2 Bytes | ``0`` bis ``65\,535`` | Ganze Zahl ohne Vorzeichen | +------------------+------------+--------------+-----------+----------+-----+------------------------------------------+ | ``float`` | 4 Bytes | ``-3.4028235E+38`` bis ``+3.4028235E+38`` | Rationale Zahl | +------------------+------------+----------------------+--------------------+------------------------------------------+ | ``double`` | 8 Bytes | ``10E-308`` bis ``10E+308`` | Rationale Zahl mit doppelter Genauigkeit | +------------------+------------+-------------------------------------------+------------------------------------------+ | ``char`` | 1 Byte | ``-128`` bis ``127`` | Ein einzelnes Zeichen (ASCII) | +------------------+------------+-------------------------------------------+------------------------------------------+ Im Unterschied zur Programmiersprache :ref:`C ` können Variablen auch lokal, also innerhalb einer Funktion definiert werden; sie haben dann allerdings auch nur innerhalb dieser Funktion ihre Gültigkeit: Beispielsweise kann eine Variable, die innerhalb der ``setup()``-Funktion definiert wurde, nicht innerhalb der ``loop()``-Funktion verwendet werden. Erfolgt die Definition einer Variablen hingegen am Beginn der Datei (noch vor der ``setup()``-Funktion), so kann diese in allen Programm-Teilen genutzt werden. Ist der Datentyp einer Variablen (einmalig) festgelegt, so kann dieser mittels des Zuweisungs-Operators ``=`` ein neuer Wert zugewiesen werden. Zeichenketten ("Strings") lassen sich als Listen ("Arrays") von ``char``-Variablen abspeichern; die Syntax dafür lautet beispielsweise: .. code-block:: c char string1[] = "Arduino"; // Definition einer konkreten Zeichenkette char string2[50] ; // Deklaration einer Zeichenkette // (mit maximal 49 Zeichen) Wird bei der Deklaration einer Zeichenkette die Länge mittels eines Zahlenwerts explizit angegeben, so muss beachtet werden, dass stets ein Zeichen weniger als angegeben genutzt werden kann, da jede Zeichenkette automatisch mit dem "String-Ende"-Zeichen ``\0`` beendet wird. Mehrere Zahlen lassen sich ebenfalls in Form einer Liste speichern; die Syntax hierfür lautet beispielsweise: .. code-block:: c int numbers[5] = {0, 5, 10, 15}; // Definition eines Zahlen-Arrays In einem Zahlen-Array können maximal genauso viele Werte gespeichert werden, wie bei der Deklaration beziehungsweise Definition angegeben wurden. .. byte (:math:`0` bis :math:`2^{8}-1`) .. float (:math:`-2^{15}` bis :math:`+2^{15}-1`) .. long, unsigned long .. _Standard-Funktionen: .. rubric:: Standard-Funktionen Zum Programmieren eines Arduinos können standardmäßig, also auch ohne ein Einbinden von zusätzlichem Quellcode, folgende Funktionen genutzt werden: * ``pinMode(pinnumber, wert)`` legt .. rubric:: Operatoren .. rubric:: Kontrollstrukturen ... to be continued soon ... .. _Arduino-Links: Links ----- * `Arduino-Arbeitsheft für Schüler `__ * `Arduino-Projekte (Kreative Kiste) `__ .. http://daeges-ulm.de/schule-und-co/nwt/nwt-10/ .. raw:: html
.. only:: html .. rubric:: Anmerkungen: .. [#] Hat man ein Arduino-Board angeschlossen, kann man in einer Shell folgende Zeile eingeben: ``ls -l /dev/ttyACM*`` Der serielle USB-Port wird vom Linux-System automatisch als "Device" erkannt; die Kommunikation findet über eine sich im ``/dev/``-Verzeichnis befindende Datei dort befindende Datei namens ``ttyACM0``, ``ttyACM1`` o.ä. statt (`tty `__ bezeichnet dabei die serielle Schnittstelle und `acm `__ das Datenübertragungs-Verfahren). Man erhält dabei also folgende Ausgabe: ``crw-rw---- 1 root dialout 188, 0 5 apr 23.01 ttyACM0`` Man kann daran erkennen, dass sowohl der Eigentümer als auch die Gruppe Lese- und Schreibrechte haben ``rw-``, alle anderen Benutzer hingegen keine Rechte haben (``---``). Der Eigentümer ist ``root``, die Gruppe ist ``dialout``. Ein Benutzer kann also nur auf die serielle Schnittstelle zugreifen, wenn er die Arduino-Software mit SuperUser-Rechten startet oder (besser) wenn er Mitglied in der ``dialout``-Gruppe ist. .. [#] Beispielsweise kann man mittels PWM einen Motor oder eine Glühbirne bei einem Wert von ``128`` mit nur "halber Leistung" ansteuern, da er nur die Hälfte der Zeit mit Spannung versorgt wird und sich die andere Hälfte der Zeit im Leerlauf befindet. Eine LED lässt sich so ebenfalls "dimmen": Die LED ist zwar schnell genug, um in der gleichen Frequenz mitzublinken, unser Auge jedoch nicht. Da wir nur 25 Einzelbilder je Sekunde wahrnehmen können, erscheint uns eine LED, die nur die Hälfte der Zeit an ist, gegenüber einer permanent hellen LED als dunkler. .. [#] Allgemein kann der Mikrocontroller Atmega328 eines Arduino-UNO-Boards gut :math:`10\,000` mal neu beschrieben werden; zudem kann auf dem Board jederzeit der Mikrocontroller durch einen neuen ersetzt werden. .. [#] Als Alternative zu diesem Programm kann auch unter der Rubrik ``02.Digital`` das Beispielprogramm ``Button`` gewählt werden. Dieses ist strukturell sehr ähnlich, bietet umfangreichere Erklärungen zum Aufbau der Schaltung, lässt andererseits jedoch den seriellen Monitor außen vor. .. https://processing.org/examples/