In dieser Übung soll mittels 2 Taster ein Relais ein- und ausgeschaltet werden. Da die Pins der Tasten und des Relais zu kurz sind, um beim Einstecken in das Breadboard vernünftigen Kontakt herzustellen, wurden 2 Platinen-Module angefertigt.
Durch Drücken der rechten Taste schaltet das Relais ein - die Led leuchtet. Durch Drücken der linken Taste schaltet das Relais wieder aus - die Led wird wieder dunkel.

Hier der Programmcode:
int buttonONpin = 8;      // Taster zum Einschalten
int buttonOFFpin = 9;    // Taster zum Ausschalten
int Relais = 7;                    // Der Relais-Ausgang

void setup() 
{
pinMode(buttonONpin, INPUT_PULLUP);  //Pin-Deklaration als Eingang mit internem 
                                                                                  //Pull-Up. Die Taste wird gegen Gnd geschaltet
pinMode(buttonOFFpin, INPUT_PULLUP);
pinMode(Relais, OUTPUT);                             //Pin-Deklaration als Ausgang
}
void loop() 
{
   if (digitalRead(buttonONpin) == LOW)  //Einlesen der Taste ON
   {
      digitalWrite(Relais, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
   }
   if (digitalRead(buttonOFFpin) == LOW) //Einlesen der Taste ON
   {
      digitalWrite(Relais, LOW);                       //Wenn Taste gegen GND, Relaisausgang Low
   }
}

In dieser Übung wird der Aufbau mit Poti und Stopp-Led stufenweise erweitert bis zum Betreib mit Rotary Encoder und 4fach-7Segment Anzeige und der Encoder-Drucktaster als Stopp.

Schritt 1: Den Aufbau 2.3 ohne Potentiometer als Ausgangsbasis

Schritt 2: Erweiterung mit Rotary Encoder

Schritt 3: Erweiterung 7-Segment Anzeige nur die 4 Widerstände
(zweites Bild zeigt nur die 4 ergänzten Verbindungen) 

Schritt 4: Erweiterung 7-Segment Anzeige mit den Signalleitungen
(zweites Bild zeigt nur die 8 ergänzten Verbindungen) 

Hier der Programmcode:
#include "SevSeg.h" //Die vorher hinzugefügte Library laden
SevSeg sevseg;           //Ein sieben Segment Objekt initialisieren

#define CLK 2
#define DT 3
#define SW 4

int currentStateCLK;
int lastStateCLK;
int counter = 0;
int Anzeigewert = 0;
int Motordrehzahl = 0;
String currentDir ="";
unsigned long lastButtonPress = 0;

byte Genauigkeit = 10;
int STOPLed = 10;          // Led als Stop-Anzeige
int Drehzahl = 0;

void setup()
{
 pinMode(7, OUTPUT);  //L293D Pin 2  //L293D IC
 pinMode(5, OUTPUT);  //L293D Pin 7  //L293D IC
 pinMode(STOPLed, OUTPUT);
 
byte numDigits = 4; //Hier wird die Anzahl der Ziffern angegeben
byte digitPins[] = {17, 16, 15, 14}; // Die Pins zu den Ziffern werden festgelegt
byte segmentPins[] = {24, 26, 28, 30, 32, 34, 36, 38}; //Die Pins zu den //Segmenten werden festgelegt
sevseg.begin(COMMON_CATHODE, numDigits, digitPins, segmentPins); //In diesem
//Abschnitt kann man nun entweder testen welche Art von Display man besitzt oder
//wenn man es schon weiß angeben ob es sich um ein COMMON_CATHODE oder
//COMMON_ANODE Display handelt. Das Display funktioniert nur wenn die richtige
//Art eingetragen ist, ansonsten werden alle Segmente gleichzeitig leuchten.

  // Set encoder pins as inputs
  pinMode(CLK,INPUT);
  pinMode(DT,INPUT);
  pinMode(SW, INPUT_PULLUP);
 
  Serial.begin(9600);   // Setup Serial Monitor 

 
  lastStateCLK = digitalRead(CLK);  // Read the initial state of CLK 

}

void loop()
{
sevseg.setNumber(Anzeigewert); //z.B. (-100);  (100); (0); Hier können wir nun die gewünschte Zahl eintragen.
sevseg.refreshDisplay(); // Dieser Teil lässt die Nummer auf dem Display
//erscheinen.
sevseg.setBrightness(90); //Hier kann die Helligkeit des Displays 0-100 angepasst

// Read the current state of CLK
  currentStateCLK = digitalRead(CLK);

  // If last and current state of CLK are different, then pulse occurred
  // React to only 1 state change to avoid double count
  if (currentStateCLK != lastStateCLK  && currentStateCLK == 1){

    // If the DT state is different than the CLK state then
    // the encoder is rotating CCW so decrement
    if (digitalRead(DT) != currentStateCLK) {
      counter --;
      Anzeigewert --;
      delay(20);
      currentDir ="Runterzählen";
    } else {
      // Encoder is rotating CW so increment
      counter ++;
      Anzeigewert ++;
      delay(20);
      currentDir ="Hinaufzählen";
    }

    Serial.print("Richtung: ");
    Serial.print(currentDir);
    Serial.print(" | Anzeigewert: ");
    Serial.println(Anzeigewert);
  }
 
  lastStateCLK = currentStateCLK;  // Remember last CLK state 

 
  int btnState = digitalRead(SW);  // Read the button state 

  //If we detect LOW signal, button is pressed
  if (btnState == LOW) {
    //if 50ms have passed since last LOW pulse, it means that the
    //button has been pressed, released and pressed again
    if (millis() - lastButtonPress > 50) {
      Serial.println("Encoder Taste gedrückt");
      counter = 0;
      Anzeigewert = 0;
    }
   
    lastButtonPress = millis();  // Remember last button press event 

  }
  delay(1);   // Put in a slight delay to help debounce the reading 

 
if (counter == 0)
       {
       Motordrehzahl = 0;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , HIGH);
       }
       
if (counter >0)
       {
       Motordrehzahl = 140;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       }

if (counter >10)
       {
       Motordrehzahl = 150;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       }   
if (counter >20)
       {
       Motordrehzahl = 160;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       } 
if (counter >30)
       {
       Motordrehzahl = 170;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       } 
if (counter >40)
       {
       Motordrehzahl = 180;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       }
if (counter >50)
       {
       Motordrehzahl = 190;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       }
if (counter >60)
       {
       Motordrehzahl = 200;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       }
if (counter >70)
       {
       Motordrehzahl = 210;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       }
if (counter >80)
       {
       Motordrehzahl = 220;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       }
if (counter >90)
       {
       Motordrehzahl = 230;
       
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       }
if (counter >99)
       {
       Motordrehzahl = 255;
       analogWrite(PIN7, Motordrehzahl);
       analogWrite(PIN5, 0);
       digitalWrite(STOPLed , LOW);
       }
if (counter >100)
       {
        Anzeigewert = 100;
        counter = 100;
       }

if (counter < -0)
       {
       Motordrehzahl = 140;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl);
       digitalWrite(STOPLed , LOW);
       }
