00 Der Mikrocontroller

Was ist ein Mikrocontroller?

Ein Mikrocontroller (auch MCU oder µC) ist ein elektronisches Halbleiterelement, welches auf einem einzigen Chip mehrere Elemente, wie eine CPU, eine Uhr, Timer, I/O Ports und Speicher zur Verfügung stellt. Mikrocontroller werden heute in vielfältiger Art und Weise eingesetzt. Elektronische Produkte besitzen fast immer einen Mikrocontroller, welcher für die "Logik" der Produkte verantwortlich ist. Dabei verarbeitet er Eingaben von Sensoren und reagiert in dem er die Stellung oder Anzeige von Aktuatoren verändert. Eine Besonderheit von Mikrocontrollern ist es, dass sch die Logik durch Programmierung verändern lässt. In diesem Workshop werden wir Arduino benutzen – eine Mikrocontroller Plattform welche am Interaction Design Institute Ivrea speziell für Interaction Design Studenten entwickelt wurde. Arduino besteht aus einem Mikrocontroller Board, sowie einer eigenen Integrierten Entwicklungsumgebung (IDE) welche es möglich macht, das Board via USB zu programmieren. Hier gibt es eine Dokumentation zur Entstehungsgeschichte und Bedeutung des Arduino

Elektronische Grundlagen

Um Mikrocontroller erfolgreich für Projekte einsetzen zu können ist es unumgänglich einige elektronische Begriffe, Grundlagen und Gesetze zu beachten. Dazu zählen: Schaltkreis: Ein Schaltkreis ist eine Aneinanderreihung von elektronischen Komponenten. Elektronen: Elektronen sind negativ geladene Elementarteilchen welche die Eigenschaft besitzen, sich mit positiv geladenen Teilchen (Protonen) zu auszugleichen, dass ein Gleichgewicht (gleiche Anzahl von Elektronen und Protonen) entsteht. Diese Eigenschaft lässt sich in elektrisch leitfähigen Materialien gezielt nutzen. Strom (gemessen in Ampere): Der Strom bezeichnet die Wanderung von Elektronen von einem Atom zum nächsten. Je höher die Anzahl der Elektronen, desto höher der Strom. Spannung (gemessen in Volt): Spannung bezeichnet die Stärke, mit welcher die Elektronen in eine bestimmte Richtung "fliessen". Es gibt dabei sowohl positive, wie auch negative Spannungen. Widerstand (gemessen in Ohm): Widerstand bezeichnet die Eigenschaft von Materialien den Elektronenfluss gut oder weniger gut zu ermöglichen. Durch den Widerstand lässt sich also der Elektronenfluss auch beeinflussen. Ohmsches Gesetz (U = R x I): Das Ohmsche Gesetz bezeichnet den Zusammenhang von Strom (I), Spannung (U) und Widerstand (R). Gleichstrom: Gleichstrom bezeichnet einen elektronischen Strom, welcher sich nicht in Richtung und Stärke verändert. Wechselstrom: Wechselstrom ist ein elektrischer Strom, welcher seine Richtung (Polung) in regelmässigen Abständen wechselt. Zu Wechselstrom zählt z.B. auch der mit ca. 50Hz schwingende Strom aus der Steckdose. !!! ACHTUNG: AUF KEINEN FALL WERDEN WIR DEN WECHSELSTROM AUS DER STECKDOSE VERWENDEN !!!

Gefahren

- Wenn an einer Schaltung gearbeitet wird, dann vorher die Spannungsversorgung unterbrechen! - Schon kleine Ströme (z.B. aus einer Batterie) können ausreichen einen Menschen zu töten! - Wir verwenden nur Spannungen bis 12V, niemals darüber! - Bei der Verwendung von Lötkolben ist besondere Vorsicht geboten!

Übersicht über C/C++

Für Arduino werden wir in C/C++ programmieren. Da Arduino auf Processing aufbaut sieht die Oberfläche und die Syntax beider Programme sehr ähnlich aus. Es gibt jedoch einige Unterschiede, welche wir im Laufe des Workshops beleuchten werden. Ihr solltet schon über einige Grundkenntnisse der Programmierung verfügen. Trotzdem gibt es hier eine kleine Wiederholung. Eine Komplette Referenz für Arduino erhaltet ihr hier.

Übersicht:

// Hier werden globale Variablen deklariert

void setup()
{
  // Die Setup Funktion wird genau einmal am Anfang ausgeführt
}

void loop()
{
  // Die Funktion Loop wird permanent ausgeführt
}

Variablen:

int (byte, int, uint, long, ulong) Ganzzahlige Variablen z.B. int x = 22; float (double) Fliesskomma Variablen z.B. int y = 1.234; char Zeichen z.B. char z = "a"; String Abfolgen von Zeichen z.B. String testString = "Arduino"; boolean Schaltvariable z.B. boolean state = false;

