Michael ARDUINO

http://sites.prenninger.com/arduino-uno-r3/michael-arduino

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                          Wels, am 2017-02-08

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   siehe     http://sites.prenninger.com/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-michael.arduino (75 Seiten)_1a.pdf


Untergeordnete Seiten (2):

B - Michael Bonacia 
A - michaelsarduino



-C01- Zufallszahlen mit dem Arduino erzeugen
-C02- LED Spiel
-C03- Software PWM
-C04- Fritzing
-C05- Einbruchsschutz mit dem Arduino
-C06- FIRMATA
-C07- Processing Programm steuert Arduino über Bluetooth
-C08- Bluetooth
-C09- Windows 10 + Arduino IDE
-C10- Loopback Test
-C11- PIC Mikrocontroller
-C12- Fuses
-C13- Stärke eines Widerstand ablesen
-C14- Optokoppler
-C15- Schleifen in C++
-C16- Aref pin
-C17- Arduino mit dem Atmel Studio programmieren
-C18- Port Manipulation am Arduino
-C19- SPI Kommunikation am Arduino
-C20- Arduino mit Strom versorgen
-C21- 7-Segment Display
-C22- Analog Input als Output verwenden
-C23- SoftwareSerial mit dem Arduino verwenden
-C24- Mikrocontroller mit Arduino Programmieren
-C25- Datentypen des Arduino
-C26- Eigene Bibliothek für den Arduino erstellen
-C27- Eigene Funktion für den Arduino definieren
-C28- Stand-by-Modus für den Arduino
-C29- Timerinterrupt und Watchdogtimer
-C30- Interrupts mit dem Arduino
-C31- Arduinos zusammenschalten über I2C
-C32- LED am Arduino über Website steuern
-C33- Processing mit dem Arduino
-C34- Serielle Verbindung zwischen PC und Arduino
-C35- Die verschiedenen Arduino Versionen und ihre Unterschiede
-C36- Die Festplatte eines Mikrocontrollers | Der EEPROM
-C37- Entfernung messen mit einem Ultraschallsensor
-C38- Musik mit dem Arduino
-C39- Interrupts mit dem Arduino



                      C - Michael Bonacia
          https://plus.google.com/110786353506245861399




-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.








-C02- LED Spiel
In diesem Post geht es darum, wie man mit dem Arduino ein kleines Spiel, mit LEDs und Buttons, bauen kann. Bei diesem Spiel leuchtet jeweils zufällig eine von vier LEDs. Der Spieler muss nun den Button vor der LED drücken. Danach leuchtet wieder zufällig eine der vier LEDs. Das Spiel läuft 30 Sekunden, und gewonnen hat der, der am öftesten den richtigen Button gedrückt hat. Für jeden falschen Buttondruck gibt es einen Punktabzug.




Die Hardware

Zunächst einmal benötigt man 4 LEDs, sowie 4 Buttons. Außerdem benötigt man 4 kleine Widerstände. Die Buttons werden auf der einen Seite mit dem Ground verbunden und auf der anderen Seite über die Widerstände mit den 3.3V des Arduino. Auf der dadurch positiven Seite des Buttons wird außerdem die Verbindung zum Arduino angebracht. Dadurch ist der Eingangspin des Arduino normalerweise auf HIGH und sobald der Button gedrückt wird auf LOW. Neben die Button bringt man nun jeweils die LEDs an.

Bread-Board Aufbau



In echt sieht das dann so aus:

Die Software

Zunächst einmal müssen die Pins, an denen die LEDs angeschlossen sind, als OUTPUTs und die Pins, an denen die Buttons angeschlossen sind, als INPUTS definiert werden. Im eigentlichen Spiel generiert der Arduino eine Zufallszahl zwischen 2 und 6, die Pins an denen die LEDs angeschlossen sind. Der Zufallspin wird dann auf HIGH geschaltet.

Nun beginnt eine while Schleife, die solange weitergeht, wie der richtige Button nicht gedrückt wurde. In ihr wird geprüft, ob ein Button gedrückt wurde. Sollte das der Fall sein, wird vom "score" eins abgezogen. Anschließend wird geprüft, ob eventuell der richtige Button gedrückt wurde. Falls er der Richtige ist wird dem score zwei hinzugefügt(eins, weil nichts abgezogen werden muss, und eins, weil es der Richtige ist). Dadurch wird immer ein Punkt abgezogen, wenn ein falscher Button gedrückt wurde und ein Punkt hinzugefügt, wenn der Richtige gedrückt wurde.

Dieser Vorgang wird 30 Sekunden lang durchgeführt. Danach werden alle LEDs angeschaltet, und der erreichte Score über die serielle Verbindung an den PC gesendet:





Hier seht ihr den Code:
int score = 0;

void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, INPUT);
pinMode(7, INPUT);
pinMode(8, INPUT);
pinMode(9, INPUT);
Serial.begin(9600);
unsigned long akt = millis();
unsigned long mom = 0;

while((akt + 30000) > mom)
{
digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);
digitalWrite(5, LOW);

int zufall = random(2, 6);
digitalWrite(zufall, HIGH);
boolean richtig = false;
while(richtig == false)
{
if(digitalRead(6) == LOW || digitalRead(7) == LOW || digitalRead(8) == LOW || digitalRead(9) == LOW)
{
score = score - 1;
int zusammen = zufall + 4;
if(digitalRead(zusammen) == LOW)
{
richtig = true;
score = score + 2;
}
}
delay(100);
}
mom = millis();
}
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
digitalWrite(5, HIGH);
Serial.println("*********************");
Serial.print("Your Score: ");
Serial.println(score);
Serial.println("*********************");
}

void loop() {

}

view raw LED_Spiel.ino hosted with ❤ by GitHub








-C03- Software PWM
In diesem Post geht es um die Software PWM Bibliothek. Mittels dieser Bibliothek kann man an beliebigen Pins des Arduino ein PWM Signal (=Pulsweitenmodulation) erzeugen. Bei einem PWM Signal ist, beispielsweise eine LED, nicht nur an oder aus, sondern kann auch eine gewisse Stärke.




Um die Software PWM Bibliothek zu nutzen, muss man sie zunächst hier herunterladen. Nun muss man die .zip Datei entpacken und ihren Inhalt in den "libraries" Ordner eurer Arduino IDE verschieben. Sobald ihr nun die Arduino IDE startet und auf Sketch > Include Library klickt, solltet ihr die SoftPWM Library sehen.





Nachdem man die Bibliothek im Sketch nachgeladen hat, muss man zunächst im setup Teil SoftPWMBegin(); aufrufen. Ab diesem Zeitpunk kann man überall im Programm den Befehl SoftPWMSet() aufrufen. Dieser hat zwei Argumente. Das erste Argument ist der Pin, welchen ihr verwenden wollt, und das zweite die Stärke des PWM Signals(0 - 255). 

Es ist möglich mehrere PWM Signale gleichzeitig zu erzeugen. Außerdem unterstützt die SoftPWM Library die analog Pins eures Arduinos.
Ein kleines Beispielprogramm, welches eine LED, angeschlossen an Pin A0, sanft an und wieder aus macht, sähe so aus:

#include <SoftPWM.h>

void setup() {
SoftPWMBegin();
SoftPWMSet(A0, 0);

}

void loop() {
int i = 0;
while(i<255)
{
SoftPWMSet(A0, i);
i++;
delay(3);
}
i = 255;
while(i>0)
{
SoftPWMSet(A0, i);
i--;
delay(3);
}
}

view raw softpwm.ino hosted with ❤ by GitHub


michaelsarduino: Software PWM





-C04- Fritzing
In diesem Post geht es um das Open Source Tool Fritzing. Mit diesem Tool kann man sein "Breadbordschaltpläne" am PC nachzeichnen, um sie mit Anderen zu teilen, oder in eine PCB Board Vorlage umzuwandeln.



Die Installation von Fritzing

Um Fritzing zu verwenden, muss man es sich herunterladen. Das kann man auf der offiziellen Fritzingseite gratis tun(ca. 50Mb). Nachdem der Download abgeschlossen ist, muss man die .zip Datei entpacken und im neuen Ordner die Datei Fritzing.exe ausführen. Nun öffnet sich das folgende Fenster:



In der oberen Leiste findet ihr 5 Menüpunkte: Willkommen, dem Reiter auf dem ihr gerade seid, wo ihr mit aktuellen Neuigkeiten über Fritzing informiert werdet. Anschließend befinden sich die drei Ansichten zum Zeichnen von Schaltungen. Im Menüpunkt Steckplatine findet ihr ein Breadboard in welches ihr die Bauteile stecken könnt(dazu gleich mehr). Unter Schaltplan findet ihr den Schaltplan, wie ihr ihn im Physikunterricht zeichnen würdet, und unter Leiterplatine das Platinenlayout eurer Schaltung. 

Die Verwendung von Fritzing

Einfacherweise kann man eine Schaltung in einer Ansicht seiner Wahl "herstellen", etwa mit einem Breadboard, und dann durch Wählen eines anderen Menüpunkts sofort die Schaltung als Leiterplatine darstellen lassen. 
Wenn man seiner Schaltung neue Bauteile hinzufügen möchte, muss man sich in der rechten Spalte Eines auswählen. Dabei sind die Bauteile in Kategorien sortiert, beispielsweise gibt es die Kategorie Core mit den "Standardbauteilen", oder die Kategorie Arduino mit den verschiedenen Arduinoboards. 
Um das Bauteil zu verwenden zieht man es einfach, mit gedrückter linker Maustaste, an den gewünschten Ort. Um nun zwei Bauteile zu verbinden klickt man den ersten Kontaktpunkt an, und fährt dann mit gedrückter Maustaste zum zweiten Kontakt. Wenn man nun die Maustaste loslässt, hat man eine Verbindung hergestellt.