if (counter < -10)
       {
       Motordrehzahl = 150;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl);
       digitalWrite(STOPLed , LOW);
       }   
if (counter < -20)
       {
       Motordrehzahl = 160;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl); 

       digitalWrite(STOPLed , LOW);
       } 
if (counter < -30)
       {
       Motordrehzahl = 170;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl); 

       digitalWrite(STOPLed , LOW);
       } 
if (counter < -40)
       {
       Motordrehzahl = 180;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl); 

       digitalWrite(STOPLed , LOW);
       }
if (counter < -50)
       {
       Motordrehzahl = 190;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl); 

       digitalWrite(STOPLed , LOW);
       }
if (counter < -60)
       {
       Motordrehzahl = 200;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl); 

       digitalWrite(STOPLed , LOW);
       }
if (counter < -70)
       {
       Motordrehzahl = 210;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl); 

       digitalWrite(STOPLed , LOW);
       }
if (counter < -80)
       {
       Motordrehzahl = 220;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl); 

       digitalWrite(STOPLed , LOW);
       }
if (counter < -90)
       {
       Motordrehzahl = 230;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl); 

       digitalWrite(STOPLed , LOW);
       }
if (counter < -99)
       {
       Motordrehzahl = 255;
       analogWrite(PIN7, 0);
       analogWrite(PIN5, Motordrehzahl); 

       digitalWrite(STOPLed , LOW);
       } 