Operatoren:

Arithmetische Operatoren (+,-,*,/,=,%) x = 3+2; // x = 5 y = 2-1; // y = 1 z = 5*2; // z = 10 i = 10/2; // i = 5 r = 9%5; // r = 4 Vergleichende Operatoren (,=,==,!=)

if(x<120) // Bedingung
{
  // Auszuführende Aktion
}

Boolsche Operatoren (&&,||,!)

if(digitalRead(2) == HIGH) // Bedingung
{
  // Auszuführende Aktion
}

Zusammengesetzte Operatoren (++,--,+=,-=,*=,/=) x++ // x um eins erhöhen y-- // y um eins verringern z+=2 // z um zwei erhöhen i-=5 // i um fünf verringern

Kontroller:

if...

if(x>120)
{
  // Aktion wenn x grösser als 120
}

if...else

if(x>120)
{
  // Aktion wenn x grösser als 120
}
else
{
  // Aktion wenn x kleiner als, oder genau 120
}

for

for(int i=0; i<=255; i++) 
{
  // Setzt i von 0 bis 255
}

switch case

switch(var)
{
case 1:
  // Aktion wenn var 1 entspricht
  break;
case 2:
  // Aktion wenn var 2 entspricht
  break;
default:
  // Aktion wenn var weder 1 noch 2 entspricht
}

while

var = 0;
while(var<120)
{
  // Aktion welche sich 120 Mal wiederholt
  var++;
}

break

for(int i=0; i<200; i++)
{
  digitalWrite(5,i);
  sensorWert = analogRead(0);
  if(sensorWert>200)
  {
    i = 0; // Schleife verlassen
    break;
  }
  delay(100);
}

return

int checkSensor()
{
  if(analogRead>200)
  {
    return 1; // checkSensor ist nun 1
  }
  else
  {
    return 0; // checkSensor ist nun 0
  }
}

Spezielle Funktionen:

pinMode(PIN) Definiert ob ein PIN als Eingang oder Ausgang benutz wird digitalRead(PIN) Liesst den Wert an einem digitalen PIN (vorher als Eingang definiert) digitalWrite(PIN, Wert) Setzt einen Wert für einen PIN (vorher als Ausgang definiert) analogRead(PIN) Liesst den Wert eines analogen PIN analogWrite(PIN, Wert) Setzt den PWM Wert eines digitalen PIN (PWM = Pulse Width Modulation) delay(Wert) Pausiert das aktuelle Programm für eine definierte Zeit (Zeit wird in Millisekunden angegeben)

Erste Schaltung

Im ersten Schritt wollen wir nicht das Arduino Board verwenden, sondern wir werden unser eigenes minimales Arduino Board auf dem Breadboard erstellen (siehe auch dieses Tutorial). Dazu benötigen wir folgende Komponenten: 1x ATMEGA 168 Mikrokontroller 2x Kondensator 22pF 1x Kondensator 0.1uF 1x Quarz 16Mhz 1x Widerstand 10kOhm 1x Steckerleiste (6 Pins) 1x FTDI Kabel (5V) 1X Widerstand 220Ohm 1x LED Rot Die Komponenten setzen wir in folgender Weise auf das Breadboard. Nachdem das Breadboard bestückt ist (alle Verbindungen noch einmal überprüfen) verbinden wir das FTDI Kabel mit dem USB Anschluss des Computers. Die rote LED sollte dann im Abstand von ca. 1sec blinken.

Erstes Programm

Um unser erstes eigenes Programm auf das Arduino zu laden müssen wir zunächst die Arduino IDE herunterladen und installieren. Der Download Link findet sich hier. Nachdem das Programm heruntergeladen wurde installieren und starten es. Folgende Ansicht wird geöffnet. Sollte das Blink Beispiel noch nicht geöffnet sein, so öffnet ihr dieses über: File/Examples/Basics/Blink. Dieses Beispiel ist schon auf eurem Mikrocontroller aufgespielt. Ihr könnt jetzt z.B. mit der Veränderung der delay() Funktion spielen um die LED schneller oder langsamer Blinken zu lassen, bzw. kleine Sequenzen abzuspielen.

Übersicht Arduino Board

Aufgaben:

1. Nutz das Blink Beispiel (Exampels/Basic/Blink) und erweitere es um eine zweite LED. 2. Öffne das BlinkWithout Delay Beispiel (Exampels/Digital/BlinkWithoutDelay) und verstehe das Konzept. 3. Programmiere ein Lauflicht mit 3 LEDs, welches sich von einer zur anderen Seite bewegt. 4. Definiert eine eigene Funktion void blinkLED(int _Pin, int _duration) welche es ermöglicht unterschiedliche LEDs mit unterschiedlichen Geschwindigkeiten blinken zu lassen.