PCB Boards herstellen lassen

PCBs (printed circuit boards) sind Platinen, auf welchen die Bauteile eines Projekts, etwa der Mikrocontroller und die LED, fest verbaut sind, und zusätzlich elektrisch leitend verbunden sind. Mit Fritzing kann man seine Breaboardschaltung in ein PCB umwandeln, indem man die Ansicht Leiterplatine wählt. Um nun zu überprüfen, ob das PCB so gebaut werden könnte, muss man auf Routing > Entwurfsregelprüfung DRC klicken.


Jetzt prüft Fritzing das PCB und gibt, wenn alles passt, eine Erfolgsmeldung aus. Nun muss man sich noch einen PCB Hersteller suchen. Da wir die Software Fritzing verwenden und Fritzing selbst PCBs herstellt, ist dort der Bestellaufwand sehr gering. Man muss lediglich die .fzz des Projekts hochladen. Unter http://fab.fritzing.org/pricing findet ihr die Preisliste. Dabei wird normalerweise pro cm^2 der Preis berechnet, wobei der bei höheren Stückzahlen sinkt. Natürlich gibt es auch bei den PCB Herstellern billigere Konkurrenten. 







-C05- Einbruchsschutz mit dem Arduino
In diesem Post geht es darum, wie man mithilfe des Arduino Einbrecher abschrecken kann, um entspannt in den Urlaub zu fahren.



Um sein Haus vor Einbrechern zu schützen gibt es zwei Möglichkeiten. Die erste besteht darin sich eine Alarmanlage zu kaufen, um damit immer gewarnt zu werden und einen Sicherheitsdienst zu rufen. Das Problem ist jedoch, dass man sich nicht einfach Alarmanlage selbst bauen darf, da sie gewisse Richtlinien erfüllen müssen, um beispielsweise nicht immer Alarm zu schlagen wenn nur ein Vogel da ist und damit die Nachbarn aufweckt. Die zweite Möglichkeit ist, vorzutäuschen, dass in der Gegend noch andere Personen anwesend sind. Denn welcher Einbrecher bricht in ein Haus ein, wo eventuell noch Leute in der Nähe unterwegs sind und ihn entdecken könnten?

Für meinen kleinen Einbruchsschutz verwende ich einen Arduino Uno mit zwei Bewegungssensoren. Zusätzlich verwende ich einen 8 Ohm Lautsprecher und eine blaue sowie zwei rote LEDs. Mit dieser Kombination kann ermittelt werden, wann sich eine Person nähert. Sobald das festgestellt wurde, fangen die LEDs an abwechselnd rot/blau zu leuchten und der Lautsprecher eine Sirene zu imitieren. Hinweis: Bitte beachte die bei dir herrschenden Gesetze in Bezug auf Sirenen/Blaulicht. Natürlich ist die Sirene sehr leise/das Licht sehr schwach. Aus diesem Grund sollte der Einbrecher unseren Schutz auch nicht sehen können. Stattdessen sollte der Einbruchsschutz eine mehrere Straßen weiter fahrenden Polizeiwagen imitieren. Dadurch wird es sich der Einbrecher zwei mal überlegen in deinem Haus einzubrechen. Da sich der Einbruchsschutz draußen befinden sollte verwende ich ein 4 AA Batteriehalter. Damit erhält man 6 V Spannung, die man über den VIN Pin des Arduino in 5 V umwandeln kann. Hier findet seht ihr meinen Sketch dazu:

#define NOTE_D5 587

#define NOTE_A5 880

void setup() {
pinMode(13, INPUT);
pinMode(12, INPUT); //sensoren
pinMode(10, OUTPUT); //blau
pinMode(9, OUTPUT);
pinMode(8, OUTPUT); //rot
}

void loop() {
while(digitalRead(13) == HIGH || digitalRead(12) == HIGH)
{
for(int i = 0; i < 5; i++)
{
tone(11, NOTE_A5, 200);
delay(125);
noTone(11);
tone(11, NOTE_D5, 125);
delay(125);
noTone(11);
}
for(int i = 0; i < 10; i++)
{
digitalWrite(10, HIGH);
delay(250);
digitalWrite(10, LOW);

digitalWrite(9, HIGH);
digitalWrite(8, HIGH);
delay(250);
digitalWrite(9, LOW);
digitalWrite(8, LOW);
}
}
}

view raw alarm.ino hosted with ❤ by GitHub

Und so sieht das Ganze in echt aus:

Was kann man noch hinzufügen?

Es gäbe viele Dinge, die man noch hinzufügen könnte. Beispielsweise könnt man über 433Mhz Sender und Empfänger ein ganzes Netzwerk aufbauen. Wenn also der Sensor vor der Eingangstüre etwas entdeckt, starten die Programme im ganzen Haus, etwa das Licht geht an, oder die Jalousien fahren herunter... Zusätzlich kann man die Alarmanlage mit dem Internet verbinden, damit man auch im Urlaub checken kann, ob jemand seinem Haus einen Besuch abgestattet hat.







-C06- FIRMATA
In diesem Artikel geht es um das Firmata Protokoll. Das Firmata Protokoll ist ein Protokoll, über welches man mit "Fernsteuerungsbefehlen", die man über die serielle Verbindung sendet, den Arduino steuern kann. Dadurch bekommt der Arduino nur die Befehle zum Schalten der Pins, und das eigentliche Programm wird auf einem leistungsfähigeren PC ausgeführt.




Um überhaupt das Firmata Protokoll zu verwenden, muss man dem Arduino zunächst mitteilen, was die, über die serielle Verbindung gesendeten, Befehle bedeuten. Dazu gibt es einen "StandardFirmataSketch" für den Arduino. Dieser  Übersetzt die Firmatabefehle in "normalen" Arduino Code. Dieser Sketch ist bereits bei der Arduino IDE dabei. Ihr findet ihn unter Datei > Beispiele > Firmata > StandardFirmata_2_2_forUNO_0_3. Nachdem ihr ihn auf euren Arduino Uno hochgeladen habt ist euer Arduino fertig vorbereitet. Da die Firmata Befehle immer in Echtzeit gesendet werden, muss euer Arduino immer mit eurem PC verbunden sein.

Nun könnt ihr an euren Arduino live Befehle senden. Dabei hat man jedoch weit mehr Möglichkeiten, wenn man die Befehle nicht manuell über die serielle Konsole sendet, sondern man mittels der Programmiersprache Processing ein PC Programm erstellt. Dieses kann dann Anweisungen "live" an euren Arduino senden. Ich habe bereits ein paar Tutorials über Processing mit dem Arduino geschrieben: Installation der IDE und erster Test, Beispielprogramm(steuern einer LED am PC), ...

Um den Arduino mittels Firmata in Processing zu verwenden gibt es zwei Processing Bibliotheken cc.arduino und die normale Serial Bibliothek von Processing. Die cc.arduino Bibliothek könnt ihr hier herunterladen. Nun müsst ihr die .zip Datei in den libraries Ordner eures Processing Ordners entpacken. Zum einfachen Einstieg gibt es Beispielsketche zur Firmataverwendung. Diese findet ihr unter dem Menüpunkt Datei > Beispiele > ContributedLibraries > arduino.

Ein einfaches Beispiel ist der Output Sketch. Dieser hat 14 Buttons, über welche man die digital Pins des Arduino steuern kann. Wie ihr im Code sehen könnt sind die Befehle die Selben, wie in der Arduino IDE. Man muss jedoch vor jedem Befehl immer das serielle Objekt mitangeben: arduino.digitalWrite(13, Arduino.HIGH); .

Wie ihr seht ist es mittels dem Firmata Protokoll einfacher seinen Arduino mittels Processing zu steuern, da man dadurch nicht alle "Befehle" neu definieren muss, was man ohne das Firmataprotokoll tun müsste. Da man den Arduino mit Processing auf einem PC steuert, hat man auch die größeren Möglichkeiten eines PC, etwa die Verwendung des Internets





-C07- Processing Programm steuert Arduino über Bluetooth
 In diesem Artikel geht es darum, wie man über die Programmiersprache Processing ein PC Programm erstellt, welches mit dem Arduino über Bluetooth kommunizieren, und damit Befehle übermitteln kann.



Der Aufbau

Um überhaupt mittels Bluetooth zu kommunizieren benötigt dein Arduino ein Bluetoothmodul. Ein einfach zu verwendendes, ist das HC 05 Bluetoothmodul. Den VCC Pin des Moduls verbindest du mit den 5V des Arduino, den GND Pin mit dem Ground. Der RXD Pin wird mit dem TX Pin des Arduino und der TXD Pin mit dem RX Pin des Arduino verbunden. Für die Stromversorgung verwende ich 4 AA Batterien, da ich ja sonst mit der USB Leitung "cheaten" könnte.


Der Processing Sketch