if (counter < -100)
       {
        Anzeigewert = -100;
        counter = -100;
       }

}

Mit der im Kit enthaltenen Zifferntastatur soll nun eine 8-fach Relaiskarte wie bei einer SPS geschalten werden. Durch Drücken der Ziffern 1-8 gehen die Relais an. Durch Drücken der Taste 0 gehen alle Relais gleichzeitig aus. Durch Drücken der Taste A schalten alle Relais gleichzeitig ein.
Mit 2 zusätzlichen Tasten auf dem Breadboard kann Relais1 und Relais2 im "toggle" Mode ein&ausgeschaltet werden. Dies funktioniert leider mit der Folientastatur nicht.

Zusätzlich wurde ein Relais-Test - oder auch Verdrahtungstest- impementiert.
Dieser könnte mit /*     und */ auskommentiert werden und damit nicht mehr aktiv sein.

Die Bibliothek keypad.h muss vorher installiert werden!

Hier der Programmcode:
#include <Keypad.h>
//Hier wird die größe des Keypads definiert
const byte COLS = 4; //4 Spalten
const byte ROWS = 4; //4 Zeilen
//Die Ziffern und Zeichen des Keypads werden eingegeben:
char hexaKeys[ROWS][COLS]={
{'D','#','0','*'},
{'C','9','8','7'},
{'B','6','5','4'},
{'A','3','2','1'}
};

int Relais1 = 6;                    // Der Relais-Ausgang 1
int Relais2 = 7;                    // Der Relais-Ausgang 2
int Relais3 = 8;                    // Der Relais-Ausgang 3
int Relais4 = 9;                    // Der Relais-Ausgang 4
int Relais5 = 10;                    // Der Relais-Ausgang 5
int Relais6 = 11;                    // Der Relais-Ausgang 6
int Relais7 = 12;                    // Der Relais-Ausgang 7
int Relais8 = 13;                    // Der Relais-Ausgang 8

int ledState1 = LOW;     // the current state of LED
int lastButtonState1;    // the previous state of button
int currentButtonState1; // the current state of button
int ledState2 = LOW;     // the current state of LED
int lastButtonState2;    // the previous state of button
int currentButtonState2; // the current state of button

const int BUTTON_PIN1 = 3;           // zusätzliche Taste1
const int BUTTON_PIN2 = 2;           // zusätzliche Taste2

byte colPins[COLS] = {38,40,42,44}; //Definition der Pins für die 4 Spalten
byte rowPins[ROWS] = {46,48,50,52};//Definition der Pins für die 4 Zeilen
char Taste; //Taste ist die Variable für die jeweils gedrückte Taste.
Keypad Tastenfeld = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); //Das Keypad kann absofort mit "Tastenfeld" angesprochen werden

