Microcontroller

Programming with Arduino platform

Arduino is a microcontroller family that you can program in C/C++ with an open source software using an serial USB port. It provides analog digital on/off input and output, reading of voltages, anolog output by Pulse Width Modulation (PWM) which is useful for controling motors, serial communication which is useful for communicating with sensors and other external devices. I am using an arduino mega controller board with an Atmel processor 2560, it has much more flash memory and i/o pins than an arduino uno.

Hardware

Microcontroller ATmega2560
Operating Voltage 5V
Input Voltage 7-12V
Input Voltage (limits) 6-20V
Digital I/O Pins 54 (15 provide PWM output)
Analog Input Pins 16
DC Current per I/O Pin 40 mA
DC Current for 3.3V Pin 50 mA
Flash Memory 256 KB
SRAM 8 KB
EEPROM 4 KB
Clock Speed 16 MHz
Datasheet
Software

A lot of informations you can find on
Arduino.cc
Arduinoforum.de
Funduino.de


The programming language for Arduino is a subset of C. In this respect, persons who are familiar with C programming should have no difficulty. In contrast to the typical C program, however, the main () function is missing. It is replaced by two functions: void setup () is executed when the program starts and contains all initializations required by the program, e.g. the definition of the data direction for I / O ports, etc. void loop () is an endless loop in which all commands and functions are done download

Here is a simple program code for blinking a LED:

int led = 13; // Pin 13 has an LED connected on most Arduino boards.

void setup() { // the setup routine runs once when you press reset:
pinMode(led, OUTPUT); // initialize the digital pin as an output.
}
void loop() { // the loop routine runs over and over again forever:
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}


This program above uses the onboard LED on port 13.
If you use a LED e.g. on port 5 you have to use a pre-resistor with ~200 Ohm.
By using the PWM you are also able to dim the LED. Therefore you can use the analogwrite() command on a digital port. This digital PWM ports are marked with ~.


int LED=5;
int helligkeit= 0;
int fadeschritte= 5;
void setup()
{
pinMode(LED, OUTPUT);
}
void loop()
{
analogWrite(LED, helligkeit);
helligkeit = helligkeit + fadeschritte;
delay(25);
if (helligkeit == 0 || helligkeit == 255) {
fadeschritte = -fadeschritte ;
}
}


Bei Fragen rund um das Programm, aber auch für Anregungen und Verbesserungen stehe ich natürlich mit Support und Hilfe immer zur Verfügung.
Über das Kontaktformular bin ich jederzeit erreichbar.

I can be reached at any time via the contact form .

Hier ein paar Infos auf deutsch