Zur Installation der Processing IDE und der Programmiersprache Processing habe ich bereits ein paar Artikel geschrieben(Installation der IDE, Daten über serielle Verbindung senden(wichtig!), ...). Um hier die Bluetoothkommunikation an einem Beispiel zu zeigen, soll unser Programm die LED des Arduino steuern können. Glücklicherweise ist die Verwendung von Bluetooth in Processing sehr, sehr(!) ähnlich mit dem Senden von Daten über die USB Verbindung. Wenn ihr den Arduino über USB an euren PC anschließt, erstellt er einen COM Port für ihn. Über diesen COM Port sendet/empfängt Processing dann Daten. Wenn ihr den Arduino über Bluetooth mit eurem PC verbindet, erstellt dieser ebenfalls einen COM Port. Der einzige Unterschied ist, dass er einen andere Nummer trägt. Bei mir ist die USB Verbindung COM3 und die Bluetooth Verbindung COM8. Wenn man dieses Detail im Processing Sketch zum Senden über USB verändert, funktioniert das Senden über Bluetooth einwandfrei. Um herauszufinden an welchem COM Port euer Arduino angeschlossen ist klickt ihr auf das blaue Bluetoothsymbol in eurer Taskleiste. Nun klickt ihr auf Einstellungen öffen. In diesem Fenster klickt ihr nun auf die Kategorie COM-Anschlüsse.




Nun seht ihr auf welchem COM Port euer Arduino angeschlossen ist. Diesen müsst ihr euch merken und in den Processing Sketch eintragen.

import processing.serial.*;

Serial arduino;

boolean button = false;

int x = 200;
int y = 180;
int b = 100;
int h = 75;

void setup() {
size(500, 500);
arduino = new Serial(this, "COM8", 9600);
}

void draw() {
if(button) {
background(255, 0 ,0);
fill(0);
arduino.write("1");
}
else {
background(0);
arduino.write("0");
fill(255, 0, 0);
}
rect(x, y, b, h);
}