void setup() 
{
Serial.begin(9600);
pinMode(BUTTON_PIN1, INPUT_PULLUP);                  // Als Eingang mit internem Pull-Up definiert
pinMode(BUTTON_PIN2, INPUT_PULLUP);                  // Als Eingang mit internem Pull-Up definiert

currentButtonState1 = digitalRead(BUTTON_PIN1);      //Befehl zum Einlesen der Tasten
currentButtonState2 = digitalRead(BUTTON_PIN2);

pinMode(Relais1, OUTPUT);                             //Pin-Deklaration als Ausgang
pinMode(Relais2, OUTPUT);                             //Pin-Deklaration als Ausgang
pinMode(Relais3, OUTPUT);                             //Pin-Deklaration als Ausgang
pinMode(Relais4, OUTPUT);                             //Pin-Deklaration als Ausgang
pinMode(Relais5, OUTPUT);                             //Pin-Deklaration als Ausgang
pinMode(Relais6, OUTPUT);                             //Pin-Deklaration als Ausgang
pinMode(Relais7, OUTPUT);                             //Pin-Deklaration als Ausgang
pinMode(Relais8, OUTPUT);                             //Pin-Deklaration als Ausgang
digitalWrite(Relais1, HIGH);                       //alle Relaisausgaenge High
digitalWrite(Relais2, HIGH);                       
digitalWrite(Relais3, HIGH);                       
digitalWrite(Relais4, HIGH);                       
digitalWrite(Relais5, HIGH);                       
digitalWrite(Relais6, HIGH);                       
digitalWrite(Relais7, HIGH);                       
digitalWrite(Relais8, HIGH);                       

// Testprogramm ob alle Relais schalten und die Verkabelung stimmt
  delay(100);
  digitalWrite(Relais1, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais2, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais3, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais4, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais5, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais6, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais7, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais8, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(1000);
  digitalWrite(Relais7, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais6, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais5, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais4, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
  digitalWrite(Relais3, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100); 
  digitalWrite(Relais2, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100); 
  digitalWrite(Relais1, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
  delay(100);
}

void loop() 
{
Taste = Tastenfeld.getKey(); //Mit Unter der Variablen pressedKey entspricht der gedrückten Taste
if (Taste) 
 { //Wenn eine Taste gedrückt wurde
 Serial.print("Die Taste ");
 Serial.print(Taste);
 Serial.print(" wurde gedrueckt");
 Serial.println(); //Teile uns am Serial Monitor die gedrückte Taste mit
}
if (Taste=='1'){
Serial.println("Relais 1");
digitalWrite(Relais1, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
delay(50);
}
if (Taste=='2'){
Serial.println("Relais 2");
digitalWrite(Relais2, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
delay(50);
}
if (Taste=='3'){
Serial.println("Relais 3");
digitalWrite(Relais3, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
delay(50);
}
if (Taste=='4'){
Serial.println("Relais 4");
digitalWrite(Relais4, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
delay(50);
}
if (Taste=='5'){
Serial.println("Relais 5");
digitalWrite(Relais5, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
delay(50);
}
if (Taste=='6'){
Serial.println("Relais 6");
digitalWrite(Relais6, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
delay(50);
}
if (Taste=='7'){
Serial.println("Relais 7");
digitalWrite(Relais7, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
delay(50);
}
if (Taste=='8'){
Serial.println("Relais 8");
digitalWrite(Relais8, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
delay(50);
}
if (Taste=='0'){
Serial.println("alle löschen");
digitalWrite(Relais1, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais2, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais3, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais4, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais5, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais6, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais7, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais8, HIGH);                       //Wenn Taste gegen GND, Relaisausgang High
delay(50);
}
if (Taste=='A'){
Serial.println("alle ein");
digitalWrite(Relais1, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais2, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais3, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais4, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais5, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais6, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais7, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
digitalWrite(Relais8, LOW);                       //Wenn Taste gegen GND, Relaisausgang High
delay(50);
}
  lastButtonState1    = currentButtonState1;      // save the last state
  currentButtonState1 = digitalRead(BUTTON_PIN1); // read new state
  delay(50);
if((lastButtonState1 == HIGH) && (currentButtonState1 == LOW)) 
  {
  ledState1 = !ledState1;// toggle ledstate1
  digitalWrite(Relais1, ledState1); 
  Serial.println(ledState1);
  Serial.println("The rel 1 is on/off");
    delay(5);
  }
  lastButtonState2    = currentButtonState2;      // save the last state
  currentButtonState2 = digitalRead(BUTTON_PIN2); // read new state
  Serial.println("Taste 2 gedrückt" );
  Serial.println(currentButtonState2);
  Serial.println("Tastatur 2 gedrückt" );
  Serial.println(Taste);
  delay(50);

if((lastButtonState2) == HIGH && (currentButtonState2 == LOW)) 
  {
  ledState2 = !ledState2;// toggle ledstate2
  // control LED arccoding to the toggled state
  digitalWrite(Relais2, ledState2); 
  Serial.println(ledState2);
  Serial.println("The rel 2 is on/off");
  delay(100);
  }
}

Nun kann zum ersten Mal der Serial Monitor sinnvoll genutzt werden. 
Zu öffnen über Tools->Serial Monitor
Auf diesem Ausgabetool  kann man mit den Befehlen  

Serial.println("bla bla");  und  

Serial.print("bla bla");   Text ausgeben.
Man kann auch Variablen ausgeben - z.B. Serial.print(Taste);
Vor dem Start sollte in der void setup-Routine Serial.begin(9600); deklariert werden. Dies startet die Kommunikation mit 9600kboud/Sek.

Mit jedem Tastendruck wird nun protokolliert.

Mit dem im Kit enthaltenen Ultraschallsensor, der RGB Led und dem Servomotor lässt sich eine automatische Schiebetürsteuerung realisieren. Nähert man sich dem Sensor geht die Schiebetür auf (Servo Bewegung AUF). Nach einstellbaren 3 Sekunden schließt sich die Tür automatisch (Servo Bewegung ZU), außer der Ultraschallsensor registriert noch immer einen Gegenstand "in der Tür".

Hier der Programmcode:
#include <Servo.h>

const int trigPin = 9;

const int echoPin = 10;

const int servoPin = 23;

const int redPin = 5;

const int greenPin = 4;

Servo myServo;

long duration;

int distance;

bool isDetected = false;

unsigned long detectionTime = 0;

bool servoWaiting = false;

void setup() {

  pinMode(trigPin, OUTPUT);

  pinMode(echoPin, INPUT);

  pinMode(redPin, OUTPUT);

  pinMode(greenPin, OUTPUT);

  myServo.attach(servoPin);

  myServo.write(0);  // Startposition

  setColor(true, false); // Anfang: rot

  Serial.begin(9600);

}

void loop() {

  // Abstand messen

  digitalWrite(trigPin, LOW);

  delayMicroseconds(2);

  digitalWrite(trigPin, HIGH);

  delayMicroseconds(10);

  digitalWrite(trigPin, LOW);

  duration = pulseIn(echoPin, HIGH);

  distance = duration * 0.034 / 2;

  Serial.print("Entfernung: ");

  Serial.print(distance);

  Serial.println(" cm");

  if (distance > 0 && distance < 20 && !isDetected && !servoWaiting) {

    // Objekt erkannt -> Servo drehen und 5 Sekunden warten

    myServo.write(180);

    setColor(false, true); // grün an

    isDetected = true;

    servoWaiting = true;

    detectionTime = millis();  // Startzeit merken

  }

// 3 Sekunden Wartezeit nach Drehung

  if (servoWaiting && (millis() - detectionTime >= 3000)) {

    servoWaiting = false;

  }

// Wenn kein Objekt mehr erkannt wird und Wartezeit vorbei ist

  if ((distance >= 20 || distance == 0) && isDetected && !servoWaiting) {

    myServo.write(0);

    setColor(true, false); // rot an

    isDetected = false;

  }

delay(100);

}

// Hilfsfunktion zur Farbsteuerung der RGB-LED

void setColor(bool redOn, bool greenOn) {

  digitalWrite(redPin, redOn ? HIGH : LOW);

  digitalWrite(greenPin, greenOn ? HIGH : LOW);

}