-C01- Zufallszahlen mit dem Arduino erzeugen

In diesem Post geht es darum, wie man mit dem Arduino Zufallszahlen erzeugt.

Zufallszahlen mit random()

Die einfachste Möglichkeit, Zufallszahlen zu erzeugen, ist die Funktion random(). Sie benötigt zwei Argumente: die kleinste Zahl, die vorkommen darf, und die erste Zahl, welche zu groß ist. Beispiel:

Wir benötigen eine Zufallszahl zwischen einschließlich 1 und einschließlich 10. Das geht, mit der Funktion random, über den Befehl random(1, 11);.

Das "Problem" von random ist, dass es keine wirklichen Zufallszahlen erzeugt, sondern eine Art Zahlenkette hat. Das bedeutet, dass man beim Neustart des Programms exakt die selben Zufallszahlen erhält. Hier ein kleines Beispiel:

Dieses Programm erzeugt hintereinander fünf Zufallszahlen und schaltet dementsprechend die LEDs, und sendet die Zahlen an den PC. 

Wie man sieht, beginnt die "Zahlenfolge" nach jedem Start von vorne, was bedeutet, dass jedes mal exakt die selben LEDs hintereinander aufleuchten. Um dieses Problem zu beheben gibt es randomSeed().

randomSeed()

Die Funktion randomSeed() gibt dem Mikrocontroller die Anweisung, nicht am Anfang seiner Zahlenfolge zu starten, sondern an dem Punkt, der der Funktion randomSeed(), als Argument, mitgegeben wurde. Wenn man nun immer einen anderen Wert der Funktion randomSeed mitgibt, so erhält man immer andere Zufallszahlen. 

Es gibt verschiedene Möglichkeiten, welche Werte man randomSeed() mitgibt. Eine wäre es den aktuellen Wert eines nicht benutzten analog Pins auszulesen. Eine Andere die aktuellen Millisekunden seit Programmstart, über die Funktion millis(), abzurufen. Hierbei muss man aber darauf achten es nicht im setup Teil zu tun, da sich dort die millis Werte, bei jedem Programmstart, sehr ähnlich sind.

randomSeed(analogRead(1));

randomSeed(millis());

Wenn man nun die Funktion random() aufruft startet sie an dem angegeben Punkt ihrer Zahlenfolge. Beim nächsten Programmstart, startet sie jedoch woanders, wodurch die Zahlen wirklich zufällig sind.

In diesem Artikel geht es um Optokoppler und deren Verwendung mit dem Arduino. Ein Optokoppler ist ein Bauteil, über welches man ein Signal zwischen zwei getrennten Stromkreisen übertragen kann.

(Optokoppler 4N35)

Die Funktionsweise eines Optokopplers 

Es gibt verschiedene Arten von Optokoppler, wobei sie immer auf demselben Prinzip beruhen. Ein Steuerungsstromkreislauf wird an- beziehungsweise ausgeschaltet. Dieser Stromkreis steuert eine LED(oft Infrarot) im Optokoppler. Zusätzlich befindet sich im IC ein "Sensor", welcher das Licht misst. Da das Gehäuse des Optokopplers lichtundurchlässig ist, registriert der Sensor nur etwas, wenn die LED angeschaltet wurde. Sollte der Sensor etwas registrieren, wird der zweite Stromkreis geschaltet. Es gibt Optokoppler, die analog Signale unterstützen, wobei Optokoppler, die nur digitale Signale unterstützen billiger sind. 

Optokoppler mit dem Arduino

Ich besitze den Optokoppler 4N35. Das ist ein häufiger Optokoppler, der einfach mit dem Arduino zu verwenden ist. Er ist in einem DIL 6 Gehäuse, was bedeutet, dass er 6 Pins/Beinchen hat.

Für eine einfach Steuerung sind jedoch nur 4 Beinchen relevant. Den Pluspol der Infrarot LED bildet der mit Anode markierte Pin(1). Pin 2(Kathode) ist der Minuspol der LED. Pin 4 ist der Minuspol und Pin 5 der Pluspol des Lichtsensors. Um das Signal zu erhalten schließt man an Pin 5 zusätzlich eine Datenleitung an. Zu beachten ist außerdem, dass man zwei Widerstände benötigt. Eine relativ Kleinen (100 bis 200 Ohm) und einen Großen(10kOhm). Ein 100Ohm Widerstand hat die Farben Braun-Schwarz-Braun-Gold, und ein 10kOhm Widerstand die Farben Braun-Schwarz-Orange-Gold. Der 100 Ohm Widerstand muss zwischen Pin 1 und der Spannung geschaltet werden, der 10kOhm Widerstand zwischen Pin 5 und der positiven Spannung. Um das ganze leichter verstehen zu können, habe ich eine Schaltung gebaut, über die ein 5V Netzteil eine LED am Arduino steuert.

Wenn jetzt die LED im Optokoppler leuchtet, also Strom im ersten Stromkreis fließt, ist die Datenleitung auf LOW. Wenn im ersten Stromkreis kein Strom fließt, ist die Datenleitung auf HIGH. Mit diesem Wissen kann man jetzt eine LED schalten:

}

view rawoptokoppler hosted with ❤ by GitHub

Jetzt weist du, wie man Signale zwischen zwei, voneinander getrennten, Stromkreisen überträgt. Eine coole Anwendung von diesem Wissen, ist den Vibrationsmotor eines Handys auszubauen und, über einen Optokoppler, das Handy mit dem Arduino zu verbinden. Dadurch kann man dann sein Projekt anrufen. 

In diesem Tutorial geht es darum, welche Arten von Schleifen es in der Programmiersprache C++(Arduino IDE/Atmel Studio) gibt. Eine Schleife enthält einen Code, der solange ausgeführt wird, bis eine bestimmte Bedingung nicht mehr wahr ist.

Die while() Schleife

Die while Schleife ist die bekannteste Schleifenform. Dabei besteht die while() Schleife aus einer Bedingung, die am Anfang steht. Sollte diese Bedingung zutreffen wird der Code einmal ausgeführt. Danach wird wieder geprüft, ob die Bedingung zutrifft und der Code eventuell erneut ausgeführt. Das wiederholt sich solange, bis die Bedingung falsch ist. Im Sketch steht die Bedingung in den normalen Klammern und der auszuführende Code in den geschweiften Klammern.

Die do...while() Schleife

Die do...while() Schleife ist eine while Schleife, die mindestens einmal ausgeführt wird. Es wird also der Code einmal ausgeführt und dann geprüft, ob die Bedingung überhaupt zutrifft. Falls dem so ist wird der Code nochmal ausgeführt. Dann wird wieder überprüft und so weiter. Der Unterschied zwischen der while und der do...while Schleife ist, dass der Code in der do...while Schleife mindestens einmal ausgeführt wird, bei der while Schleife muss dazu die Bedingung zutreffen.

Wichtig ist noch, dass nach der Bedingungsklammer ein Semikolon(;) benötigt wird.

Die for() Schleife

Eine for Schleife ist eine abgewandelte while Schleife. Dabei wird auch ein gewisser Code öfter ausgeführt. Der Unterschied ist, dass die Zählervariable, die in der Bedingung vorkommt, direkt in der for Schleife definiert wird, und der Hochzählrhythmus auch direkt in der Schleife definiert wird. Das klingt jetzt seltsam, wird aber mit einem Beispiel klar:

In den normalen Klammern wird erste eine Variable mit einem Startwert definiert, nach einem Semikolon kommt dann die Bedingung. Nach einem weiteren Semikolon steht dann, was mit der Variable, nach jedem Durchgang, getan werden soll. In diesem Fall die Variable um 1 vergrößern, dafür das ++. Lustigerweise kommt daher auch der Name von C++.  In den geschweiften Klammern steht dann wieder der auszuführende Code. Nach einem Durchgang wird dann der dritte Abschnitt der normalen Klammern ausgeführt(das Vergrößern um 1), und dann geprüft, ob die Bedingung wahr ist. 