1 Programmierung des Arduino´s
Die Programmierung erfolgt wie schon beschrieben in C bzw. C++. Eine detaillierte Erklärung gibt´s unter arduino.cc .
1.1 Sketch
Das eigentliche Programm wird Sketch bezeichnet. Es besteht immer aus zwei Funktionen: setup und loop. Setup wird einmal ausgeführt und dient zur Deklarationen von Variablen. Loop ist eine endlos-Schleife. Sie wird nach jedem Durchlauf wieder von vorne aufgerufen. void setup() { // wird einmal ausgeführt } void loop() { // Endlos-Schleife }

1.2 Digital I/O
Im Setup wird z.B. definiert, welcher Pin als Eingang und welcher als Ausgang dient. int val = 0; void setup() { pinMode(13, OUTPUT); // setzt den Pin 13 als Ausgang pinMode(12, INPUT); // setzt den Pin 12 als Eingang } void loop() { val = digitalRead(12); // einlesen des Digitalen Wert digitalWrite(13, val); // setzt den Ausgang 13 auf HIGH (+5V), wenn an PIN 12 ebenfalls +5V anliegen delay(1000); // eine Sekunde warten digitalWrite(13, LOW); // schaltet den Ausgang 13 wieder auf LOW (0V) }

1.3 Analog I/O
Für die analogen Pins gilt das gleiche, wie bei den digitalen Pins. Bei analogWrite wird der Wert in ein Rechtecksignal umgewandelt, dass im Mittelwert dem gewünschten analogen Wert entspricht (PWM mit ca. 490 Hz) void setup() { pinMode(9, OUTPUT); // Pin 9 unterstützt analogWrite(), d.h. Ausgabewerte von 0-255 möglich } void loop() { int val = analogRead(3); // Potentiometer einlesen, d.h. Werte von 0-1023 sind bei 10bit Auflösung möglich val = map(val, 0, 1023, 0, 255); // val muss von 0-1023 auf 0-255 angepasst werden, für die Analog Ausgabe analogWrite(9, val); }

1.4 Zeit
Für die Zeitgebung und die Verzögerung gibt es bereits fertige Funktionen. // 1 s = 1 000 ms = 1 000 000 us t = millis(); // gibt die Millisekunden zurück seit der Mikrocontroller läuft. t = micros(); // gibt die Zeit in Mikrosekunden zurück. Die Auflösung beträgt 4 us bei 16MHz delay(t); // verzögert das Programm um t ms delayMicroseconds(t); // verzögert um t us

1.5 Kommunikation

Die Kommunikation mit dem Arduino erfolgt meist über einen seriellen Port. Zum einen wird der Arduino darüber programmiert, zum anderen kann man auch mit ihm kommunizieren. Zum Beispiel Sensorwerte auslesen und direkt anzeigen. Um dies zu machen muss man zuerst den Serial Monitor aktivieren und die richtige Baudrate auswählen. Weitere Funktionen sind hier beschrieben. void setup() { Serial.begin(9600); // Neue Kommunikation einrichten mit einer Baudrate von 9600 } void loop() { Serial.println(analogRead(0)); // den analogen Pin 0 einlesen und auf dem Serial Monitor Fenster ausgeben delay(100); // verzögerung von 100 ms }

1.6 Mathem. Funktionen
In der Standard Bibliothek gibt es ebenfalls bereits vorhandene mathematische Funktionen.
minX = min(x1, x2); // bestimmt die kleinere Zahl maxX = max(x1, x2); // bestimmt die größere zahl x = abs(a); // berechnet den Absolutwert value= map(value, fromLow, fromHigh, toLow, toHigh); // Wertebereich wird angepasst a = pow(base, exponent); // berechnet die Potenz einer Zahl a = sqrt(x); // berechnet die Wurzel a = sin(a); // berechnet den Sinus (Radiant) randomSeed(analogRead(0)); // Den Zufallsgenerator abhängig von einem Eingang machen. Der Funktionsaufruf muss im setup erfolgen x = random(300); // eine Zufallszahl zwischen 0 und 299 generieren x = random(10, 100); // Zufallszahl liegt zwischen 10 und 99);

1.7 Arrays
In einem Array werden Daten gleichen Datentyps zusammengefasst. int x[3]; // Deklaration x[0] = 1; // 1. Element x[1] = 2; // 2. Element x[2] = 3; // 3. Element int y[3] = {1, 2, 3}; // Kann auch bei der Deklaration festgelegt werden for(int i = 0; i < 3; i++) // array durchlaufen x[i] = y[i]; // Element muss existieren!

1.8 Strings
Ein String kann auch als char-Array bezeichnet werden.
char str1[5] = {’T’, ’e’, ’s’, ’t’, ’\0’}; // \0 beendet den String char str2[] = "Test"; // nach der Deklaration ist das Array 5 lang char str3[5] = "Test"; char str4[15] = "Test"; // platz halten für einen größeren String

1.9 Konstanten
Es gibt Konstanten mit Variablennamen. Dabei wird eine Variable zusätzlich mit dem Schlüsselwort const gekennzeichnet, so kann sie später im Programm nicht mehr verändert werden. Es gibt auch symbolische Konstanten. Hier wird zu Beginn ein Name festgelegt, der später beim Kompilieren durch den dazugehörigen Wert ersetzt wird. // Symbolische Konstanten #define NL ’\n’ #define Number 5 #define Hello "Hello World\n" //Konstanten mir Variablennamen const int N = 5;

2 Arithmetische Operatoren
Zu jeder arithmetischen Operation gibt es auch eine Kurzschreibweise, führt aber zu schlecht lesbarem Code.
a = a + b; // Addition a += b; a = a - b; // Subtraktion a -=b; a = a * b; // Multiplikation a *=b; a = a / b; // Division (Vorsicht bei Integer) a /=b; a = a % b; // Modulo (Rest bei Division) a %= b;

2.1 Vergleichsoperatoren
Alle Operationen geben true oder false zurück.
int a = 3, b = 6; a < b; // a kleiner b a <= b; // a kleiner gleich b a > b; // a größer b a >= b; // a größer gleich b a == b; // a gleich b (Vorsicht bei Gleitkommazahlen) a != b; // a ungleich b (Vorsicht bei Gleitkommazahlen) if(a == b) // wenn erfüllt { //..dann tue das }

2.2 Logische Operatoren
Alle Operationen geben true oder false zurück.
bool a = true; a = !a; // jetzt hat a den wert false a = a && true // logisches UND a = a || true // logisches ODER

2.3 Verzweigung
Es wird überprüft, ob eine Bedingung erfüllt ist. Je nach dem wird ein anderer Code ausgeführt.
bool a = true; if(a == true) { // wenn a == true } else { // wenn a == false } int c = (a > b) ? a : b // Kurzschreibweise ist aber offiziell ein Ternärer Operator

2.4 for-Schleife
Der Code im Block wird eine bestimmte Anzahl durchlaufen. Auf die Zählvariable kann innerhalb des Blocks zugegriffen werden.
for(int i=0; i<10; i++) { // dieser Code wird 10 mal ausgeführt }

2.5 while-Schleife
Der Code innerhalb des Blocks wird solange ausgeführt, wie die Bedingung im Kopf erfüllt ist. while(a == true) { // dieser Code wird solange ausgeführt wie a gleich true ist }

2.6 do-while-Schleife
Dies ist die fußgesteuerte while-Schleife. Sie funktioniert wie die normale while-Schleife nur, dass die Bedingung am Schluss kommt. Der Vorteil ist, dass der Code unabhängig von der Bedingung mindestens einmal ausgeführt wird.
do { // dieser Code wird mindestens einmal ausgeführt } while(a == true);

2.7 break and continue
Diese beiden Anweisungen werden im Zusammenhang mit Schleifen verwendet. Vorsicht bei der Anwendung. break: der Aufruf dieser Anweisung beendet die gesamte Schleife. continue: Der Aufruf beendet nur den aktuellen Durchlauf an dieser Stelle und setzt die Codeausführung an dem Schleifenkopf fort. int i = 0; for(;;) { i++; // i um 1 hochzählen if(i % 2 == 0) // alle geraden Zahlen überspringen continue; // den Rest vom Programmteil überspringen und beim Schleifen Kopf starten if(i>1000) // nach 1000 durchläufen Schleife beenden break; }

2.8 switch-Anweisung
Falls man einen Wert einer Variablen auf verschiedene Werte überprüfen möchte, ist die switch-Anweisung geeignet.
int n = 7; switch(n) { case 3: // falls n gleich 3 ist break; // die Anweisung break beendet die switch-Anweisung case 7: // falls n gleich 7 ist break; default: // Falls es auf kein Fall zu trifft break; }

3 Funktionen
Wenn Programmabschnitte meist öfter als einmal benötigt werden, oder einfach nur der übersichtlichkeit halber, bietet sich eine Funktion an. Sie besteht aus dem Datentyp, welchen sie zurückgibt, dem Namen und der übergabeparameter. Doch zuerst muss man sie, wie auch bei den Variablen, bekannt geben. int add(int a, int b); // Deklaration der Funktion meist außerhalb in einem Header File int add(int a, int b) // Definition der Funktion { return (a + b); } int c = add(1, 2); // Aufruf der Funktion