void setup() {                
  // initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  pinMode(13, OUTPUT); 
  pinMode(12, OUTPUT);  
}

void loop() {
  digitalWrite(13, HIGH);   // set the LED on
  digitalWrite(12, HIGH);   // set the LED on
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // set the LED off
  digitalWrite(12, LOW);    // set the LED off
  delay(1000);              // wait for a second
}

// constants won't change. Used here to 
// set pin numbers:
const int ledPin =  13;      // the number of the LED pin

// Variables will change:
int ledState = LOW;             // ledState used to set the LED
long previousMillis = 0;        // will store last time LED was updated

// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long interval = 1000;           // interval at which to blink (milliseconds)

void setup() {
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);      
}

void loop()
{
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the 
  // difference between the current time and last time you blinked 
  // the LED is bigger than the interval at which you want to 
  // blink the LED.
  unsigned long currentMillis = millis();
 
  if(currentMillis - previousMillis > interval) {
    // save the last time you blinked the LED 
    previousMillis = currentMillis;   

    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW)
      ledState = HIGH;
    else
      ledState = LOW;

    // set the LED with the ledState of the variable:
    digitalWrite(ledPin, ledState);
  }
}

#define LED_ONE 13
#define LED_TWO 12
#define LED_THR 11

void setup() 
{                
  pinMode(LED_ONE, OUTPUT); 
  pinMode(LED_TWO, OUTPUT); 
  pinMode(LED_THR, OUTPUT);  
}

void loop() 
{
  for(int i=13; i<11; i--)
  {
    digitalWrite(i, HIGH);
    delay(500);
    digitalWrite(i, LOW);
    delay(500);
  }
  
  for(int i=11; i<=13; i++)
  {
    digitalWrite(i, HIGH);
    delay(500);
    digitalWrite(i, LOW);
    delay(500);
  } 
}

int ledPins[3] = {8,9,10}; // Alle LED Pins in einem Array initialisieren
boolean ledStates[3] = {false, false, false}; // Alle LED Status speichern
long previousMillis[3] = {0,0,0}; // Die Zeiten speichern

void setup()
{
  for(int i=0; i<3; i++)
  {
    pinMode(ledPins[i], OUTPUT); // Alle LED Pins sind Output
  }
}

void loop()
{
  blinkLED(1, 100);  // Aufrufen unserer Funktion
  blinkLED(2, 1000);
  blinkLED(3, 500);
}

void blinkLED(int _Pin, int _duration) // Eigene Funktion
{
  if(millis() - previousMillis[_Pin-1] > _duration) // Ist genug Zeit vergangen?
  {
    previousMillis[_Pin-1] = millis(); // Zeit speichern
    ledStates[_Pin-1] != ledStates[_Pin-1];  // Den LED State umdrehen (wenn AUS dann AN)
    digitalWrite(ledPins[_Pin-1], ledStates[_Pin-1]); // State setzen
  }
}

Weitere Informationen

Getting Started with Arduino – Massimo Banzi (2008) Arduino – Die Arduino Website. Bitte anschauen... Microcontroller – Was ist ein Mikrokontroller?

Reflektion

Mikrocontroller

In der ersten Lektion haben wir uns mit dem Mikrocontroller und dessen Schaltung und Programmierung vertraut gemacht. Folgende Inhalte waren dabei wichtig: - Ein Mikrocontroller ist eine programmierbare elektronische Komponente. - Wir verwenden die Arduino IDE, welche auf C/C++ basiert ist.

Bauteile

Des weiteren haben wir schon unterschiedliche elektronische Bauteile und Gesetzmässigkeiten angewandt. Dazu zählen: - Wiederstand - LED - Kondensator Hier zunächst weitere Informationen zu den betreffenden Bauteilen: Make Presents: The Resistor Make Presents: The LED Make Presents: The Capacitor

Funktionen

setup(): Wird nur einmal zum Beginn des Programms aufgerufen. Hier werden weitere Funktionen aufgerufen (z.B. pinMode()). loop(): Der Loop beinhaltet das eigentliche Programm und wird permanent ausgeführt. Die Geschwindigkeit, mit der das Programm aufgerufen wird hängt dabei von der Taktfrequenz des Prozessors und den Funktionen ab, die aufgerufen werden. pinMode(): Definiert ob ein digitaler Pin als Input oder Output genutzt wird. digitalWrite(): Schreibt einen Wert auf einen Pin (zunächst nur HIGH oder LOW). delay(): Hält das Programm für eine definierbare Zeit an. Diese Funktion ist nicht so effektiv, wie die Nutzung von millis(). millis(): Hier wird die Aktuelle Systemzeit (in Millisekunden) zurückgegeben.