Die verschiedenen Operatoren 

Ein Operator ist ein "Ding", das entweder wahr oder falsch, also einen Wahrheitswert, zurückgibt. Ein Beispiel ist das ">" Zeichen. Operatoren verwendet man, um eine Bedingung für eine Schleife oder eine Abfrage(if) zu erzeugen. Es gibt verschiedene Operatoren. Hier die wichtigsten:

Es ist wichtig, dass du, falls zwei Dinge gleich sein sollen ein doppeltes = machst, also ==, denn ein einfaches = ordnet den Wert der ersten Variable einfach der zweiten Variable zu. Dadurch wird dann die Schleife unendlich oft ausgeführt.

Bedingungen verknüpfen

Natürlich ist es auch möglich, dass eine Schleife oder eine Abfrage mehrere Bedingungen hat. Dazu gibt es in der Arduino IDE zwei Möglichkeiten:

Das doppelte Und-Zeichen verknüpft einfach die beiden Bedingungen. Wenn also beide Bedingungen zutreffen wird der Code ausgeführt. Im Programm muss man dann die beiden Bedingungen in die normalen Klammern schreiben: while((Bedingung1) && (Bedingung2)) { Code }.  Nach dem selben Prinzip funktioniert ||. Das steht für oder.

Erwähnenswert ist noch, dass man eine Bedingung über ! "umdrehen" kann. Falsch ergibt demnach wahr und wahr falsch. Beispiel: while(!(Bedingung)) { Code }.

Der ADC(Analog digital Wandler) des Arduino kann jeweils zwischen 1024 Spannungen unterschieden. Dazu "zerlegt" er die jeweilige Referenzspannung in die 1024 Bereiche und überprüft dann, in welchem Bereich die aktuelle Spannung liegt. Diesen Wert kann man dann im Sketch verarbeiten. Durch den AREF Pin kann man die Referenzspannung der analog Inputs/ des Analog digital Wandlers verändern. Wenn man also an den AREF Pin 2.5V anschließt, werden diese in 1024 Bereiche aufgeteilt. Dadurch kann man zwischen 0V und 2.5V viel genauer messen. Man darf jedoch keine Spannungen größer als 5V(3.3V) anschließen, da das den Arduino beschädigen könnte.

Wenn man eine Spannung an den AREF Pin anlegt, um sie als neue Referenzspannung festzulegen, muss man das dem Arduino auch mitteilen. Das funktioniert über den Befehl analogReference() am Anfang des Sketches. Dieser benötigt als Argument den Referenzwert. Wenn man die Spannung des Arduino haben will (3.3V /5V), ist das richtige Argument DEFAULT. Falls man den AREF Pin benutzen möchte, muss man als Argument EXTERNAL wählen. Zusätzlich kann man noch INTERNAL wählen. Das gibt einen Anteil der internen Spannung als Referenzwert. Da der Arduino einen ATmega328 enthält,  wären 1.1V dieser Wert. Insgesamt ist bei Spannungen, die vom Arduino geliefert werden, jedoch zu beachten, dass die Spannungen variieren können. So sinkt beispielsweise die Spannung, sobald viele zusätzliche Geräte(Sensoren, Motoren, ...) angeschlossen sind. Deshalb ist es, falls eine genaue absolute Messung erforderlich ist, sinnvoll immer über den AREF Pin den Referenzwert festzulegen.

In diesem Post geht es darum, wie man das Atmel Studio installiert und welche Einstellungen man vornehmen muss, damit man den Arduino mit dem Atmel Studio programmieren kann. Dadurch hat man dann eine, für manche Leute, angenehmere IDE, mit mehr Wahlmöglichkeiten, und zusätzlich kann man dann den Arduino in echtem C / C++ programmieren.

Installation des Atmel Studio

Das Atmel Studio (vor Version 6 AVR Studio) ist eine IDE von Atmel, dem Hersteller der Mikrocontroller, die sich auf dem Arduino (hier bei AZ-Delivery) befinden. Bei diesem muss man das Programm auch herunterladen. Nachdem ihr die Datei, mit einem Doppelklick, geöffnet habt, müsst ihr das Setup durcharbeiten. Dabei werden einige Zusatzmodule nachinstalliert. Im Wesentlichen könnt ihr jedoch alle Haken lassen, wie sie sind. Nachdem alles installiert ist, seht ihr diese Fenster:

Nun müssen wir noch einige Einstellungen vornehmen, um den Arduino zu verwenden. Wie euch vielleicht schon in der Arduino IDE aufgefallen ist, wird zum eigentlichen Upload des Programms avrdude verwendet. Dieses Uploadtool müssen wir jetzt auch, für das Atmel Studio, konfigurieren. Ihr müsst ihn jedoch nicht installieren, da ihr ihn bereits mit der Arduino IDE installiert habt. Dazu klickt ihr auf Tools > External Tools.

Nun erstellt ihr ein neues Tool. Dazu klick ihr auf den ADD Button. Bei Titel wählt ihr einen sinnvollen Namen, der gut umschreibt, dass wir Programme auf den Arduino Uno, oder einen anderern Arduino laden. Ich habe es einfach Arduino Uno genannt. Bei Command müsst ihr auf eure "avrdude.exe" verlinken. Diese befindet sich ihn eurem Arduino Ordner im Ordner Programme (x86) unter "hardware"  > "tools" > "avr" > "bin" >  "avrdude.exe". Bei Arguments müsst ihr dem avrdude mitteilen, was er tun soll. Dazu benötigt er den Link auf die ".hex" Datei, die er hochladen soll und muss wissen auf welchen Mikrocontroller er die Datei hochladen soll. Das ist eine Liste mit allen Argumente des avrdude. Ihr könnte jedoch auch einfach meine Argumente übernehmen wobei ihr jeweils euren Mikrocontroller eures Arduino eintragen müsst. Ich verwende einen Arduino Uno, der einen ATmega328P hat. Wenn du einen anderen Arduino verwendest hat der vielleicht einen anderen Mikrocontroller. Außerdem kann euer COM Port, und eure Datenrate, eine Andere sein. Bei mir ist das COM3 und 115200 als Datenrate. Glücklicherweise ist das leicht heraus zu finden. Dazu ladet ihr einfach einen Sketch in eurer Arduino IDE hoch. Nun seht ihr in dem unteren Bereich die benötigten Informationen:

Dort steht auch, wo die "avrdude.conf" auf eurem PC ist. Wenn ihr all diese Informationen gesammelt habt, ändert ihr meine Tool dementsprechend ab und speichert das Ganze.
Title: Arduino Uno
Command: C:\Program Files (x86)\Arduino\hardware\tools\avr\bin\avrdude.exe
Arguments: -u -v -patmega328p -carduino -PCOM3 -b115200  -Uflash:w:"$(ProjectDir)Debug\$(ItemFileName).hex":i -C"C:\Program Files (x86)\Arduino\hardware\tools\avr\etc\avrdude.conf"

Den Rest könnt ihr leer lassen und ein Haken ist auch nur bei "Use Output window" nötig. Nun ist euer eigenes Tool fertig. Wenn ihr jetzt auf Tools klick seht ihr, dass sich dort euer Tool befindet:

Erster Sketch

Nachdem die Installation und Konfiguration, des Atmel Studio, abgeschlossen ist, können wir einen ersten Sketch schreiben. Ich zeige hier, wie beispielsweise der blink Sketch in C++ gemacht wird. Dazu klickt  ihr zunächst einmal auf File > New > Project.

Im erscheinenden Fenster wählt ihr jetzt "C++ Executable Project".

Bei Prozessor wählt ihr nun euren jeweiligen Mikrocontroller. Nun habt ihr, in der Mitte des Atmel Studios, ein normales Textfeld.