void mousePressed() {
if(mouseX > x && mouseX < x+b && mouseY > y && mouseY < y+h)
{
button = !button;
}

Der Arduino Sketch

Der Arduino Sketch muss nur eine serielle Verbindung mit der Datenrate 9600 erstellen. Dabei ist es praktisch, wieder SoftwareSerial zu verwenden, da man dadurch auch seinen Sketch aktualisieren kann, ohne das Bluetoothmodul abzustecken, da die "normale" serielle Verbindung frei bleibt. Sobald der Arduino nun etwas über die serielle Verbindung empfängt muss er nur noch überprüfen, ob es 1 ist, und die LED anmachen, oder aber überprüfen, ob der Processing Sketch 0 gesendet hat, er also die LED ausschalten soll. 

#include <SoftwareSerial.h>

SoftwareSerial bluetooth(2, 3);

void setup() {
bluetooth.begin(9600);
pinMode(13, OUTPUT);
}

void loop() {
if(bluetooth.available() > 0)
{
int status_led = bluetooth.read();
if(status_led == 49)
{
digitalWrite(13, HIGH);
}
if(status_led == 48)
{
digitalWrite(13, LOW);
}
}


Wie man sieht ist es vergleichsweise einfach mit Processing ein PC Programm zu erstellen und mit dem Arduino über Bluetooth zu kommunizieren, da man ihn, wie bei der USB Verbindung, über einen COM Port ansprechen kann.




-C08- Bluetooth
In diesem Post geht es darum, wie man das HC-05 Bluetoothmodul korrekt mit dem Arduino verbindet und dadurch Daten mit einem anderen Bluetooth Gerät(PC, Notebook, Smartphone, ...) austauscht.



Die Verkabelung

Glücklicherweise sind die Pins des HC 05 Bluetoothmoduls mit verständlichen Bezeichnungen markiert. Das Modul hält die 5V Spannung des Arduino UNO aus, weshalb man wirklich nur die Kontakte über die Kabel verbinden muss. Dabei wird VCC an die 5V Spannungsversorgung angeschlossen und GND an den Ground. Das Bluetoothmodul kommuniziert über eine serielle Verbindung mit dem Arduino. Deshalb muss der RXD Pin des Moduls mit dem TX Pin des Arduino und der TXD Pin mit dem RX Pin des Arduino verbunden werden. Diese Verkabelung reicht zum einfachen Versenden und Empfangen von Daten über Bluetooth.

Der Arduinosketch

Um Daten über das Bluetoothmodul zu senden muss man einfach eine serielle Verbindung mit dem Gerät starten(Datenrate 9600) und dann kann man ganz normal Daten über diese serielle Verbindung senden. Das Bluetoothmodul sendet dann die empfangenen Daten weiter an das Smartphone. Um Daten zu empfangen verwendet man auch die serielle Verbindung. Hier findet ihr erklärt, wie man Daten über eine serielle Verbindung übertragt. Um am Anfang besser überprüfen zu können was passiert, ist es sinnvoll die über Bluetooth empfangenen Daten an den PC zu schicken, um sie dort ausgeben zu lassen. Das bedeutet jedoch, dass man Pin 0 und 1 nicht verwenden darf, da sie für die serielle Verbindung über USB benötigt werden. Das macht jedoch nichts, da man mittels der Arduino Bibliothek SoftwareSerial zwei beliebige Pins für eine neue serielle Verbindung verwenden kann. Ich verwende jetzt Pin 2 und 3 für die neue serielle Verbindung mit dem HC 05 Chip. Insgesamt sieht der Aufbau dann so aus:


Ein Sketch, welcher Daten über Bluetooth empfängt und an den PC weiterleitet, sieht so aus:

#include <SoftwareSerial.h>

SoftwareSerial serialbluetooth(2, 3);

void setup() {
serialbluetooth.begin(9600);
Serial.begin(9600);
}

void loop() {
if(serialbluetooth.available() > 0)
{
String status_led = serialbluetooth.readString();
Serial.println((String)status_led);
}


Bluetoothverbindung mit Smartphone

Zunächst einmal muss man Bluetooth auf seinem Smartphone aktivieren. Um Daten manuell über Bluetooth zu versenden gibt es diverse Apps. Eine gute Android App ist die App "BlueTerm".

Nachdem man die App installiert hat verbindet man den Arduino mit dem PC, um das Bluetoothmodul zu starten. Nun geht man in die Einstellungen und verbindet sein Smartphone mit dem Bluetoothmodul. Bei mir hieß es HC-05. Falls eine Pin abgefragt wird, muss man 1234 eingeben. Nun kann man die APP BlueTerm öffnen. Falls man hier noch nicht verbunden ist klickt man in BlueTerm auf ConnectDevice und HC-05. Nun steht oben rechts connected. Wenn man nun eine Zahl oder einen Buchstaben auf der Bildschirmtastatur eingibt, erscheint er nach kurzer Zeit in der seriellen Konsole am PC.





-C09- Windows 10 + Arduino IDE
Heute habe auch ich die Meldung erhalten, dass das Upgrade auf Windows 10 für meinen PC bereitsteht. Nachdem ich das Upgrade ausgeführt habe, habe ich die Arduino IDE unter Windows 10 ausprobiert. Hier meine Erfahrungen:

Design

Wie alle Fenster in Windows 10 ist der Rahmen der Arduino IDE verändert worden. Auch die Icons zum verkleinern, vergrößern und schließen wurden verändert. Die einzige andere Änderung ist eine geänderte Hinterlegung eines Menüpunkts, über den man mit der Maus fährt.




Funktionen der Arduino IDE

Um die Arduino IDE zu testen habe ich den blink Sketch aus den Beispielen(Datei > Beispiele > Basics > Blink) auf den Arduino heruntergeladen. Dabei wurden scheinbar alle Pfade von Windows 10 korrekt beibehalten, da der Upload einwandfrei funktionierte. Auch mein Arduino Uno wurde korrekt erkannt. Der COM Port ist dabei der Selbe, wie unter Windows 8 geblieben, in meinem Fall COM 3. Auch meine hinzugefügten Bibliotheken und gespeicherten Dateien erkennt die Arduino IDE unter Windows 10.

Bisher sind mir noch keine Bugs in der Arduino IDE augefallen, wobei ich den Artikel aktualisieren werde, wenn ich welche finden sollte. Damit spricht, aus Sicht des Arduino, nichts gegen ein Upgrade auf Windows 10.

Hast du einen Bug gefunden? Schreib ihn in die Kommentare, damit wir gemeinsame eine Lösung finden können!



-C10- Loopback Test
In diesem Post geht es um den Loopback Test. Der Loopback Test ist ein Test, um zu überprüfen, ob die Verbindung zwischen dem PC und dem Arduino einwandfrei funktioniert. Wenn der Loopback Test bei euch funktioniert, wisst ihr sicher, dass euer PC über die serielle Verbindung senden kann und, dass das USB Kabel und der USB to Serial converter von eurem Arduino funktionieren.


Aufbau 

Beim Loopback Test sendet euer Computer Daten über die serielle Verbindung an euren Arduino. Der Mikrocontroller des Arduino (ATmega328) wird dabei durch eine Verbindung zwischen dem Resetpin und dem Ground deaktiviert gehalten. Durch eine Verbindung des RX und des TX Pins werden die Daten die der Arduino empfägt direkt wieder an den PC zurück gesendet.
1. Entferne alle angeschlossenen Shields oder sonstige Geräte
2. Trenne die Verbindung zum PC
3. Verbinde den Reset Pin mit dem Ground
4. Verbinde RX(0) mit TX(1)
5. Verbinde den Arduino mit dem PC


Durchführung des Loopback Tests

Nun musst du die Arduino IDE öffnen. In ihr öffnest du mit einem Klick rechts oben auf den Button die serielle Konsole. Nun kannst du in die Zeile oben Etwas eintippen. Sobald du auf "Senden" klickst sollte nach kurzer Zeit der getippte Text im Fenster unten erscheinen:



Ergebnis des Loopback Tests

Wenn nun der eingetippte Text erscheint, funktioniert Alles einwandfrei. Sollte der Text nicht erscheinen solltest du als Erste überprüfen, ob die Kabel richtig angeschlossen sind und es auch mit anderen Kabeln (auch das USB Kabel tauschen) ausprobieren. Weiterhin solltest du überprüfen, ob die RX sowie die TX LEDs leuchten. Diese deuten an, ob etwas über die serielle Verbindung empfangen wurde(RX) und ob etwas über die serielle Verbindung gesendet wurde(TX).



Es kann auch helfen das USB Kabel vom Computer zu trennen und dann neu zu verbinden, da manchmal Windows den Arduino nicht korrekt erkennt.




-C11- PIC Mikrocontroller
Dieser Artikel soll einen Einblick in die Welt der PIC Mikrocontroller und deren Programmierung geben.



Was sind PIC Mikrocontroller?

PIC Mikrocontroller sind, wie der Name bereits andeutet, Mikrocontroller, sie sind also für ähnliche Aufgaben gedacht, wie die AVR Mikrocontroler(AT...). PIC Mikrocontroller werden von der Firma Microchip seit den 90er Jahren hergestellt(Geschichte bei Wikipedia) Wie bei den AVR Mikrocontroller gibt es unterschiedliche Arten/Leistungsklassen der PIC Mikrocontroller. Das sind die 8Bit Mikrocontroller, die 16Bit Mikrocontroller und die 32Bit Mikrocontroller. Diese unterschieden sich jeweils in den technischen Daten, also der Leistungsfähigkeit, der Speichergröße, der Taktfrequenz, der Pinanzahl, .... Zusätzlich unterstützen die kleinen PIC Mikrocontroller keine Interrrupts. Die PICs kosten ungefähr genauso viel, wie AVR Mikrocontroller(ab 2€ bis ca. 15€).

Wie werden PICs programmiert?

Man kann PICs in verschiedenen Programmiersprachen programmieren. Bekannte Beispiele sind Assembler, C und BASIC. Das bedeutet ihr könnt sie ähnlich wie eure AVRs programmieren, da sie im wesentlichen die selben Sprachen unterstützen. Zur Programmierung gibt es von Microchip eine IDE namens MPLAB, in der neusten Version MPLAB X. Sobald man sein Programm geschrieben hat wird das Programm über die ICSP Schnittstelle hochgeladen. Von Microchip selbst gibt es Geräte zum Hochladen der Programme, wie beispielsweise das PICkit3(ca. 40€). Damit hat man dann eigentlich auch genug zum ersten Start, wobei es auch bei PICs von Vorteil sein kann sich erst ein kleines Board, ähnlich wie den Arduino bei AVRs, zu kaufen. 


Welche Mikrocontroller sind besser?

(ATmega328P-PU)

Diese Frage lässt sich, wie so oft, nicht pauschal beantworten. Es gibt bei in beiden "Welten" große Unterschiede bei der Leistungsfähigkeit und Mikrocontroller für spezielle Aufgaben. Deshalb muss man sich immer überlegen, was man den bauen möchte. Im Zweifelsfall kann es sich lohnen einfach beide auszuprobieren und dann zu schauen was einem besser gefällt. Ich jedenfalls habe mit dem Arduino, also AVR Mikrocontrollern, angefangen und bin sehr zufrieden mit ihnen, auch dank der großen Vielfalt(kleine ATtinys mit 6 Pins bis große ATmegas, wie im Arduino Mega 2560).





-C12- Fuses
In diesem Post geht es darum, was Fuses sind und wozu man sie verwenden kann. Vorneweg noch der Hinweis: Durch das falsche Setzen von Fuses kann man seinen Mikrocontroller unbrauchbar werden lassen, weshalb man immer wissen sollte was man tut, bevor man Fuses ändert.


Was sind Fuses?


Fuses, manchmal auch als Fuse-Bits bezeichnet, sind Speicherstellen in denen die "Grundeinstellungen" eines Mikrocontrollers gespeichert werden. Früher war es so, dass die Fuses Kontakte waren, die bei Bedarf verbunden wurden. Mittlerweile sind sie jedoch fast immer über Software veränderbar. In diesen Speicherstellen werden die relevanten Informationen zum Betrieb des Mikrocontroller gespeichert. Beispiele sind die Taktfrequenz, die Taktquelle, Schreibschutz für den EEPROM, .... Durch das ungeschickte Verändern der Fuses kann man seinen Mikrocontroller/Arduino unbrauchbar werden lassen. Wenn man aber weiß, was man tut, kann man einige coole Sachen, durch das Ändern der Fuses, anstellen. Beispielsweise ist es möglich den RESET Pin des Mikrocontrollers/des Arduino als zusätzlichen GPIO, also Input und Output, zu definieren. Dadurch hat man dann einen Pin mehr für seine Programme. 

Wie verändert man die Fuses?

Um die Fuses zu verändern bedarf es entweder einem Programmer, oder aber man verwendet einen Arduino. Dadurch kann man dann bei einem Mikrocontroller/ bei einem zweiten Arduino die Fuses ändern. Das geht über ein externes Programm namens Pony-Prog. In diesem Programm kann man dann die Fuses ändern, wobei du dich auch jeweils das Datenblatt deines Mikrocontroller zu Rate ziehen solltest, um die Standardeinstellungen und Besonderheiten zu erfahren. Zum Programm Pony-Prog und dem Verändern von Fuses gibt es hier ein Tutorial.

Ich hoffe ich konnte dir mit diesem Artikel einen Überblick über das Thema Fuses geben.





-C13- Stärke eines Widerstand ablesen

In diesem Post geht es darum, wie man die Stärke eines Widerstands abliest. Das geht über die farbigen Striche, die sich auf dem Widerstand befinden.

Ein Widerstand  hat entweder 4 oder 5 Striche, wobei der letzte Strich jeweils die Toleranz des Widerstands angibt, also wie stark der Wert des Widerstands vom angegebenen Wert abweichen kann. Man erkennt diesen Strich daran, dass er einen größeren Abstand zu den Anderen hat, oder dicker als die anderen Striche ist. Die ersten 3 oder 4 Striche geben die eigentlich Stärke an. Dabei steht jede Farbe für eine Zahl. Beispielsweise braun für eine 1. Der vorletzte Strich gibt jeweils den Multiplikationsfaktor an. Nun bildet man aus den ersten 2 beziehungsweise 3 Strichen eine Zahl, indem man die Zahlen einfach hintereinander hängt. Wenn ich also einen gelb-lila-rot-goldenen Widerstand habe, schaue ich nach, und sehe dass gelb für 4 steht, lila für 7, der rote Strich für mal 100 Ohm und der goldenen für 5% Toleranz. Jetzt hänge ich die 7 an die 4, also 47 und nehme das mal 100 Ohm. Das ergibt dann 4700 Ohm, also 4,7 kOhm, bei 5% Toleranz. In der Realität hat der Widerstand also einen Wert von 0,95 * 4700Ohm, also 4465 Ohm bis 1,05 * 4700 Ohm, also 4935 Ohm. Hier findest du die Tabelle mit den einzelnen Bedeutungen der Farben:
Und zum Abschluss noch eine kleine Aufgabe: Welche Stärke hat der folgende Widerstand?
Lösung:Es handelt sich um einen Widerstand mit 4 Strichen. Der erste Strich ist braun, also eine 1. Der zweite Striche ist schwarz, also eine 0. Das ergibt die Zahl 10. Der Multiplikationsfaktor ist ein roter Strich. Rot steht für mal 100 Ohm. 10 mal 100Ohm ergibt 1000 Ohm oder 1kOhm. Der goldene Strich steht für 5 % Toleranz. Die wahre Stärke des Widerstands liegt also zwischen 950 Ohm und 1050 Ohm.

Natürlich gibt es auch Tools im Internet, bei denen man die einzelnen Farben angibt und man dann die Stärke erhält. Ein Gutes ist dieses Tool. Mit der Zeit kriegt man jedoch Übung beim Ablesen der Stärke, wodurch man schneller selber abliest, als im Internet nachzuschauen.




-C14- Optokoppler  4N35
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:

int led = 13;
int opto = 7;
void setup() {
pinMode(led, OUTPUT);
pinMode(opto, INPUT);
}

void loop() {
if(digitalRead(opto) == HIGH)
{
digitalWrite(led, LOW);
}
else {
digitalWrite(led, HIGH);
}
}

view raw optokoppler 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. 



-C15- Schleifen in C++
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 }.






-C16- Aref pin
In diesem Artikel geht es um den AREF Pin des Arduino. Der AREF Pin des Arduino, ist der Pin, der den Referenzwert für die analog Inputs darstellt. Durch die Veränderung dieses Referenzwertes, also das Anlegen einer anderen Spannung am AREF Pin, kann man den Messbereich eingrenzen, um dadurch eine höhere Genauigkeit zu erzielen.



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.




-C17- Arduino mit dem Atmel Studio programmieren
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.

/*
* GccApplication2.cpp
*
* Created: 13.07.2015 14:24:32
* Author: Michael
*/
#ifndef F_CPU
#define F_CPU 16000000UL
#endif
#include <util/delay.h>
#include <avr/io.h>
int main(void)
{
DDRB = (1 << DDB5);
while(1)
{
PORTB = (1 << DDB5);
_delay_ms(100);
PORTB = (0 << DDB5);
_delay_ms(100);
}
}

view raw arduino_led_blinken hosted with ❤ by GitHub
Hierbei fällt sicherlich auf, dass das Schalten der LEDs mit der Port Manipulation in der Arduino IDE sehr ähnlich ist. Jetzt haben wir unser fertiges Programm. Das muss über File > Save All gespeichert werden. Anschließend kompiliert man über einen Druck auf die Tast F7 das Programm. Das erzeugt aus dem aktuellen Code die Hex Datei, die über einen Druck auf Tools > Euer Tool (z.B. Arduino Uno) auf den Arduino (hier bei AZ-Delivery) geladen wird. Ihr müsst vor jedem Upload eure Datei kompilieren, da ansonsten eine alte Hex Datei eures Programms hochgeladen wird. Jetzt blinkt die LED des Arduino.
Im nächsten Artikel geht es darum, wie man die GPIOs(Pins) des Arduino steuert.

  1. Hallo,
    damit funktioniert das Hochladen perfekt !
    -Uflash:w:"$(ProjectDir)Debug\Uno_Blink.hex"
    Es macht nur kein Sinn bei jedem Projekt den Namen zu ändern.
    Meine Frage: Was gebe ich anstelle /Uno_Blink ein in /&(????) die Klammer.
    Mit /&(ItemFileName) <- geht es jedenfalls nicht.







-C18- Port Manipulation am Arduino
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:










-C19- SPI Kommunikation am Arduino
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.

#include <SPI.h>

void setup (void)
{

digitalWrite(SS, HIGH); //SS Pin auf HIGH setzten

SPI.begin (); //Verbindung starten

SPI.setClockDivider(SPI_CLOCK_DIV8); //Geschwindigkeit verlangsamen

}

void loop (void)
{

char c;

digitalWrite(SS, LOW); //starten der Kommunikation mit Slave

for (const char * p = "Hallo, Welt!\n" ; c = *p; p++)
{
SPI.transfer (c); //senden von Text
}

digitalWrite(SS, HIGH); //beenden der Kommunikation

delay (1000); //kurze pause

Der Slave

Der Slave benötigt ebenfalls die SPI Bibliothek. Dann wird im Setup ein Interrupt erstellt, der aufgerufen wird, sobald etwas über die SPI Verbindung empfangen wird. Das wird dann, sobald eine "\n", also ein Zeilenumbruch, empfangen wird, über die serielle Verbindung, an den PC gesendet.

#include <SPI.h>

char buf [100];
volatile byte pos;
volatile boolean senden;

void setup (void)
{
Serial.begin (9600); //starten der seriellen Verbindung

SPCR |= bit (SPE); //SPI im Slave Modus starten

pinMode(MISO, OUTPUT);

pos = 0;
senden = false; //Variablen fuer Buffer vorbereiten

SPI.attachInterrupt(); //SPI Interrupt schalten

}


ISR (SPI_STC_vect) //SPI Interrupt
{
byte c = SPDR; //kopieren der Daten von SPI Buffer

if (pos < sizeof buf)
{
buf [pos++] = c; //hinzufuegen des naechsten Zeichens

if (c == '\n')
senden = true;

} //wenn Zeilenumbruch an PC senden
}


void loop (void)
{
if (senden) //warten auf Ende der Zeilenumbruch (\n)
{
buf [pos] = 0;
Serial.println (buf);
pos = 0; //senden der Daten ueber serielle Verbindung
senden = false; //senden -> falsch
}
}

view raw SPI_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:










-C20- Arduino mit Strom versorgen
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:






-C21- 7-Segment Display
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.
void setup() {
int i;
Serial.begin(9600);
for(i=2; i<10; i++)
{
Serial.println(i);
pinMode(i, OUTPUT);
digitalWrite(i, HIGH);
delay(5000);
digitalWrite(i, LOW);

}

}

void loop() {
//keine zu wiederholende Aktion

}

view raw 7SegmentDisplayTest hosted with ❤ by GitHub

Zahlen anzeigen

Wenn du nun weißt, wie das 7 Segment Display angesteuert wird, ist es am besten sich für jede Zahl eine Funktion zu schreiben. Ich werde das beispielhaft mit der Zahl 7, zeigen. Hier siehst du, welcher Pin, bei mir, was anschaltet:


In meinem Fall muss ich also immer Pin 7, 6 und 3 auf HIGH schalten, um eine 7 zu erzeugen. Davor müssen natürlich alle Pins zum Schalten des 7 Segment Displays auf LOW gesetzt werden, damit sich die Zahlen nicht vermischen. Hier wird erklärt, wie man eine Funktion definiert. Der gesamte Code zum Schreiben einer 7 sieht dann so aus:

void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
}

void loop() {
sieben();

}

void sieben() {
int i;
for(i=2; i<10; i++)
{
digitalWrite(i, LOW);
}
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);

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.






-C22- Analog Input als Output verwenden
In diesem kurzen Artikel geht es darum, wie man die analog Inputs des Arduino als GPIOs verwendet. Das bedeutet, das sie als INPUT und als OUTPUT verwendet werden können.

Um einen analog Input als OUTPUT zu verwenden,  definiert man ihn einfach in der Setuproutine als OUTPUT. Das geht auch über den Befehl pinMode(), wobei man als Pinnumer jeweils die Pinnummer mit einem A davor benutzt. Um Beispielsweise den analog Eingang 0 zu benutzen, um eine LED zu schalten, schreibt man:



Jetzt liegt eine Spannung an Pin A0 an:

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




Leider unterstützen die analog Inputs kein PWM. Das bedeutet man kann sie nur auf LOW oder HIGH schalten und nicht in Stufen(0-255). PWM unterstützen am Arduino Uno Pin 3, 5, 6, 9, 10, 11.

Die analog Pins als GPIOs zu verwenden ist eine einfache Möglichkeit größere Projekte zu ermöglichen.






-C23- SoftwareSerial mit dem Arduino 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.

Suche in GOOGLE
michaelsarduino: SoftwareSerial mit dem Arduino verwenden



-C24- Mikrocontroller mit Arduino Programmieren
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.

michaelsarduino: Mikrocontroller mit Arduino Programmieren





-C25- Datentypen des Arduino
In diesem Post geht es um die verschiedenen Datentypen, die man zum Programmieren des Arduino verwenden kann. Außerdem, wie man die verschiedenen Datentypen in einander umwandeln kann.

Die einzelnen Datentypen

Boolean

Ein Boolean ist ein Wahrheitswert. Das bedeutet er kann den Wert TRUE oder den Wert FLASE beinhalten. Da das im Arduino mit Strom oder kein Strom gespeichert wird benötigt er nur einen Bit des Speichers.

Definition in der Arduino IDE:

boolean Name_der_Variable = FALSE;

Byte

Ein Byte besteht aus 8 Bit. Das bedeutet er speichert 8 mal Strom an oder aus. Dadurch ergeben sich 256 Kombinationen, weshalb ein Byte eine Zahl zwischen 0 und 255 speichern kann.

Definition in der Arduino IDE:

byte Name_der_Variable = 233;

Integer

Integer, kurz int, ist wahrscheinlich der meist verwendete Datentyp für Zahlen. Ein Intger enthält nur Ganzzahlen, also keine Kommazahlen. Es können Zahlen zwischen -32768 und +32767 gespeichert werden. Wenn man 32767 +1 rechnet erhält man die Zahl -32768. Wenn man -32768 - 1 rechnet erhält man die Zahl 32767. Das wird als Roll Over bezeichnet. Ein Integer benötigt 2 ^ 16 Bits oder 2 Bytes dadurch ergeben sich 65536 Kombinationen, die gleichmäßig auf positive und negative Zahlen aufgeteilt wurden.

Definition in der Arduino IDE:

int Name_der_Variable = 2956;

Long

Eine Variable vom Typ Long enthält auch Ganzzahlen, wie ein Integer, nur ist ein größerer Zahlenbereich verfügbar: von -2147483648 bis +2147483648. Ein Long benötigt 32 Bits/4 Bytes Speicherplatz

Definition in der Arduino IDE:

long Name_der_Variable = 29438;

Float

Variablen vom Datentyp Float sind Zahlen mit 6-7 möglichen Nachkommastellen. Dadurch kann man auch kleine Werte exakt berechnen. Der Zahlenbereich ist von -34028235 * 10^38 bis 34028235 * 10^38. Wichtig ist, dass man kein Komma, sondern einen Punkt stattdessen macht.

Definition in der Arduino IDE:

float Name_der_Variable = 34438.24;

Hinweis:

Viele Zahlenvariablen sind auch unsigned möglich. Das bedeutet, dass der mögliche Zahlenraum nicht auf positive und negative Zahlen aufgeteilt wird, sondern, dass alle Werte positiv sind. Dadurch können die Werte größer werden. Zusätzlich spart man sich ein Bit, das besagt ob die Zahl negativ oder positiv ist, was den Zahlenraum zusätzlich erweitert.

Char

Char ist ein Variablentyp, für Variabeln, die genau einen Buchstaben besitzen. So kann ein char den Buchstaben 'A' beinhalten. Hierbei wird zwischen einem 'a' und einem 'A' unterschieden. Der Buchstabe wird als eine Zahl gespeichert. Die Übersetzung erfolgt automatisch gemäß dieser Übersetzungstabelle. Ein Char benötigt bis zu 1 Byte Speicherplatz.

Definition in der Arduino IDE:

char Name_der_Variable = 'A';

String

Ein String ist nicht anderes als eine Zeichenkette. Hier kann man so viele Zeichen speichern wie man will, weshalb auch der Speicherbedarf variiert. 

Definition in der Arduino IDE:

String Name_der_Variable = "Hallo";

Wichtig ist hierbei zwischen zwei Arten von Strings zu unterscheiden. Dem String mit großem S, wie oben, und dem string mit kleinem s. Der string ist in der Arduino IDE einfach nur ein Array vom Datentyp char, bei dem jedes Element ein Zeichen enthält. Zusammen ergibt das dann die Zeichenkette. Der String, mit großem S, ist eine wirkliche Zeichenkette. Dieser benötigt zwar mehr Speicherplatz, dafür sind mit ihm aber auch mehr Operationen möglich, beispielsweise Suchen und Ersetzen.

Umwandeln von Datentypen

Manchmal ist es sinnvoll den Datentyp zu ändern. Beispielsweise, um eine Funktion mit einer Variable zu verwenden, wobei die Funktion den aktuellen Datentyp nicht akzeptiert. Dann muss man den Datentyp ändern. Das geht natürlich nur mit Datentypen, bei denen das sinnvoll ist. Beispielsweise kann man "Hallo" nicht in einen Integer umwandeln. Zusätzlich muss man die maximalen Größen einer Variable beachten. Wenn das Alles zutrifft kann man über diese Funktionen den Datentyp ändern:
  • char()
  • byte()
  • int()
  • long()
  • float()
Wenn ich, beispielsweise eine Zahl vom Typ Integer mit dem Wert 22 habe und sie in ein Byte umwandeln will, schreibt man:

byte Name_der_Variable = byte(Name_der_alten_Variable_mit_Typ_int);
Nun ist der Datentyp geändert. 




-C26- Eigene Bibliothek für den Arduino erstellen
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. 





-C27- Eigene Funktion für den Arduino definieren
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



-C28- Stand-by-Modus für den Arduino
In diesem Artikel geht es darum, welche verschiedenen Standy-by-Modi es für den Arduino gibt, und wie man sie verwendet. Dadurch verbraucht ein +Arduino  weniger Strom, wodurch ein längerer Batteriebetrieb möglich ist.

Die verschiedenen Stand-by Arten

Es gibt verschiedene Arten des Standy-by-Modus für den Arduino. Dadurch kann man dann Chips, beispielsweise für die USB/serial Kommunikation abstellen, oder eben nicht, wodurch sich zusätzlich Strom sparen lässt. Natürlich ist es auch möglich Funktionen einzeln abzustellen.
Vorneweg: Der Arduino (Uno) benötigt schon aufgrund seiner Power LED eine Menge Strom. Deshalb ist es sinnvolle die Schaltung erst mit dem Arduino auszuprobieren, und dann einen Mikrocontroller allein zu verwenden. Zusätzlich spart man sich Kosten, da das Arduinoboard mehr als der darin enthaltene Mikrocontroller kostet. 
  • SLEEP_MODE_IDLE
  • SLEEP_MODE_ADC
  • SLEEP_MODE_PWR_SAVE
  • SLEEP_MODE_STANDBY
  • SLEEP_MODE_PWR_DOWN
Das sind die fünf verschiedenen Standby Arten. Der IDLE Modus benötigt am meisten Strom, dafür funktioniert beispielsweise auch die serielle Kommunikation. Auch alle Interrupts werden unterstützt. Der Stromverbrauch wird dann bis zum PWR_DOWN Modus gedrosselt, wo nur einige Interrupts funktionieren. Diese sind auch dringend notwendig. Denn wie teilt man denn einem Mikrocontroller mit, dass er wieder aufwachen soll? Mit Interrupts!

Arduino in Stand-by-Modus schalten

Um den Arduino in einen SLEEP_MODE zu versetzen, sind ein paar Schritte und Bibliotheken notwendig. Zunächst einmal muss man sich entschieden, wie man den Arduino wieder aufwecken will. Das geht über die verschiedenen Interrupts. Also entweder über einen Button, über einen Timer, oder über einen Watchdoginterrupt. Theoretisch könnte man ihn auch über die serielle Verbindung aufwecken, wobei man in der Praxis selten einen PC angeschlossen haben wird, und wenn doch, dann  spielt der Stromverbrauch des Arduino sowieso keine Rolle, im Vergleich zu dem des PC. Ich werde im Folgenden exemplarisch das Blinken einer LED, sowie das Anschalten der LED, sobald ein Knopf gedrückt ist, mit einem Stand-by-Modus stromsparend realisieren.

Stand-by mit "Buttoninterrupt"

Am Anfang des Sketches muss man zwei Bibliotheken nachladen um die SLEEP_MODEs zu verwenden. Diese sind bereits mit der Arduino IDE mitinstalliert. Im Setupteil wird der Pin, an dem die LED angeschlossen ist, als OUTPUT definiert und der Interrupt an Pin 2 definiert. Im Loopteil wird die LED angeschaltet, drei Sekunden gewartet, und die LED wieder ausgeschaltet. Danach wird die Funktion enterSleep() aufgerufen. In dieser wird der Standbymodus gestartet. Sobald der Interrupt von Pin 2 ausgelöst wird, wird die Funktion des Interrupts aufgerufen. Nachdem diese leer ist, wird gleich die nächste Zeile ausgeführt. Das ist die Zeile in enterSleep(), die den Standbymodus deaktiviert. Dadurch landen wir dann wieder in der Hauptschleife, die die LED an und aus macht. Die LED ist an Pin 13 angeschlossen, und der Button an Pin 2, sowie den Ground und die 3.3V Spannung.

#include <avr/sleep.h>
#include <avr/power.h> //nachladen der benoetigen Bibliotheken
void setup() {
pinMode(13, OUTPUT); //definieren von Pin 13 als OUTPUT
attachInterrupt(0, interrupt, RISING); //festlegen des Interrupts an Pin 2

}

void loop() {
digitalWrite(13, HIGH);
delay(3000);
digitalWrite(13, LOW); //3 Sekunden LED leuchten
enterSleep(); //starten der enterSleep() Funktion
}

void interrupt() {
//leere Interruptfunktion
}

void enterSleep(){
set_sleep_mode(SLEEP_MODE_PWR_DOWN); //festlegen des Schlafmoduses
sleep_enable(); //ermoeglichen der angegebenen Schlaffunktion
sleep_mode(); //starten der Schlaffunktion
//hier geht es nach dem Interrupt weiter
sleep_disable(); //deaktivieren der Schlaffunktion
power_all_enable(); //reaktivieren aller Chips/Funktionen
}

view raw arduino_sleep_1 hosted with ❤ by GitHub

Stand-by mit Watchdoginterrupt

Mit einem Watchdoginterrupt lässt sich prima der Stand-by-Modus nach einer gewissen Zeit deaktivieren. Der Vorteil gegenüber dem Timer ist, dass der Watchdoginterrupt bis zu 8 Sekunden lang sein kann (Timer 4s). In diesem Fall wollen wir, dass eine LED alle 8 Sekunden ihren Status ändert, also sehr langsam blinkt. Dazu lassen wir bei jedem Programmneustart, verursacht durch den Watchdog, den Status ändern. Ein kleines Problem, dass aufgetreten ist, ist, dass der Watchdoginterrupt den Arduino neu startet. Dadurch ist die LED immer aus, weshalb sie immer auf HIGH gestellt wird. Ich habe das Problem gelöst, indem ich den aktuellen Status immer in den EEPROM schreibe. Dessen Inhalt bleibt auch ohne Strom bestehen. Genaues zur Verwendung des EEPROM. Der Sketch für diese Möglichkeit, den Arduino aus dem Stand-by-Modus zu holen, ist dieser:
#include <avr/sleep.h>
#include <avr/power.h>
#include <avr/wdt.h>
#include <EEPROM.h> //nachladen der Bibliotheken
int status_led = 0;

void setup() {
wdt_enable(WDTO_8S); //starten des Watchdoginterrupts
pinMode(13, OUTPUT); //definieren von Pin 13 als OUTPUT
}

void loop() {
status_led = EEPROM.read(10);
status_led = !status_led;
EEPROM.write(10, status_led); //auslesen des Status des EEPROM, umdrehen des Werts und abspeichern des neuen Werts
digitalWrite(13, status_led); //schalten der LED
enterSleep(); //senden des Arduino in den Schlafmodus
}

void enterSleep(){
set_sleep_mode(SLEEP_MODE_PWR_DOWN); //auswaehlen des Modus
sleep_enable(); //start des Schlafens ermoeglichen
sleep_mode(); //Stand-by-Modus starten
//hier geht es nach Wtchdoginterrupt weiter
sleep_disable(); //deaktivieren des Stand-by-Modus
power_all_enable(); //reaktivieren aller Funktionen
}

view raw arduino_sleep_2 hosted with ❤ by GitHub

Das sind zwei Möglichkeiten, wie man den Stand-by Modus mit dem Arduino verwendet.

Fragen und Anregungen einfach in die Kommentare schreiben.

Kommentare

  1. könntest du bitte diese Zeile erklären:

    attachInterrupt(0, interrupt, RISING); //festlegen des Interrupts an Pin 2

    Woher sehe ich das dies Pin 2 ist? Müsste es nicht Pin 0 sein?





-C29- Timerinterrupt und Watchdogtimer
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


Claus Kühnel

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.

michaelsarduino: Timerinterrupt und Watchdogtimer



-C31- Arduinos zusammenschalten über I2C
In diesem Artikel geht es darum, wie man mehrere Arduinos/Mikrocontroller zusammenschalten kann. Dadurch können einem nicht die Pins oder die Speicherkapazität ausgehen, da man theoretisch auch mehrere Dutzend zusammenschalten kann, da die Kommunikation jeweils nur 2 Kabel benötigt.


Zur Kommunikation zwischen Mikrocontrollern wurde in den 70er Jahren von Philips das I^2 Protokoll(sprich: I Quadrat C) entwickelt. Diese benötigt nur zwei Kabel zur Verbindung: SDA und SCL. Auf das SCL Kabel wird in regelmäßigen Abständen Spannung angelegt. Diese gibt den Takt an. Also jedes mal wenn die Spannung am SCL Pin auf HIGH gesetzt wird, wird die Spannung vom SDA, quasi dem Datenübertragungspin, genommen und gespeichert/weiterverarbeitet. Beim I^2C Protokoll gibt es einen oder mehrere Master und einen oder mehrere Slaves. Der Unterschied ist, dass ein Master immer senden kann und ein Slave nur, wenn der Master eine Anfrage gestartet hat. In unserem Beispiel wollen wir einfach einen Text versenden und ihn auf der seriellen Konsole ausgeben lassen. Deshalb muss der Mikrocontroller der Master sein und der Arduino der Slave.

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.


Diese sind jedoch exakt die selben, wie analog Pin 4 und 5. Man muss sich also für eine der beiden Optionen entscheiden und dann jeweils den SCL Pin mit dem SCL Pin und den SDA Pin mit dem SDA Pin von Master bzw. Slave verbinden. Zusätzlich brauchen die kommunizierenden Geräte einen gemeinsamen Ground. Man muss also noch die Grounds miteinander verbinden. Wenn man, wie ich, seinen Mikrocontroller über den Arduino mit Strom versorgt geschieht das ja automatisch. Der SDA Pin am ATmega328 ist Pin 27 und der SCL Pin ist Pin 28. Solltest du nicht wissen, wie man einen Mikrocontroller über den Arduino programmiert, beziehungsweise korrekt anschließt empfehle ich dir meinen Post dazu

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:


I2C ist eine gute Möglichkeit Geräte miteinander kommunizieren zu lassen, insbesondere, da die Kommunikation nur 2 Kabel/Pins benötigt. Man kann auch nicht nur Mikrocontroller kommunizieren lassen, sondern über I2C auch beispielsweise einen externen EEPROM(Speicher, dessen Inhalt auch ohne Strom gespeichert bleibt) ansteuern.





-C32- LED am Arduino über Website steuern
In diesem Tutorial geht es darum, wie man eine LED, angeschlossen an den Arduino, über eine Website steuern kann. Du musst dafür keinerlei zusätzliche Hardware kaufen, da der PC die Funktion des Webservers übernimmt.

Die allgemeine Funktionsweise

Wenn ein Benutzer die Website aufruft, die auf einem Apache Webserver auf dem PC gehostet ist, und einen Status auswählt, so wird 1 für an oder 0 für aus in eine Textdatei geschrieben. Ein kleiner Processing Sketch liest dann laufend den Inhalt der Textdatei aus, und sendet diesen dann über die serielle Verbindung an den Arduino. Dieser schaltet dann dementsprechend die LED. 

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.
Die LED muss dann mit dem kurzen Bein an der Ground(Minuspol) und dem langen  Bein an den gewählten digitalPin angeschlossen werden.

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

Ich habe die Website und das Speichern in die Textdatei in PHP gemacht. PHP ist eine Webprogrammiersprache. Damit diese Website auch im Webbrowser aufgerufen werden kann braucht man einen Webserver, quasi den Lieferanten der Website. Ich verwende Apache. Hier ist ein gutes Tutorial zur Installation unter Windows. Hinweis: Es reicht der Apache Webserver und PHP.
Nun müsst ihr nur noch das unten stehende PHP Programm in den htdocs Folder eures XAMPP Verzeichnisses kopieren.


<html>
<h1>Hier kannst du die LED des Arduino steuern.</h1>
<form action="arduino_webpage.php" method="POST">
<input type="radio" id="an" name="status" value="an" />an <br />
<input type="radio" id="aus" name="status" value="aus" />aus <br />
<input type="submit" value="schalten" />
</form>
<?php
if($_POST['status'] != "")
{
$status = $_POST['status'];
$handle = fopen('file.txt', "w");
if($status == "an")
{
$write = 1;
}
else {
$write = 0;
}
fwrite($handle, $write);
fclose($handle);
echo "Die LED wurde ";
echo $status;
echo " geschaltet!";
}
?>

</html>

arduino_webpage hosted with ❤ by GitHub


Das PHP Programm erklären würde hier zu lange dauern, wobei es bei genauerer Betrachtung logisch ist und es viele Tutorials zum Thema PHP und schreiben in eine Textdatei im Web gibt.

Das Ergebnis

Nun könnt ihr die Website aufrufen, indem ihr auf euerem PC localhost/namederdatei.php eintippt. Wenn ihr auf einem anderen Gerät in eurem WLAN Netzwerk seid müsst ihr IPdesPC/namederdatei.php eintippen. Wie ihr die IP Adresse eures PC herausfindet seht ihr am Ende von diesem Artikel. Diese Website kann nur von Geräten in eurem LAN/WLAN Netzwerk aufgerufen werden. Wenn ihr das auch über das Internet machen wollt, googlt nach Port Forwarding, wobei es dabei natürlich einige Risiken gibt. Wenn man nun die Website aufruft sieht das so aus:
Insgesamt ist das eine interessante Möglichkeit über Processing und PHP über das Internet eine LED am Arduino zu steuern. Wenn ihr mehr über Processing mit dem Arduino erfahren wollt, schaut euch auch die anderen Post auf diesem Blog dazu an.







-C33- Processing mit dem Arduino
Heute möchte ich euch die Programmiersprache Processing vorstellen und ihre Möglichkeiten in Bezug auf den Arduino erläutern.

Die Funktionsweise

Über Processing kann man entweder dem Arduino "live" Code senden, den er dann ausführt, oder man kann über Processing am PC ein Programm schreiben, das über die serielle Verbindung eine Verbindung zum Arduino hat. Natürlich ist Processing auch an sich eine coole Programmiersprache, die man unabhängig vom Arduino verwenden kann. Durch die Kommunikation mit dem Arduino und die Leistung eines PC kann man über Processing eine Menge toller Projekte realisiern, bei denen ein PC hilfreich sein kann.

Die Installation von Processing

Die Installation von Processing ist denkbar einfach. Man lädt es einfach von hier herunter, entpackt es und klickt auf "processing.exe". Dann sollte sich die Processing IDE öffnen:
Hier fällt sicherlich als erstes auf, dass sie eine immense Ähnlichkeit zu Arduino IDE aufweist, was den Anfang wirklich erheblich erleichtert.
Auch die Programmstrukturen sind ähnlich.

Die Verbindung zum Arduino

Als erstes muss man einen Bibliothek nachladen,ähnlich, wie beim Arduino, um die serielle Verbindung verwenden zu können. Das geschieht über Sketch > Import Library > serial. Dann sollte im "Schreibfenster" die Zeile import processing.serial.*; erscheinen. Anschließend müssen wir einen Partner für die serielle Verbindung der Klasse Serial definieren. Außerdem brauchen wir eine Variable vom Typ String, wo die gesendeten Texte des Arduino gespeichert werden. 

Der zweite Abschnitt eines Processing Programms ist der Setupteil, genauso, wie beim Arduino. Dort muss man eine Variable Port erstellen, in der die "Verbindungsdaten über die Funktion Serial.list()[0]; gespeichert werden. Wenn bei euch später nichts erscheinen sollte, ist euer Arduino an einem anderen COM Port angeschlossen. Diesen müsst ihr dann in den eckigen Klammern angeben. Jetzt erst stellen wir die eigentliche Verbindung zu "arduino" her. Dazu erstellt man das Objekt vom Typ Serial mit dem zuvor definierten Port(Verbindungsdaten) und der Datenrate. Außerdem muss man this als erstes Argument eintippen(fragt mich nicht wieso:) ).

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

Durch die Verbindung über Processing könnt ihr alle mit dem Arduino gesammelten Daten, wie Temperatur, Bewegung, Entfernung oder Sonstiges am PC weiterverarbeiten. Dadurch kann man die Möglichkeiten eines Arduino Projekts deutlich erweitern und auch deutlich komplexere Berechnungen durchführen, oder aber auch das Internet miteinbeziehen. Da die Programmiersprache Processing mit dem Arduino eine interessante Mischung ergibt, wird es sicherlich noch den ein oder anderen Artikel von mir dazu geben.






-C34- Serielle Verbindung zwischen PC und Arduino
Manchmal ist es prakisch, dass man sein Arduinosketch auch vom PC steuern/überwachen kann. Dazu verwendet man eine serielle Verbindung. Diese sendet dann Daten über das USB Kabel.

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?






-C35- Die verschiedenen Arduino Versionen und ihre Unterschiede
Heute möchte ich euch ein paar der vielen verschiedenen Arduinos vorstellen, da es mittlerweile schon sehr viele gibt und man dadurch leicht den Überblick verliert.

Der Arduino Uno (r3)

Den Arduino Uno  gibt es mittlerweile schon in der 3 Auflage. Er stellt so etwas, wie den "Standard Arduino" dar. Er besitzt einen soliden ATmega328 Mikrocontroller und lässt sich leicht über die USB Buchse mit dem PC verbinden. Er verfügt über 32KByte Flasch Speicher, was durchaus ordentlich ist. Er besitzt insgesamt 20 Pins(14 digital Inputs/Outputs und 6 analoge Eingänge), wodurch sich schon etwas größere Projekte realisieren lassen.

Der Arduino Leonardo


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

Die Besonderheit des Arduino Mega2560 ist, dass er mega groß, bezogen auf die Pinanzahl, ist. Er besitzt nämlich 54 digital Inputs/Outputs und 16 analoge Pins. Um all diese zu verwalten, hat er einen größeren Mikrocontroller, den ATmega2560, der fest verbaut ist. Dieser besitzt auch ordentlich Speicher(256KB Flash, 8KB SRAM und 4 KB EEPROM). Durch diese Dimensionen, kann man mit dem Arduino Mega2560 auch große Projekte, die viel Pins benötigen, realisieren.
Mega 2560.

Der Arduino Nano

Der Arduino Nano ist, wenn man so will, das Gegenstück zum Arduino Mega. Er ist auf seine möglichst kleine Bauform getrimmt, wobei man jedoch wie beim Uno einen ATmega328 verbaut. Dieser ist fest verbaut. Durch den ATmega328 hat man genauso viele Pins, wie beim Arduino Uno, wobei diese nach unten raus stehen, um den Arduino Nano leicht in ein Breadboard verbauen zu können.





Der Arduino Robot(eigentlich zwei)

Der Arduino Robot(hier auf Amazon.de) ist ein Vertreter der runden Arduinos, ein besonders Cooler noch dazu. Er besteht eigentlich aus zwei Boards, dem Motor Board, das die beiden Motoren steuert und mit dem Control Board kommuniziert, das Sensorwerte oder Ähnliches ermittelt. Gemeinsam ergeben diese beiden Boards einen fahrenden Arduino Roboter. Dieser kann/muss über 4 AA Batterien mit Strom versorgt werden.


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





Ich hoffe ich konnte euch die (wichtigsten) Arduinos vorstellen. Es gibt natürlich noch ein paar Weitere, wobei diese oft Abwandlungen eines der hier vorgestellten Arduinosboards sind. Außerdem gibt es natürlich noch die Arduinokopien von diversen anderen Herstellern, die mehr oder minder kompatibel sind, dafür natürlich aber auch etwas billiger. Abschließend bleibt es mir noch zu fragen:

Welchen Arduino findet ihr am coolsten und welchen werdet ihr euch als nächstes kaufen? 



-C36- Die Festplatte eines Mikrocontrollers - Der EEPROM
EEPROM steht für Electrically Erasable Programmable Read-Only Memory(Wikipedia). Die Besonderheit des EEPROM ist, dass dessen Inhalt auch noch gespeichert bleibt, wenn die Stromzufuhr unterbrochen wurde, ähnlich wie die Festplatte eines Computers.

Der EEPROM befindet sich in eurem jeweiligen Mikrocontroller bereits integriert. Der ATmega328, der Mikrocontroller des Arduino Uno, besitzt einen EEPROM mit 1024 Bytes Speicherkapazität. Das bedeutet, er kann 1024 verschiedene Zahlen zwischen 0 und 255 speichern. Um nun etwas in den EEPROM zu schreiben, verwendet man die Bibliothek EEPROM.h, die schon mit der Arduino IDE installiert wurde. Sie muss man über #include nachladen. Um nun einen Wert zu schreiben, muss man die Funktion write aus der EEPROM Bibliothek verwenden. Diese braucht als Argumente(Werte in den Klammern) die Speicheradresse und die zu schreibende Zahl. Die Speicheradresse ist der Speicherort der Information. Das ist notwendig, damit man später beim auslesen die richtige Information ausliest. Sie ist einfach eine Zahl zwischen 0 und 1024, da der ATmega328 einen EEPROM mit 1024 Byte Speicherkapazität hat.

EEPROM_write


Um die Zahl einer Speicheradresse auszulesen, kann man die Funktion EEPROM.read(Speicheradresse) verwenden. Ein Sketch zum auslesen der oben geschriebenen Wertes sähe so aus:

EEPROM_read

Der EEPROM ist also wie eine Art Festplatte des Arduino, um Daten dauerhaft zu speichern. Abschließend ist noch zu sagen, dass es auch externe EEPROMs für den Arduino gibt. 

Welche Anwendungen könnt ihr euch vorstellen, wo ihr den EEPROM verwenden werdet?




-C37- Entfernung messen mit einem Ultraschallsensor
Heute klingelte bei mir mal wieder der Postbote und brachte mir den Ultraschallsensor HC-SR04 . Ein Ultraschallsensor ist ein Sensor der einen Ton ausgibt (im Ultraschallbereich hört man ihn nicht) und schaut wie lange es dauert, bis der Ton wieder ankommt. Aus dieser Zeit kann er dann die Entfernung berechnen.

http://www.micropik.com/PDF/HCSR04.pdf




HC-SR04
Um ihn mal zu testen können wir einfach ein kleines Programm schreiben, dass eine Näherungsmeldung ausgibt, wenn ein Objekt sagen wir mal näher als 30cm ist.

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

Der Ultraschallsensor hat zwei Datenpins, wobei der Trig Pin dem Sensor mitteilt, dass dieser nun messen soll und der Echo Pin dem Arduino mitteilt wie lange der Schall vom Sensor weg und wieder zurück braucht. Damit der Sensor misst muss die Spannung am Trig Pin für 5 Mikrosekunden auf HIGH sein. Wenn man nun die Zeit misst, wie lange die Spannung am Echo Pin HIGH ist, so weiß man die Zeit die der Schall braucht. Zum Messen dieser Zeit gibt es die Funktion pulseIn(PIN, ZUSTAND);. Diese Funktion wartet bis der Pin auf den definierten Zustand geht und zählt die Zeit bis er ihn wieder ändert in Mikrosekunden. Wir können uns diesen Wert über die serielle Verbindung(siehe letzter Post: hier) ausgeben lassen. Der Sketch sieht dann so aus.


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.








Das Ergebnis ist dann, das ab 30 cm Entfernung oder niedriger die LED blinkt. Kurzes Video zur Demonstration:


michaelsarduino: Entfernung messen mit einem Ultraschallsensor







-C38- Musik mit dem Arduino
Heute wollen wir Musik mit dem Arduino machen. Dazu benötigt man 8 Ohm Lautsprecher . Gut geeignet sind . Diese sind auch sehr günstig.
Sie besitzen lediglich zwei Anschlüsse einen Plus- und einen Minuspol. Diesen können jedoch auch vertauscht werden. Der Minuspol wird an den Ground des Arduino angeschlossen und der Pluspol an einen digital Pin. Ich habe Pin 8 verwendet.

Um Töne am Arduino auszugeben gibt es die Funktion tone(Pin, Frequenz, Dauer);. Da man jedoch nicht für jeden Ton auswendig die Frequenz weiß gibt es eine Art Sammlung aller Töne mit ihren Frequenzen, die ihr hier findet. Nun müsst ihr euch noch eine Tonfolge überlegen, die ihr wiedergeben wollt und die dazugehörigen Noten herausfinden. Ich habe mal den Telekom Jingle genomme(nein ich kriege hierfür kein Geld von der Telekom ;)). Dieser hat die Noten C,C,C,E,C. Da es ja verschieden hohe C bzw. E gibt hat jedes Ton beim Arduino in der Definition eine Nummer, die besagt um welches C es sich handelt. Durch die Funktion noTone(Pin); wird die Wiedergabe des aktuellen Tons gestoppt. Ein Sketch der den Jingle abspielt sieht dann so aus: (die Definitionen der Töne die ich oben verlinkt habe einfach ganz am Anfang des Programms einfügen.

t_ne.ino


Das Ergebnis ist dann (fast :)) der Telekom Jingle:
Auf diese Art und Weise kann man viele verschiedene Melodien schreiben. Man kann sogar mit genügend Buttons sein eigenes Piano machen. Viel Spaß beim ausprobieren!
Werdet ihr ein Piano bauen?




-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

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:








Quelle:
https://plus.google.com/110786353506245861399




DIN A4  ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE









Untergeordnete Seiten (2): Michael Bonacia michaelsarduino
Comments