Arduino
Befehle sind Anweisungen, die Methoden in der Arduino-Software aufrufen.
pinMode()
Der Befehl pinMode(Pin, Modus) deklariert einen digitalen Kanal auf dem Arduino-Board entweder als Eingang (INPUT) oder Ausgang (OUTPUT). Er bekommt als zusätzliche Informationen den Pin (Kanal) und die Funktion.
pinMode(3,OUTPUT); // setzt den digitalen Kanal 3 als Ausgang<strong></strong>
digitalWrite()
Der Befehl digitalWrite(Pin, Wert) schaltet einen, zuvor mit pinMode() als OUTPUT deklarierten, digitalen Kanal auf HIGH (5V+) oder LOW (GND). digitalWrite(3,HIGH); // schaltet 5V+ auf den digitalen Kanal 3
digitalRead()
Der Befehl digitalRead(Pin) liest ein digitales Signal am Übergebenen digitalen Kanal aus. Der Kanal muss vorher als INPUT deklariert worden sein. digitalRead(4); // liefert HIGH oder LOW
analogWrite()
Der Befehl analogWrite(Pin, Wert) setzt eine Spannung auf einen PWM-Kanal (digitale Kanäle mit PWM gekennzeichnet: 3, 5, 6, 9, 10, 11). Die Spannung wird als Wert zwischen 0 (GND) und 255 (5V+) übergeben. analogWrite(3,200); // am digitalen Kanal 3 werden 4V+ angelegt
analogRead()
Der Befehl analogRead(Pin) liest das anliegende Signal am übergebenen analogen Input ein. Digitale Kanäle können dafür nicht verwendet werden. analogRead(1); // liefert den anliegenden Wert vom analogen Kanal 1
delay()
Der Befehl delay(Wert) verzögert den Programmablauf um den Wert in Millisekunden. delay(1000); // der Programmablauf wird eine Sekunde verzögert<strong></strong>
Serial.begin()
Der Befehl Serial.begin(Baudrate) startet die serielle Kommunikation zwischen dem Arduino-Board und dem Computer. Auslesen kann man die Daten z.B. im seriellen Monitor der Arduino-Software. Die möglichen Baudraten sind standardisiert: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, und 115200. Der Befehl muss im void setup() ausgeführt werden. void setup(){ Serial.begin(9600); // startet die Datenübertragung mit 9600 Baud}
Serial.println()
Der Befehl Serial.println(Daten) sendet Daten über die serielle Schnittstelle. Man kann sie mit dem seriellen Monitor anzeigen lassen. Serial.println(analogRead(1)); // sendet den analogen Wert am Kanal 1 an den Computer
Aufgabe und passender Befehl
Oft ist es so, dass man plötzlich vergisst, wie man jetzt gerade in dieser Programmiersprache einen benötigten Befehl formulieren muss. Deswegen hier zum nachschlagen eine Auflistung der wichtigsten Befehle.
| Befehl | Schreibweise |
| Grundlegendes | |
| Grundstruktur | void setup() { }void loop() { } |
| Variable deklarieren (Typ Integer, Wert = 0) | int led = 0; |
| Konstante deklarieren (Typ Integer, Wert = A0) | const int analogInPin = A0; |
| Array deklarieren (Typ Integer, 6 Werte) | int Arrayname[6] = {2, 4, -8, 3, 2}; |
| Pin-Funktion festlegen | pinMode(led, OUTPUT); |
| Library einbinden | #include <libX.h> |
| Ausgaben/Eigaben | |
| Pin auf HIGH schalten | digitalWrite(led,HIGH); |
| PWM-Pin auf maximal Wert setzen | analogWrite(led, 255); |
| Digitalen Zustand von Pin schalter lesen | digitalRead(schalter) |
| Funktion: Analog Pin A0 auslesen | analogRead(A0) |
| Ton Ausgabe an Pin8, Frequenz x, länge y | tone(8, x, y) |
| Ton Ausgabe an Pin8 stoppen | noTone(8) |
| Serielle Schnittstelle | |
| Serielle Schnittstelle initialisieren | Serial.begin(9600); |
| Text seriell Ausgeben | Serial.print(“Hallo”); |
| Text seriell Ausgeben + neue Zeile | Serial.println(“Hallo”); |
| Byte seriell Ausgeben | Serial.write(val) |
| Funktion: Anzahl von auslesbaren Bytes | Serial.available() |
| Funktion: seriell Einlesen | Serial.read(); |
| Funktion: Text im Buffer finden (true/false) | Serial.find(„TEXT“) |
| Funktion: Text i. Buffer finden bis Endetext | Serial.findUntil(“TEXT“,“ENDE TEXT“) |
| Speichert Anzahl Bytes in Buffer | Serial.readBytes(buffer, length) |
| Speichert Bytes in Buffern bis lenght oder Ende-chracter erreicht | Serial.readBytesUntil(character, buffer, length) |
| Funktion: Findet nächste Integerzahl | Serial.parseInt() |
| Prozedur aufgerufen wenn Daten vorhanden | void serialEvent() |
| Abfragen/Schleifen | |
| If-Abfrage mit Else | if (button == HIGH){ }else{ } |
| Switch-Abfrage | switch (x) { case 1: case 2: default: |
| Wartezeit (500 ms) | delay(500); |
| For-Schleife | for (x = 2; x < 7; x++) { } |
| While-Schleife | while (schalter== HIGH) { }ODER: do{} while (schalter==HIGH); |
| Schleife vorzeitig verlassen | break; |
| Überspringt ausführbaren Quelltext in Schleife | continue; |
| Mathematisches | |
| Sinus, Cosinus, Tangens | sin(),cos(),tan() |
| Wurzel aus X | sqrt(x) |
| X hoch Y : xy | pow(x, y) |
| Absolut Wert einer Zahl (Betrag von x) | abs(x) |
| Zufällige Zahl | random() |
| Vergleiche | |
| gleich | == |
| ungleich | != |
| größer, kleiner | <, > |
| Größer oder gleich, kleiner oder gleich | <= , >= |
| Funktion: kleinere Zahl von x und y | min(x, y) |
| Funktion: größere Zahl von x und y | max(x, y) |
| Boolsche Operatoren | |
| Und | && |
| Oder | || |
| Nicht | ! |
| Datentypen | Boolean; char; unsigned char; byte; int; unsigned int; word; long; unsigned long; short; float; double; string; String; |
| Datentypkonvertierungen | char(); byte(); int(); word(); long(); float() |
| Interrupts | |
| Interrupts verbieten | noInterrupts() |
| Interrupts erlauben | nterrupts() |
| Interrupt an Pin mit Funktion verknüpfen | attachInterrupt(interrupt, function, mode) |
| Interrupt Verbindung aufheben | detachInterrupt(interrupt) |
| Sonstiges | |
| Kommentar eine Zeile | // |
| Kommentar längerer Bereich | /* */ |
| Array definieren | |
| Funktion: Wertebereich transformieren (z.B. 10bit Sensor auf 8bit PWM) | map(sensorWert, 0, 1024, 0, 255); |
| Funktion Wertgrenzen bestimmen(alles darüber/darunter wird abgeschnitten) | constrain(sensorWert, 0, 255); |
| Bein Funktionen: Wert zurückgeben | return x; |
| Zum Sprungpunk hier springen | goto hier; |
| Prozedur | Void Prozedurname() { } |
| Funktion mit Integer-Rückgabewert und Byte-Parameter | int Funktionsname (byte Parameter) {return 13;} |
Die Digitalelektronik basiert auf abgestuften Werten (diskrete Werte), die üblicherweise durch unterschiedliche Spannungen definiert werden.
Elektronisch am einfachsten umzusetzen und damit am häufigsten zu finden, ist die Abstufung in zwei Werten. Damit kann das Dualsystem direkt auf eine „elektronische Ebene“ abgebildet werden. Die beiden Werte werden durch zwei unterschiedliche Spannungen definiert. Die Spannungen hängen von der Technologie ab, mit welcher gearbeitet wird.
Die erlaubten Spannungsbereiche werden als High (hohe Spannung) H, bzw. als Low (niedrige Spannung) L bezeichnet.
Die Spannungspegel hängen von der verwendeten Technologie ab. Um die Verlustleistung bei hohen Frequenzen zu verringern, ist man bestrebt, mit möglichst geringen Spannungen zu arbeiten. Bei Microcontrollern werden 5V und 3,3V am häufigsten verwendet.
Achtung! Wer einen Eingang eines 3,3V Mikrocontrollers (z.B. Raspberry pi) an den Ausgang eines 5V Mikrocontrollers (z.B. Arduino) anschließt, riskiert mit ziemlicher Sicherheit die Zerstörung des 3,3V Mikrocontrollers!