Sicherlich fällt als Erstes auf, dass das Programm nicht in Setup und Loop aufgeteilt ist, sondern es nur main gibt. In main kann man jedoch einmalige Aktionen ausführen lassen und in der while(1) Schleife wird Alles wiederholt. Dadurch ergibt sich wieder die bekannte Aufteilung. Nun können wir einfach den blink Text eingeben.

In diesem Artikel geht es darum, wie man die Pins des Arduino schneller und effizienter verwenden kann. Dazu benutzt man Port Manipulation, was die langsamen Fuktionen digitalRead() und digitalWrite() ersetzt. Zusätzlich benötigt Port Manipulation weniger Speicherplatz, wodurch sich größere Sketche programmieren lassen, und  durch Port Manipulation kann man mehrere Pins gleichzeitig schalten.

Die Theorie

Ein Arduino enthält einen Mikrocontroller, der Uno beispielsweise den ATmega328P-PU. Diese Mikrocontroller besitzen die Pins, welche man über den Arduino, neu nummeriert, schalten kann. Dafür benutzt man dann die Funktionen digitalRead() und digitalWrite(). Die Pins des Mikrocontroller sind jedoch eigentlich anders, als beim Arduino, sortiert, nämlich in Ports. Ein Port ist nicht gleich mit einem Pin sondern ein Port ist eine "Pingruppe". Die Pins des Arduino Uno sind, am Mikrocontroller, eigentlich in 3 Ports gegliedert. Das sind Port B, C und D.

Über die Port Manipulation schaltet man also die Pins eines Ports beziehungsweise einen ganzen Port auf einmal. Dazu gibt es drei Register: DDRx, PORTx und PINx. Das klingt jetzt komplizierter als es ist. 

Die Umsetzung

Über DDRx legt man fest, ob die einzelnen Pins eines Port OUTPUTs oder INPUTs sein sollen. Beispielsweise würde die Zeile DDRC = B000111 die analog Eingänge A0 bis A2 als Input definieren und A3 bis A5 als Output definieren. 0 steht für Input und 1 für Output. Das "B" vor den Zahlen gibt nur das Format an. Die Definition beginnt immer mit dem Pin mit der kleinsten Nummer am Arduino, also von A0 bis A5, da  0 < 5. 

Über das PORTx Register legt man fest, ob die Pins auf LOW oder HIGH geschaltet werden sollen. Dabei steht das x wieder für den jeweiligen Port. Wenn wir also Pin 8, 10 und 12 auf HIGH und Pin 9, 11 und 13 auf LOW setzen wollen, schreiben wir PORTB = B101010.

Das PINx Register ist dazu da, um den aktuellen Status der Input Pins, also LOW oder HIGH, festzustellen. Dazu wählt man für x wieder den aktuellen Port und vergleicht dann das Register mit einer Abfolge. Beispielsweise überprüft if(PINB == 0b000000), ob alle Pins, des Ports B, auf LOW geschaltet sind. 

Nun weißt du also, wie du schnell und effizient einen ganzen Port schalten kannst. Doch was ist, wenn du nur mal schnell den Status eines Pins ändern willst?

Um nur einen einzelnen Pin zu definieren, beziehungsweise zu schalten oder auszulesen gibt es verschiedene Schreibweisen, die jedoch immer das selbe bewirken.

Wenn ich beispielsweise Pin 10 als OUTPUT festlegen möchte, so brauche ich das DDR Register vom Port B. Dort ist der Pin 10 der Pin 2 und OUTPUT ist als 1 definiert. Deshalb schreibt man die Zeile DDRB = (1<<PB2). Dadurch wird eine 1, also Output, zu Pin 2 des Ports B geschrieben. Wenn wir diesen Pins nun auf HIGH schalten wollen, so schreibt man PORTB = (1<<PB2). Um einen Eingang auszulesen schreibt man PINB & (1<<PB2). (Das & ist kein Tippfehler!) Das gibt den aktuellen Status des Eingangs zurück. Nicht wundern: Falls der Pin auf HIGH ist, gibt die "Abfrage" den Wert 4 zurück.

Dank der Port Manipulation könnt ihr jetzt Pins gleichzeitig schalten, beziehungsweise auslesen. Außerdem sind eure Sketche kleiner, wie ihr hier sehen könnt:

In diesem Tutorial geht es darum, wie verschiedene Arduinos, Mikrocontroller oder sonstige Geräte, wie beispielsweise Shields, oder externer Speicher,  mit einem Arduino, über das SPI Protokoll kommunizieren können. Das ist, ähnlich wie I2C, ein Protokoll, mit dem Daten seriell übertragen werden.

Der Aufbau

Eine SPI Verbindung besteht aus 4 Pins. Das sind der MISO, der MOSI, der SCK und der SS Pin. Auf dem MISO Pin werden Daten vom Slave zum Master gesendet, auf dem MOSI Pin Daten vom Master zum Slave, und der SCK Pin gibt den Takt an. Der SS Pin ist dazu da, um eine speziellen Slave anzusprechen. Da SPI mehrere Slaves unterstützt, werden einach alle Geräte mit den selben MISO, MOSI und SCK Pins verbunden. Damit man nun einen speziellen Slave auswählen kann und nur dieser auf die aktuell gesendeten Informationen achtet, hat der Master zu jedem Slave eine eigene SS Leitung. Sobald er diese Verbindung zu einem Slave auf LOW setzt, empfängt dieser die gesendeten Daten und reagiert dementsprechend. Dadurch braucht man am Master für jeden zusätzlichen Slave nur einen weiteren Pin.

Der ICSP Header sind die 6 freistehenden Pins neben dem ATmega328 auf dem Arduino Uno Board. Da diese mit ihren jeweiligen Pendants, der digital Pins, mit dem jeweils gleichen Pin am Mikrocontroller verschaltet sind, kann man Pin 11, 12, 13 trotzdem nicht frei verwenden, obwohl an sie kein Kabel angeschlossen ist. Hier findet ihr die ICSP Header Zählweise:

Diese Pins verbindet man nun mit dem jeweils gleichen Pins des anderen Geräts. Das bedeutet MISO zu MISO, MOSI zu MOSI, SCK zu SCK und SS zu SS. Der SS Pin ist standardmäßig Pin 10 des Arduino. Ihn findet man nicht am ICSP Header. Ich habe einen Arduino mit einem ATmega328 verbunden, also einen Arduino mit einem Mikrocontroller. Dabei muss man am Mikrocontroller die Arduino Mikrocontroller Umrechnung beachten und den Mikrocontroller mit Strom versorgen. 

Das Programm

Das Programm zum übertragen von Daten besteht logischerweise aus zwei Teilen. Einem Sketch zum Senden der Daten, für den Master, und ein Sketch zum Empfangen der Daten, für den Slave. Meine beiden Sketch senden den Text "Hello, World!" vom Mikrocontroller an den Arduino, der das dann, über die serielle Konsole, am PC ausgibt. Man verwendet dazu die SPI Bibliothek, für den Arduino, die bereits mit der Arduino IDE vorinstalliert ist.

Der Master

Der Master beginnt, über SPI.begin(), die SPI Kommunikation. Dann schaltet er den SS Pin (10) auf LOW und sendet über SPI.transfer() die einzelnen Buchstaben des eingegebenen Textes. Am Ende schaltet er wieder den SS Pin auf HIGH, und beendet dadurch die Kommunikation.

}

view rawSPI_Arduino_Slave hosted with ❤ by GitHub

Wenn man nun in der Arduino IDE die serielle Konsole öffnet, sieht man, was der Arduino, vom Mikrocontroller, empfängt:

In diesem Post geht es darum, auf welche Arten man den Arduino mit Strom versorgen kann, und welche Spannung dafür jeweils benötigt wird/maximal zulässig ist.

USB Port

Der einfachste Weg den Arduino mit Strom zu versorgen, ist ihn mit dem PC zu verbinden. Dazu muss man das Kabel an den USB Port am Arduino und an einen USB Port am PC anschließen.

Dabei kann man dann den Arduino auch mit dem PC programmieren.

DC Stromanschluss

Eine weitere Möglichkeit ist, den Arduino über ein DC Netzteil zu versorgen. Dort können Spannungen von 6V bis 20V verarbeitet werden wobei 9V bis 12V optimal sind, und der Rest nur als Hitze abgeführt wird. Die jeweilige Spannung findet ihr auf eurem Netzteil.

3.3V/5V Stromanschluss

Wenn man stabile 3.3V oder 5V von einem Netzteil oder einer Batterie bekommt, kann man diese an den jeweiligen Pin des Arduino anschließen, und den Ground an einen Groundpin des Arduino. Mit meinem 5V Netzteil sähe das so aus:

Dabei verträgt der Arduino am 5V Pin bis zu 1A. Bei den 3.3V muss man achten ob der Arduino mit 3.3V arbeitet oder 5V benötigt. Der Arduino Uno beispielsweise, benötigt 5V, wobei er in einem Test von mir auch mit 3.3V lief, wobei das nicht zu empfehlen ist. Weiterhin ist zu erwähnen, dass falls man den Arduino über den 3.3V oder den 5V Pin versorgt, der Strom einfach ohne "Kontrolle" durch fließt, wodurch bei falscher Spannung der Arduino leicht kaputt geht.

Vin Pin

Auch über den VIN Pin, kann man den Arduino mit Strom versorgen. Dieser befindet sich neben den beiden Grounds.

Über diesen Pin kann man, wie beim USB Port oder DC Anschluss, Spannungen, auch größer als 5V anlegen, da der VIN Pin an den Spannungsregler angeschlossen ist. Es bietet sich beispielsweise an 4 x 1.5V Batterien an den VIN Pin anzuschließen. Dabei wird wieder der Ground mit einem Groundpin des Arduino verbunden. 

Hier alles noch einmal in einer Tabelle zusammengefasst:

In diesem Tutorial geht es darum, wie man ein 7 Segment LED Display mit dem Arduino steuern kann. Das sind Displays, die 7 LED Striche so angeordnet haben, das sie alle Ziffern darstellen können. Dadurch kann man dann viele Zahlen, mit einem LCD Display verglichen, billig anzeigen lassen.

Der Aufbau

Das oben dargestellte 7 Segment Display (eigentlich 8, da es noch den Punkt hat), hat einen gemeinsamen Ground(Common Anode). Das bedeutet, dass der mittlere Pin, jeweils in der oberen und der unteren Pinreihe, mit dem Ground verbunden werden muss. Jeder, der verbleibenden 8 Pins, steuert eine LED. Diese wird angeschaltet, sobald der Pin am Arduino auf HIGH gestellt wird. So sieht dann die korrekte Verkabelung mit dem Arduino in Echt aus:

Nun muss man noch herausfinden, welcher Pin des Arduino, welchen LED-Strich steuert. Dazu kann man den folgenden Sketch verwenden. Dabei schaltet er Pin 2 bis Pin 9 als OUTPUT und macht die zugehörige LED für 5 Sekunden an. In der seriellen Konsole wird jeweils der aktuelle Pin angezeigt. Wenn man das auf einem Papier mitschreibt, weiß man welcher Pin was steuert. Alternativ kannst du dir auch im Internet das jeweilige Datenblatt deines 7 Segment Displays herunterladen und dort nachsehen. Das dauert jedoch meist länger.

}

view raw7SegmentDisplay_Zahl_schreiben hosted with ❤ by GitHub

Nun erscheint eine 7 auf dem 7 Segment LED Display :

Das kann man jetzt mit allen Zahlen machen und bei Bedarf sich dafür eine eigene Bibliothek erstellen.

Natürlich kann man einen analog Input auch als digital Input verwenden:

In diesem Post geht es um die Arduino Bibliothek SoftwareSerial. Mit ihr kann man zusätzliche serielle Verbindungen zu anderen Geräten, mit jeweils zwei beliebigen digital Pin des Arduino, herstellen. Dadurch kann dann ein Masterarduino eine Anwendung steuern und die Aufgaben dann, über die seriellen Verbindungen, an die anderen Arduinos verteilen.

Die Bibliothek SoftwareSerial ist bereits mit der Arduino IDE vorinstalliert, weshalb man nur auf Sketch > Include Library > SoftwareSerial klicken muss.

Um eine weitere serielle Verbindung zu starten muss man zunächst den Namen der neuen Verbindung und ihre Pins angeben. Jede serielle Verbindung besteht aus zwei Pins: dem TX und dem RX Pin. Über den TX Pin sendet der Mikrocontroller/Arduino, über den RX Pin empfängt der Arduino/Mikrocontroller. Also ist der TX Pin von A mit dem RX Pin von B, und umgekehrt, verbunden. In meinem Fall sind das Pin 10 und 11. Bei der Benennung kommt erst der RX und dann der TX Pin. Nun kann man, wie von der "normalen" seriellen Verbindung gewöhnt, über Name.begin(Datenrate) die Verbindung starten. Auch das Empfangen (Name.read()) und das Senden(Name.write()) klappt genauso. Um das Ganze an einem Beispiel zu erläutern sendet ein Mikrocontroller laufend den Text "Hallo" an einen Arduino. Dieser wiederum empfängt den Text und sendet ihn weiter an den PC, jeweils über eine serielle Verbindung. 

Der Sketch des Mikrocontroller:

Der Sketch des Arduino:

Nun muss man den ersten Sketch auf einen Mikrocontroller laden, und den zweiten auf den Arduino. Außerdem wird Pin 2 des Mikrocontroller mit Pin 11 des Arduino und Pin 3 des Mikrocontrollers mit Pin 10 des Arduino verbunden. Nun sendet der Mikrocontroller "hallo" an den Arduino, der das über das USB Kabel an den PC weiterleitet. Wenn man jetzt die serielle Konsole öffnet, bekommt man den Text angezeigt:

Hallo

Hallo

Hallo

Hallo 

usw.

Wenn dir der Artikel gefallen hat, gib ihm einen Daumen nach oben, damit ihn auch andere Leute finden können.

Mittlerweile haben wir schon einiges darüber gelernt wie man einen Arduino programmiert. Doch für viele Projekte ist es notwendig mehrere Arduinos zu programmieren. Da man aber nicht immer zwei Arduinos zur Hand hat, kann man sich auch einfach den Kern des Arduino kaufen und programmieren, einen Mikrochip.

Die Modelle

Es gibt viele verschieden Firmen und Modelle von Mikrocontrollern. Eine weit verbreiteter Hersteller ist die Firma Atmel. Sie produziert auch die Mikrocontroller der verschiedenen Arduino Varianten. Sie hat insgesamt drei Reihen die ATtiny, die ATmega und die ATxmega Serien. Die ATtiny sind wie der Name schon sagt sehr klein und beginnen schon unter 2€, haben jedoch auch nur wenige Pins(~12). Die ATmega Serie beinhaltet die großen Mikrochips wie den ATmega328 des Arduino. Die ATxmega Serie sollte eine Verbesserung der ATmega Serie werden wobei sie sich immer mehr als Flopp erweist. Jeder Mikrochip hat einen gewissen Namen der die Baureihe und die Flashspeichergröße angibt. Für eine genaue Übersicht aller verfügbaren Modelle schau doch mal bei mikrocontroller.net / vorbei. Wichtige Größen die beim Kauf beachtet werden sollten sind die benötigten Pins(also Pinanzahl und Art) sowie die benötigte Spannung, der Prozessor Takt, die Flashspeicherkapazität und die Größe des Arbeitsspeichers(RAM).
Da ich einen Arduino Uno habe und mit seine Leistung und der Anzahl der Pins zufrieden war habe ich mir den Kern des Arduino Uno, den ATmega 328 gekauft. Noch ein Hinweis am Rande: Ich würde immer empfehlen nicht nur einen Mikrochip zu bestellen sondern zwei oder drei, da man dann immer die Gewissheit hat und überprüfen kann ob der Controller kaputt ist. Außerdem muss man dann nicht immer nachkaufen. :)

Die Verkabelung und das Hochladen

Das ist meiner Meinung nach der schwierigste Teil überhaupt und auch ich saß 4 Tagen lang und habe es ausprobiert bis ich es geschafft habe, also lass den Kopf nicht hängen:). Um eine Mikrocontroller zu programmieren gibt es verschiedene Möglichkeiten. Eine Gängige ist sich einen ISP(In System Programmer) zu kaufen. Eine Andere einen Bootloader aufzuspielen und per USB to Serial  Adapter zu programmieren. Da ich bereits einen Arduino besitze verwende ich meinen Arduino als ISP für meine Mikrocontroller. Das geht relativ gut, wenn man einige Dinge unbedingt beachtet. Die Pins eines Mikrochips werden genauso wie die eines anderen Teils gezählt. Wenn links der Halbkreis am Rand ist, ist Pin 1 links unten und Pin 28 links oben. Da ein Mikrocontroller Strom braucht wird er an Pin 7 und 20 mit den 5V Spannung versorgt. Pin 8 und 22 werden mit dem Ground verbunden. Zur Datenübertragung mit dem Arduino wird Pin eins des Mikrochips mit Pin 10 des Arduino verbunden sowie Pin 17 mit Pin 11, Pin 18 mit Pin 12 und Pin 19 mit Pin 13.Das sieht dann so aus:

Wenn man nun ein Programm hochladen will kann man nicht einfach auf hochladen klicken, da sonst der Sketch auf dem Arduino landet und wir den Arduino ja als ISP verwenden möchten. Dazu müssen wir erst einmal ein Programm auf den Arduino laden, das ihn in einen ISP für den Computer verwandelt. Diese findet ihr unter Datei > Beispiele > ArduinoISP. Wenn das hochgeladen ist, ist der Arduino fertig konfiguriert. Vielleicht erinnert ihr euch ja noch, dass ihr als ihr die Arduino Software installiert habt, ihr euren Arduino als Zielplattform unter Werkzeuge > Platine auswählen musstet. Nun wollen wir jedoch nicht einen Arduino programmieren sondern den ATmega328 alleine. Deshalb müssen wir erst ihn als Zielplattform auswählen. Da seine Daten jedoch nicht vorinstalliert sind müssen wir das nachholen. Dazu müsst ihr unter http://arduino.cc/en/uploads/Tutorial/Breadboard1-5-x.zip die Datei herunterladen und in eurem Arduino Ordner einen Unterordner namens "Hardware" erstellen und dorthin entpacken. Dann solltet ihr nach einem Neustart eurer Arduino IDE unter Werkzeuge > Platine das Folgende sehen:

Wählt nun ATmega328 on a breadbord(8 Mhz internal clock) aus und wählt unter Werkzeuge > Programmer den Punkt Arduino as ISP aus. Nun könnt ihr als Test einen Bootloader auf eueren Mikrocontroller spielen. Wählt dazu Werkzeuge > Bootloader brennen. Nun sollten die TX und RX LEDs des Arduino leuchten und nach einigen Minuten die Meldung "Bootloader erfolgreich gebrannt erscheinen". Wenn ihr auch ein Programm hochladen wollt, so öffnet ihr dieses ganz normal müsst dann jedoch für den Upload auf Datei > Hochladen mit Programmer drücken. Ganz wichtig ist, dass ihr immer, bevor ihr Sketche auf den externen Mikrocontroller ladet, den ISP Sketch auf den Arduino spielt sowie ATmega 328 on a breadbord und Arduino as ISP auswählt.

Ein Programm

Wenn wir einmal unser allererstes Programm (die leuchtende LED) auf den Mikrocontroller spielen merken wir dass Pin 13 des Mikrocontrollers ungleich Pin 13 des Arduino ist, da die LED an Pin 13 nicht leuchtet. Die "Übersetzung" sieht so aus:

Beim ATmega328, dem Kern des Arduino ist der SDA Pin der analog Eingang 4, und der SCL Pin der analog Eingang 5. Lustigerweise gibt es auch zwei extra SDA und SCL Steckplätze oberhalb von digital pin13 am ARDUINO UNO Board.

Beispielsweise wäre also Pin 13 des Arduino Pin 19 des Mikrocontrollers und Pin 13 des Mikrocontrollers Pin 7 des Arduino. In einem Sketch werden immer die Arduino Pins gewählt, wobei dann bei einem Mikrocontroller auf dem Breadbord "umrechnen" muss. Sobald ein Programm hochgeladen ist kann man die Datenleitungen zum Arduino unterbrechen, nur die Stromversorgung muss bleiben. Das Ergebnis ist dann eine, von einem eigenständigen Mikrocontroller gesteuerte, LED.

Ich hoffe ich habe alles verständlich erklären können. :) Schreibt doch mal in die Kommentare, ob es bei euch geklappt hat.

In diesem Artikel geht es darum, wie man eine Bibliothek für den Arduino erstellen kann. Eine Bibliothek ist eine Art Sammlung von Befehlsdefinitionen, die ausgelagert wurden. Ein Beispiel ist die LiquidCrystal Bibliothek, durch die man ohne große Fachkenntnisse ein LCD Display verwenden. Durch eine Bibliothek kann man dann viele Befehle mit nur einer Zeile Code im Sketch definieren.

Aufbau einer Bibliothek für die Arduino IDE

Eine Bibliothek besteht aus drei Teilen. Einerseits dem Ordner, und andererseits die im Ordner enthaltenen Dateien, die Header Datei, und die C++ Datei. In der Headerdatei, eine Textdatei mit der Endung ".h", werden die Funktionen einer Klasse benannt und die nötigen Variablen definiert. In der CPP Datei wird der Inhalt der Funktionen angegeben, also die, von der Arduino IDE bekannten, Befehle.
Um das Erstellen einer Bibliothek an einem Beispiel zu veranschaulichen, erstelle ich eine Bibliothek, über die man eine LED zum Blinken bringen kann. Der Pin kann vom User angegeben werden.

Die Headerdatei

Eine gute Headerdatei beginnt immer mit einer if Schleife. Diese fragt ab, ob der Programmierer versehentlich die Bibliothek zum zweiten Mal nachlädt. Wenn dem nicht so ist, wird eine Klasse mit dem Namen der Bibliothek erzeugt. Diese Klasse hat diverse Methoden, also Befehle. Diese werden in public angegeben. Wenn eine Funktion Werte benötigt gibt man diese, wie in der Arduino IDE, in den Klammern, samt Datentyp an. Wenn eine Funktion keine Argumente hat, schreibt man void vor den Funktionsnamen. Diese Funktionen kann dann der User, sobald er die Bibliotehk importiert hat, verwenden. Auf Alles, was im Bereich private steht, hat nur die Bibliothek/die Klasse selbst Zugriff. Dort würde beispielsweise Variablen, die später Zwischenergebnisse enthalten, definiert werden. Das #include "Arduino.h" am Anfang ist immer notwendig und gibt einige Standardeinstellungen und Definitionen vor. Unsere Klasse/Bibliothek soll eine Funktion Blinken haben, auf die wir zugreifen können, und bei der wir den Pin angeben können. Deshalb kommt die Funktion in den public Bereich. Die gesamte Headerdatei sieht dann so aus:

Um eine Headerdatei zu erstellen öffnet ihr euren ganz normalen Windows Editor und tippt dort den Text ein. Anschließend klickt ihr auch Datei > Speichern unter. Dort wählt ihr den Namen Blinken.h und als Dateityp "Alle Dateien". Wenn ihr das nicht tut, interpretiert euer PC das ganze als eine Textdatei mit dem Namen "Blinken.h.txt".

Die C++ Datei

In der C++ Datei werden die einzelnen Befehle, die ihr erstellt habt, mit Leben gefüllt. Das bedeutet, dass ihr, ähnlich wie bei der Funktionsdefinition in der IDE selbst, sagt welche Befehle eure neue Methode enthält. Dazu müsst ihr zunächst wieder die Arduino.h und eure Bibliotheksheaderdatei, die ihr gerade erstellt habt, nachladen. Danach könnt ihr schon mit der Definition der Methoden beginnen. Dort verwendet man die ganz normalen Befehle, die aus der Arduino IDE bekannt sind.

Auch diese Datei kann, wie die Headerdatei, mit einem normalen Texteditor erstellt werden.

Die Bibliothek im Arduino Sketch verwenden

Um nun den Befehl Blinken aus der Bibliothek zu verwenden, muss man diese Bibliothek ganz normal nachladen. Also entweder über das schreiben der Zeile #include <Blinken.h> oder über Sketch > IncludeLibrary > Blinken. Nun müssen wir nur noch die Methode Blinken(Pinnummer); im Loopteil angeben, und schon blinkt die gewählte LED.

Das ist ein einfaches Beispiel, wie man eine Bibliothek für die Arduino IDE erstellt und verwendet.
Wenn dir der Post gefallen, gib ihm doch bitte einen Daumen hoch. 

In diesem Artikel geht es darum, wie man eine eigene Funktion definiert und verwendet. Dadurch müsst ihr dann nicht immer den selben Code schreiben oder kopieren, was dass Programmieren schneller, und den Code übersichtlicher macht.

Beginnen wir mit einem einfachen Beispiel. Wir wollen das Blinken der Arduino LED an Pin 13 in eine Funktion packen. Dadurch müssen wir dann nur noch blinken() angeben.

Um eine Funktion im Setup oder Loop Teil zu verwenden muss man sie erst definieren. Das geschieht außerhalb dieser beiden Programmteile. Zunächst muss man festlegen, welchen Datentyp die Daten haben, die die Funktion zurück gibt. Da das Blinken keine Daten zurück gibt, muss man void angeben. Danach kommt der Name der Funktion. In den Klammern könnte man dann die Argumente angeben (dazu später mehr). Innerhalb der geschweiften Klammern wird dann der Code angegeben, der beim Aufruf der Funktion einmal ausgeführt werden soll. In meinem Fall die LED anmachen, kurz warten, wieder ausmachen und wieder kurz warten. Da diese Funktion dauernd im Loop Teil aufgerufen wird, blinkt die BoardLED konstant.

Nun wollen wir diese Funktion universell einsetzbar machen. Dazu wollen wir immer in den Klammern den Pin angeben, an dem die LED angeschlossen ist, die blinken soll. Das bedeutet die Funktion hat ein Argument. Argumente haben wie Variablen immer einen Datentyp. Der Pin wäre in unserem Fall eine Zahl, also int. Bei der Definition der Funktion wird nun in den normalen Klammern der Datentyp und der Name des Argument angegeben. Die Pinzahl, die dann beim Aufrufen der Funktion angegeben wird, ist dann in der Funktion in der Variable, mit dem Argumentnamen, gespeichert.

In meinem Fall heißt das Argument pin. Deshalb steht bei mir, bei digitalWrite(), an der Stelle wo der Pin angegeben werden sollte, pin. Wenn wir nun ein weiteres Argument wollen, beispielsweise die Geschwindigkeit des Blinkens, so werden die Argumente mit Kommas getrennt.

Nun müssen wir immer die Dauer des Blinkens angeben. Wäre es nicht praktisch, wenn man eine Standarddauer für das Blinken hat und deshalb die Dauer nur angeben muss, wenn man eine Andere haben will?
Das lässt sich auch ganz einfach lösen! Dazu definiert man einfach die gewünschte Funktion mehrmals. Einmal in der Kombination, wo man nur den Pin angibt, und einmal in der Kombination Pin und Dauer. Das sähe dann so aus:

Nun wollen wir noch, dass uns die Funktion einen Rückgabewert liefert. Beispielsweise die Geschwindigkeit des Blinken. Schnell, normal oder langsam. Dazu muss man das void vor dem Namen in den jeweiligen Datentyp umändern, in diesem Fall String, und in der Funktion, über return variable, eine Variable vom genannten Datentyp zurückgeben. Um die gefühlte Geschwindigkeit zurück zu geben, sähe der Sketch so aus:

In der seriellen Konsole wird dann laufend die "gefühlte Blinkgeschwindigkeit" ausgegeben.

schnell
schnell
schnell
schnell
schnell
schnell

schnell

Jetzt weißt du, wie man Funktionen definiert, Argumente verwendet, auch Optionale, und, wie eine Funktion etwas zurück geben kann.

michaelsarduino: Eigene Funktion für den Arduino definieren

In diesem Artikel geht um den Timerinterrupt und den Watchdogtimer. Durch den Timerinterrupt kann man festgelegt alle paar Sekunden eine Aufgabe ausführen und durch den Watchdogtimer kann man, falls eine gewisse Zeitspanne überschritten wird, den Arduino zurücksetzen.

Der Timerinterrupt

Durch den Timerinterrupt kann man unabhängig von der Hautpschleife(loop) alle paar Sekunden, den Wert kann man festlegen, eine gewisse Aktion ausführen. Das passiert auch, wenn man gerade in einer großen Schleife ist. Die Zeile wird dann abgebrochen, die Aktion ausgeführt, und dann die Schleife fortgesetzt. Ein Anwendungsbeispiel wäre eine Ampel. Eine Ampel hat, nehmen wir Mal an, verschiedene Aufgaben. Zum Beispiel schauen, ob eine Knopf gedrückt wurde, oder Informationen von anderen Ampeln/Fahrzeugen erhalten. Nichtsdestotrotz muss die Ampel jedoch alle fünf Sekunden von rot auf grün oder umgekehrt schalten. Für eine solche Aufgabe würde man dann einen Timerinterrupt verwenden. Dazu verwendet man die TimerOne Library, die ihr hier herunterladen könnt. Die .zip Datei müsst ihr dann in euren Libraries Ordner so entpacken, dass es dort einen TimerOne Ordner gibt, der den Inhalt der .zip Datei hat. Diese Bibliothek müsst ihr dann im Sketch nachladen. Um einen Timerinterrupt zu verwenden, muss man erst die Zeit festlegen, nach der die besondere Aktion ausgeführt werden soll. Das geschieht über Nametimer.initialize(Zeit in Sekunden * 1000000). Um den Timer jetzt noch zu "starten" muss man den Befehl Nametimer.attachInterrupt(Name der Funktion) eingeben. In den Klammern muss man den Namen der Funktion eingeben, die jedesmal ausgeführt werden soll. Diese müsst ihr auch definieren. Das habe ich bereits hier erklärt. Dann wird sie jedesmal, nach der festgelegten Zeit, ausgeführt. Mein Ampel Sketch sieht so aus:

Der Watchdogtimer

Den Watchdogtimer, muss man sich wie einen Wachhund vorstellen. Wenn man ihn nicht alle festgelegten Sekunden streichelt, beißt er dich/deinen Sketch und der Arduino wird neu gestartet. Das ist sinnvoll, wenn man sicherstellen muss, dass ein Programm läuft, und nicht in einer Schleife hängen bleibt. Beispielsweise wenn man die Funktion millis() verwendet. Diese speichert die Millisekunden seit Programmstart, und da das sehr viele werden können, und die Variable "überläuft" gibt es nach 46 Tagen einen Neustart bei Null. Wenn dann eine Schleife ungünstig gesetzt ist wartet der Arduino 46 Tage bevor er kurz weitermacht. Für einen solchen, oder andere Fälle ist ein Watchdogtimer sinnvoll. Für diesen muss man im Sketch wieder eine Bibliothek nachladen, die aber mit der IDE bereits mit installiert wurde. Im Setupteil muss der Watchdog über wdt_enable() gestartet werden. In den Klammern gibt man die Zeit an. Man kann sie jedoch nur in bestimmten "Portionen" angeben. Diese sind:

Nun beißt uns der Wachhund, und setzt den Arduino zurück, sobald wir ihn die angegebene Zeit nicht "streicheln". Das tuen wir über wdt_reset();.

Der Timerinterrupt und der Watchdogtimer sind zwei gute Möglichkeiten um, einerseits immer etwas in einem bestimmten Rhythmus zu erledigen, oder aber zu überprüfen, ob sich der Arduino "aufgehängt" hat.

Wenn dir der Artikel gefallen hat, gib ihm einen Daumen hoch, oder folge mir auf Google Plus um immer über neue Post informiert zu werden.



-C30- Interrupts mit dem Arduino

Manchmal ist es sinnvoll, dass eine laufende Aktion unterbrochen wird, damit kurz etwas Anderes ausgeführt wird. Beispielsweise wenn man in einer Schleife ist und dann ein User plötzlich einen Button drückt. Dann soll erst die, mit dem Button verknüpfte, Aktion ausgeführt werden, und dann die Schleife weiter ausgeführt werden. Genau dafür sind Interrupts.

Die Verwendung von Interrupts auf der Arduino Plattform

Auf dem Arduino Uno sind nicht alle Pins dazu geeignet als Interrupt Signal zu dienen. Das funktioniert nur mit Pin 2, Interrupt Pin 0, und Pin 3, Interrupt Pin 1. An anderen Arduinos sind es andere Pins, der Arduino Due kann mit Interrupts auf allen Pins umgehen. Die genaue Auflistung gibt es auf arduino.cc. Wenn man einen Interrupt verwenden will, muss man das bereits im Setup Teil festlegen. Dazu gibt es die Funktion attachInterrupt();. Diese braucht als erstes Argument(Werte in der Klammer, nach Name der Funktion) den Interrupt Pin, also 0 oder 1. Als Zweites muss die Funktion angegeben werden, die ausgeführt werden soll, wenn eine Bedingung zutrifft. Das dritte Argument ist die Bedingung, die entscheidet, ob die angegebene Funktion ausgeführt werden soll. Am Arduino Uno gibt es vier Möglichkeiten. LOW, HIGH, RISING, FALLING. LOW und HIGH sind, denke ich einmal, klar. RISING bedeutet, dass sobald die Spannung, die beispielsweise ein Button, leitet steigt, die Funktion aufgerufen wird. FALLING ist das exakte Gegenteil, also sobald die Spannung sinkt. Sobald also die Bedingung wahr ist, was automatisch laufend überprüft wird, wird die aktuelle Zeile im Sketch abgebrochen, die angegebene Funktion aufgerufen, und dann die vorherige Zeile, und der ganze Sketch regulär weiter ausgeführt. 

Das Definieren der "Interruptfunktion"

Im Setup Teil wird durch attachInterrupt() eine Funktion angegeben, die ausgeführt werden soll, wenn die Bedingung wahr ist. Diese muss aber auch definiert werden. Dazu muss man erst auswählen, ob die aufgerufene Funktion etwas zurückgeben soll, oder nicht. Interruptfunktionen geben nie etwas zurück. Nichts zurückgeben bedeutet void. Dann muss der Name der Funktion kommen mit Klammern. In diese können die Argumente geschrieben werden, die die Funktion benötigt. Auch das ist bei Interruptfunktionen leer. Also (). In die nachfolgenden, geschweiften, Klammern wird der eigentlich Programmcode der Funktion geschrieben. Eine weitere Besonderheit bei Interrupts ist, dass Variablen, die in einem Interrupt verwendet werden immer ein volatile vor dem Datentyp bei der Definition brauchen.

Eine LED per Interrupt zum Leuchten bringen

Ein Beispiel, wo man einen Interrupt verwenden könnte, ist um eine LED, unabhängig vom Loop Teil, an-/auszuschalten. Im Loop Teil blinkt, bei mir, einfach nur eine LED. Der Sketch, mit Interrupt, sieht so :

Die Verkabelung ist auch ganz normal, und wie im Sketch angegeben:

Wenn man nun auf den Button drückt schaltet sich die LED an. Sobald man den Button wieder los lässt, schaltet sich die LED wieder aus.

LED über Interrupt steuern

Der Arduino bietet mehr als die beschriebenen Interrupts. Alle Interrupts des ATmega328 stehen auch im Arduino Umfeld zur Verfügung.
In meinem Buch "Arduino - Hard- und Software Open Source Plattform" habe ich u.a. die folgenden Interrupts an Hand von Programmbeispielen beschrieben: INT0, INT1, PCINTx, Timer - und Watchdog-Interrupt, Analog Comparator und AD-Umsetzer.

Die Verkabelung

Für das I2C Protokoll kann man normalerweise nicht jeden beliebigen Pin als SDA oder SCL Pin verwenden. Beim ATmega328, dem Kern des Arduino ist der SDA Pin der analog Eingang 4, und der SCL Pin der analog Eingang 5. Interessanterweise gibt es auch 2 extra SDA und SCL Steckplätze oberhalb von digital Pin 13.

Der Sketch des Masters

Um das I^2C Protokoll überhaupt verwenden zu können, muss man die Wire Bibliothek nachladen. Diese ist bereits vorinstalliert, weshalb das Einfügen der Zeile #include <Wire.h> genügt. Über Wire.begin(Adresse) wird die I^2C Kommunikation gestartet, wobei jedes Gerät eine Adresse haben sollte. Wenn es nur einen Master gibt, braucht er keine Adresse, ein Slave braucht immer eine Adresse. Über Wire.beginTransmission(AdressedesZiels); wird ein "Gespräch" gestartet, über write(Text) etwas gesendet und über endTransmission(); das "Gespräch" beendet.

Der Sketch des Slaves

Das Neue beim Sketch des Slaves ist, dass im Setup Teil ein neuer Programmteil beim Empfangen einer Nachricht gestartet wird. Durch onReceive(NamedesauszuführendenAbschnitts); wird festgelegt, dass jedes mal wenn ein Gespräch mit dem Slave gestartet wird, der angegebene Programmteil ausgeführt wird. Dort wird über Wire.available geprüft ob noch etwas empfangen wurde und über Wire.read() das letzte Zeichen in einer Variable gespeichert. Wenn wir den oben geschickten Text jetzt empfangen wollen und über die serielle Konsole ausgeben lassen wollen, müssen wir immer zwischen Buchstabe und Zahl unterscheiden. Das geschieht durch die Festlegung des Datentyps der Variable zum Befehl Wire.read();. Der gesamte Sketch sieht dann so aus:

Die allgemeine Funktionsweise

Der Arduino Sketch

Im Arduino Sketch wird die serielle Verbindung gestartet und der digitalPin, an dem die LED angschlossen ist, als OUTPUT definiert. Dann wird im loop() Teil laufend überprüft, ob die Zahl die über die serielle Verbindung empfangen wird 1 oder 0 ist und die LED entsprechend geschaltet.

Der Processing Sketch

Im Processing Sketch muss die serielle Verbindung gestartet werden. Wer sich damit nicht auskennt sollte meinen Post dazu hier anschauen. Der einzig neue Befehl ist loadStrings(). Mit diesem Befehl kann man eine Textdatei Zeile für Zeile auslesen. Diese werden in einen Array, der vom Typ String sein muss, gespeichert. Erklärung Array im Lexikon. Danach wird die erste Zeile in eine Zahl umgewandelt, da sie ja nur 0 oder 1 enthält. Insgesamt sieht der Sketch so aus:

Die Website

Das Ergebnis

Die Funktionsweise

Die Installation von Processing

Der Loopteil heißt in Processing draw, ist aber ansonsten gleich. Hier wird durch eine if Schleife überprüft, ob es eine serielle Verbindung gibt, und dann der Inhalt in der Variable daten gespeichert. Danach wird dieser in der Konsole ausgegeben. Diese ist bei Processing das schwarze Feld unten. Insgesamt sieht der Code so aus:

Wenn auf dem Arduino nun ein Sketch ist, der über die serielle Verbindung etwas sendet, so erscheint das unten im schwarzen Fenster. Wenn ihr wissen wollt, wie der Arduino Sketch dazu aussehen müsste, schaut einfach bei meinem Post über die serielle Verbindung zum Arduino von gestern vorbei.

Ausblick

Daten vom Arduino zum PC

Um Daten vom Arduino zum PC zu schicken (beispielsweise Statusinformationen), muss man zunächst eine serielle Verbindung starten. Das geschieht im Setup Teil über den Befehl Serial.begin(Datenrate). Die "Standarddatenrate" ist 9600. Wenn man nun einen Text senden will, verwendet man den Befehl Serial.print("Text"), bei Variablen lässt man die Anführungszeichen weg. Um danach einen Zeilenumbruch am PC zu erhalten verwendet man die Funktion Serial.println("Text");.

Die Zeile while(Serial.available() < 0) {} ist ein kleiner Trick. Dadurch wird solange gewartet, bis die serielle Konsole am PC geöffnet wird. Erst, wenn diese geöffnet ist seht ihr die Nachrichten, die gerade gesendet werden. Ihr öffnet sie direkt in der Arduino IDE über einen Klick auf das Symbol rechts oben.

Dort erschient nun die von uns gesendete Nachricht:

Hallo, hier spricht der Arduino!

Daten vom PC zum Arduino

Um Daten vom PC zum Arduino zu senden tippt man einfach die Nachricht in Zeile der seriellen Konsole ein (siehe oben). Damit der Arduino diese Nachrichten aber auch auswertet muss man ihm das mitteilen. Nehmen wir mal an wir wollen zwei LEDs über die serielle Konsole steuern können. Dann müssen wir sie natürlich als OUTPUTs definieren und eine serielle Verbindung mit einer gewissen Datenrate starten. Nun müssen wir wieder überprüfen, ob die serielle Konsole geöffnet ist/etwas gesandt wurde. Dazu nehmen wir wieder den Befehl Serial.available(). Um nun die Nachricht in einer Variable zu speichern, verwendet man die Funktion Serial.read(). Diese liest jedoch immer nur ein Zeichen aus. Wenn wir also beide LEDs über die Zeichenkette 11 anschalten wollen, müssen wir zweimal die Funktion Serial.read() aufrufen. Nun müssen wir nur noch überprüfen, ob die Variable einer LED 0 ist, also aus, oder 1 ist, also an.

Hinweis: Jedes mal, wenn man die serielle Konsole neu startet, startet sich auch der Arduino neu!

Das Ergebnis sind dann über den PC gesteuerte LEDs.

Wozu werdet ihr die serielle Verbindung benutzen?

Der Arduino Uno (r3)

Der Arduino Leonardo ist dem Arduino Uno sehr ähnlich, etwa von der Größe und Pinanzahl. Jedoch ist der Mikrocontroller des Arduino Leonardo(ATmega32u4) fest verbaut und der Arduino Leonardo hat einen speziellen Chip um am PC zusätzlich als Maus/Tastatur zu erscheinen. Der ATmega32u4 ist von den technischen Daten her, abgesehen von 0.5KByte mehr SRAM(2KByte vs 2.5KByte), genauso, wie der ATmega328.

Der Arduino Yun

Der Arduino Yún ist eine erst kürzlich vorgestelle Arduino Version. Der Yun besteht wie der Leonardo aus einem ATmega32u4 hat jedoch zusätzlich einen Atheros AR9331 Controller verbaut. Dadurch hat der Yun einen SD Karten Slot, einen Ethernet Port und ein WLAN Modul. Der AR9331 hat eine spezielle Linux Version aufgespielt, die auch mit dem ATmega32u4 kommuniziert, wodurch sich sehr viele Projektmöglichkeiten ergeben. Nichtsdestotrotz kann der Arduino Yun ganz normal über die Arduino IDE programmiert werden, wie übrigens jeder der hier vorgestellten Arduinos.

Der Arduino Mega2560

Der Arduino Nano

Der Arduino Robot(eigentlich zwei)

Hier findet ihr die technischen Daten nochmal in einer Tabelle zusammengefasst:

Die Verkabelung

Glücklicherweise steht am HC-SR04 direkt drauf welcher Pin wofür ist. Von links nach rechts: Ground zum Ground, Echo zu einem digitalen Pin, Trig zu einem digital Pin und Vcc wieder an die 5V Spannungsversorgung. Ich habe digital Pin 7 für Trig und Pin 8 für Echo verwendet.

Die Funktionsweise und das Programm

Nun müssen wir nur noch die LED mit dem kurzen Bein an den Ground anschließen, und mit dem langen Bein an einen Datenpin. Dazu dann im Programm eine if Abfrage.

michaelsarduino: Entfernung messen mit einem Ultraschallsensor

-C39- Interrupts mit dem Arduino

Eigentlich ist das nichts besonderes, aber in der Literatur findet man hauptsächlich Programme, bei denen der Zustand von Pins zyklisch abgefragt wird. Das birgt die Gefahr, dass man manche Ereignisse nicht mitbekommt. Wer sicher gehen will, sollte mit Interrupts arbeiten.

Der Rechner reagiert auf externe Ereignisse, unterbricht seine Arbeit und führt eine Sonderaufgabe durch. Diese sollte sehr kurz sein, damit nicht an anderer Stelle etwas durcheinander kommt. Wie das geht, möchte ich hier kurz illustrieren.

#define INT0PIN 2

static volatile int int0var;

void int0(void) {
 int0var++;
}

void setup (void) {
 pinMode (INT0PIN, INPUT);
 digitalWrite (INT0PIN, 1);
 attachInterrupt(0, int0, FALLING);
}

void loop (void) {
 if (int0var > 0) {
  int0var = 0;
  // Verarbeite Interrupt
 }
}

Der Code ist eigentlich ganz einfach. Zunächst einmal wird ein Pin für den Interrupt definiert. Die Pins 2 und 3 sind dafür vorgesehen. Dann definieren wir eine Variable vom Typ "static volatile int". static heißt, dass es eine globale Variable auf dem Heap ist, die mit 0 initialisiert wird. volatile bedeutet, dass sich der Compiler nicht darauf verlassen kann, dass der Wert unverändert bleibt.

Denn letztendlich kann die Interruptroutine int0() den Wert zur Laufzeit verändern. Die Routine tut nichts anderes als den Wert der Variablen int0var zu erhöhen.

In der Initialisierungsfunktion setup() wird zunächst der Interruptpin als Eingang definiert. Dann wird der Wert 1 geschrieben. Es klingt zunächst widersinnig, auf einen Eingang zu schreiben. Es passiert jedoch nichts anderes, als dass dadurch der interne Pull-Up-Widerstand aktiviert wird. Auf gut Deutsch: Am Pin steht immer eine Spannung an, die man einfach kurzschließen kann um einen Interrupt auszulösen. Als letztes wird dem Interrupt 0 die Routine int0() zugewiesen, der Interrupt scharf geschaltet und zwar so, dass er auf fallende Flanken reagiert.

Im Hauptprogramm kann alles mögliche stehen. Wichtig ist der hier illustrierte Teil: Die Variable int0var wird geprüft. Hat sie einen von 0 verschiedenen Wert, sind Interrupts aufgetreten und können bearbeitet werden. Dazu wird als erstes int0var zurück gesetzt, um weitere Interrupts zu registrieren.

Und schon haben wir ein Programm, das sich erst dann mit den externen Anschlüssen beschäftigt, wenn dort etwas passiert.

Interrupts mit dem Arduino

Die Verwendung von Interrupts auf der Arduino Plattform

Das Definieren der "Interruptfunktion"