Arduino Lektion #101: Multifunktionales Shield “Easy Module MIX V1” von YwRobot

In diesem Beitrag möchte ich, ein Multifunktionales Shield “Easy Module MIX V1” von YwRobot vorstellen.

Das Shield ist mit vielen Funktionen ausgestattet welche dem Anfänger sowie auch dem Fortgeschrittenen Entwickler viel Spaß bereiten kann. Der Vorteil eines sollchen Shields ist es, dass ohne viel Verkabelung und Löten fast sofort losgelegt werden kann.

Anders als die Bereits vorgestellten Multifunktionalen Shields für die Arduino Familie, kann man dieses nicht auf den Arduino UNO / Leonardo, Mega 2560 R3 stecken, sondern muss hier mit Breadboardkabeln “arbeiten”.

Wichtig bei den Shields ist es das darauf geachtet wird wo die Pins SDA / SCL liegen der Arduino UNO hat diese auf den analogen Pins A4 bzw. A5 verbaut. Beim Arduino Leonardo sind diese in der Reihe der digitalen Pins.

Bezug

Das Shield gibt es für knapp 10$ (ca. 9€) inkl. Versandkosten bei banggood.com bzw. aliexpress.com zu kaufen. (Man findet dieses auch auf ebay.de* aber dort ist der Preis doppelt so hoch.) Ich habe mein Shield über Banggood bestellt und es wurde nach ca. 3 Wochen geliefert.

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Funktionsumfang

Das multifunktionale Shield beinhaltet folgende Funktionen / elektronische Bauteile

• Relais
• Piezo Buzzer
• analoger Temperatursensor LM35
• Lichtsensor / Fotowiderstand
• IR Empfänger
• LEDs
• Drehpotentiometer
• Temperatur & Luftfeuchtigkeitssensor DHT11
• Taster
• RGB LED 
• Rainbow LEDs

Dieses sind deutlich mehr als die bisherigen Shields in meiner Sammlung.

Die einzelnen Sensoren & Aktoren sind über separate Pins erreichbar welche am unteren Ende des Shields aufgereiht sind.

Für den Anschluss an einen Arduino UNO empfehle ich die 20cm, männlich-weiblich Breadboardkabel. (Diese gibt es zbsp. bei ebay.de.)

Beispiele

Nachfolgend möchte ich nun zu jedem Sensor / Aktor ein kleines Beispiel liefern. Den Quellcode zu den Beispielen findest du auf meinem GitHub Repository oder nachfolgend bequem zum Download.

Relais

Das Relais kann gemäß dem Aufdruck maximal 3A bei 250V AC und 3A bei 30V DC schalten. 

Ob ich jedoch bei einem Chinakracher solche Ströme schalten würde, steht auf einem anderen Blatt.

Die Anschlußklemmen des Relais sind mit “NO”, “COM” und “NC” beschriftet. Je nachdem in welchem Status man schalten möchte ist der Stromfluß. D.h. wenn das Relais NICHT eingeschaltet sein soll und der Strom fließen soll dann muss man “COM” und “NC” verwenden. Wenn das Relais eingeschaltet sein soll für den Stromfluß dann muss “NO” und “COM” verwendet werden.

Beispiel #1 – einfaches wechselblinken zweier LEDs

const int relaisPin = 8;
 
void setup() {
  pinMode(relaisPin, OUTPUT); // den Pin des Relais als Ausgang setzen
}
 
void loop() {
  digitalWrite(relaisPin, HIGH); //Relais aus
  delay(500);  //500ms warten
  digitalWrite(relaisPin, LOW);  //Relais an
  delay(500);// 500ms warten
}

Video

In dem Video kann man gut den Wechsel erkennen. Wenn das Relais ausgeschaltet ist dann leuchtet die rote LED und wenn es eingeschaltet ist die grüne.

Beispiel #2 – steuern des Relais über einen Taster

#include <Bounce2.h>

//Relais am digitalen Pin D8 angeschlossen
const int relaisPin = 8;

//Taster am digitalen Pin D3 angeschlossen
const int btnPin = 3;

//Variable zum speichern des Status des Relais
boolean relaisIsActive = false;

//"Hilfs" Object damit der Taster entprellt wird
//Parameter
//der Pin an welchem der Taster angeschlossen ist
//eine Zeit in Millisekunden
Bounce btnBounce = Bounce(btnPin, 50);

void setup() {
  pinMode(relaisPin, OUTPUT); // den Pin des Relais als Ausgang setzen
  pinMode(btnPin, INPUT); // den Pin des Relais als Ausgang setzen
}

void loop() {
  //aktualisieren des Objectes
  btnBounce.update();
  //Wenn der Taster gedrückt wird dann...
  if (btnBounce.fell()) {
    //negieren des Status
    relaisIsActive = !relaisIsActive;
    //Wenn das Relais deaktiviert ist dann...
    if (relaisIsActive) {
      digitalWrite(relaisPin, LOW);
    } else {
      digitalWrite(relaisPin, HIGH);
    }
    //eine kleine Pause von 250ms.
    delay(250);
  }
}

Video

Achtung

Die Relais können bei sehr schnellem hin und herschalten (Wechsel zwischen EIN und AUS) verkleben. Dieses ist dem Aufbau des Relais geschuldet.

Zwischen den Kontaktfedern können beim Schalten hohe Ströme entstehen welche dafür sorgen das diese zusammenkleben. Durch ein beherztes klopfen auf das Relais lassen sich diese im Normalfall wieder lösen.

Piezo Buzzer

Der Piezo Buzzer ist ein kleiner Aktor welcher einfache Töne wiedergeben kann. Mit etwas Geschick kann man sogar kleine Lieder abspielen.  In meinem Beitrag zum LED Weihnachtsbaum verwende ich bereits so ein kleines Gerät. Jedoch ist dieser vorliegende ein aktivier Piezo Buzzer d.h. wir müssen zusätzlich eine 5V Versorgungsspannung anschließen.

Um einen Ton auszugeben kann man in der Arduino IDE den Befehl “tone” verwenden. Diese Funktion gibt es in 2 verschiedene Ausführungen.

In der ersten Version werden 3 Parameter übergeben einmal der Pin an welchem der Piezo Buzzer angeschlossen wurde, dann die Frequenz sowie die Dauer wie lange der Ton ertönen soll.
Die zweite Version benötigt nur 2 Parameter (Pin und Frequenz) jedoch benötigt man noch zusätzlich noch einen Aufruf der Funktion “noTone(<PIN>);” damit der Ton deaktiviert wird.

tone(<PIN>,<FREQ>,<ZEIT>);

tone(<PIN>,<FREQ>);
noTone(<PIN>);

Tip

Wenn du ein bestimmtes Lied abspielen möchtest dann schaue doch ob es für dieses Lied eine Anleitung für ein Xylophon gibt. Einpaar schöne Bücher findet man hier auf amazon.de oder aber auch gebraucht bei medimops.de.

Was man dann nur noch brauch sind die Frequenzen zu den Noten. Und genau hier wird es etwas schwieriger aber auch das ist lösbar. Zur Not kann man eine Google-Suche mit dem Begriff “Arduino Buzzer Songs” ausführen und sich von den bereits erstellten Sketchen leiten lassen.

Beispiel – Alle meine Entchen

In den Beispielen auf GitHub oder im ZipFile findest du ein Sketch mit dem Lied “Alle meine Entchen”.

analoger Temperatursensor LM35DZ

Der Temperatursensor LM35DZ kann die Temperatur mit einer Auflösung von 1°C messen. Dabei nutzt dieser die 5V als Referenzspannung. Bei meinem Einsatz mit dem Keyestudio UNO musste ich feststellen das dieser Microcontroller keine genauen 5V auf dem 5V Pin liefert sondern nur 4,74V diese Ungenauigkeit sorgte beim Temperatursensor LM35DZ dazu das dieser einen Unterschied ca. 2°C erzeugte.

Ein wechsel zum originalen Arduino UNO brachte hier ein deutlich besseres Ergebnis da dieser Microcontroller auf dem 5V Pin 5,01V liefert (ich gehe davon aus das mein Messgerät “Voltcraft ME-42” eine kleine Toleranz hier hat). 

Quellcode

//Temperatursensor LM35DZ am analogen Pin A0
#define lm35 A0

void setup() {
  //beginn der seriellen Kommunikation
  Serial.begin(9600);
}

void loop() {
  //lesen des aktuellen, analogen Wertes des Temperatursensors
  int value = analogRead(lm35);
  //umrechnen in ein Temperaturwert
  int temp = (125*value)>>8 ; 
  //Ausgeben der Temperatur auf der seriellen Schnittstelle
  Serial.print(temp) ;
  Serial.println("°C"); 
  //eine kleine Pause von 125ms
  delay(125);
}

LEDs

Die LEDs sind mit jeweils einem 220 Ohm Vorwiderstand belegt, daher können wir an die Pins unseren Microcontroller direkt anschließen. Es sind sowohl GND und VCC Pins vorhanden, hier nutzen wir jedoch “nur” den GND sowie den Signalpin “S” für den Anschluß.

Beispiel #1 – Lauflicht

//LEDs
#define led1 3
#define led2 4
#define led3 5
#define led4 6

int leds[] = {led1, led2, led3, led4};

const int PAUSE = 50;

void setup() {
  //beginn der seriellen Kommunikation
  Serial.begin(9600);
}

void loop() {
  for(int i = 0;i<=3;i++){
    digitalWrite(leds[i], HIGH);
    delay(PAUSE);
    digitalWrite(leds[i], LOW);
    delay(PAUSE);
  }

   for(int i = 2;i>=0;i--){
    digitalWrite(leds[i], HIGH);
    delay(PAUSE);
    digitalWrite(leds[i], LOW);
    delay(PAUSE);
  }
}

Beispiel #2 – Lauflicht, variable mit Drehpotentiometer

//LEDs
#define led1 3
#define led2 4
#define led3 5
#define led4 6

//Drehpotentiometer am analogen Pin A0 angeschlossen
#define drehpoti A0

int leds[] = {led1, led2, led3, led4};

void setup() {
  //beginn der seriellen Kommunikation
  Serial.begin(9600);
}

void loop() {

  //Schleife über das Array mit den LEDs,
  //von der ersten bis zur letzten LED
  for(int i = 0;i<=3;i++){
    //aktivieren der LED
    digitalWrite(leds[i], HIGH);
    //lesen des aktuellen Wertes des Drehpotis und
    //verwenden als Pause
    delay(readDrehpoti());
    //deaktivieren der LED
    digitalWrite(leds[i], LOW);
    delay(readDrehpoti());
  }

   //Schleife über das Array mit den LEDs,
   //jedoch beginnen wir mit der vorletzen LED
   //da die letzte LED bereits in der Schleife zuvor geblinkt hat.
   for(int i = 2;i>=0;i--){
    digitalWrite(leds[i], HIGH);
    delay(readDrehpoti());
    digitalWrite(leds[i], LOW);
    delay(readDrehpoti());
  }
}

//Liefert den aktuellen Wert des Drehpotentiometers
int readDrehpoti(){
  return analogRead(drehpoti);
}

Lichtsensor / Fotowiderstand

Der Fotowiderstand verändert je nach Lichteinfall seinen Widerstandswert. Den Wert misst man einfach über einen analogen Pin des Arduinos. Die Messdaten werden mit einer Spannungsteilerschaltung gemessen. D.h. es gibt eine definierte Eingangsspannung welche über einen definierten Widerstand geleitet wird, Parallel dazu wird der Fotowiderstand geschaltet und dadurch kann der Wert gemessen werden. (“Dieses ist nur die verkürzte Erklärung der Spannungsteilerschaltung.”)

Beispiel #1 – einfache Ausgabe auf der seriellen Schnittstelle

Das einfachste ist es wohl den Wert auf der seriellen Schnittstelle auszugeben.

//Lichtsensor / Fotowiderstand am analogen Pin A0
#define lightSensor A0

void setup() {
  //beginn der seriellen Kommunikation
  Serial.begin(9600);
}

void loop() {
  //lesen des aktuellen, analogen Wertes des Lichtsensors
  int value = analogRead(lightSensor);
  //ausgeben des Wertes auf der seriellen Schnittstelle
  Serial.println(value);
}

Beispiel #2 – “Ausgabe” auf LEDs

//Lichtsensor / Fotowiderstand am analogen Pin A0
#define lightSensor A0

//LEDs
#define led1 3
#define led2 4
#define led3 5
#define led4 6

int leds[] = {led1, led2, led3, led4};

void setup() {
  //beginn der seriellen Kommunikation
  Serial.begin(9600);
}

void loop() {
  resetLeds();
  //lesen des aktuellen, analogen Wertes des Lichtsensors
  int value = analogRead(lightSensor);
  //ausgeben des Wertes auf der seriellen Schnittstelle
  Serial.print("Wert des Lichtsensors: ");
  Serial.println(value);

  int led = map(value,300,820,0,3);
  digitalWrite(leds[led], HIGH);
  delay(125);
  Serial.print("aktive LED: ");
  Serial.println(led);
}

void resetLeds(){
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
}

IR Empfänger

Für den experimentellen Aufbau mit der Infrarot Diode benötigen wir eine Fernbedienung. Leider liegt dem Shield keine passende bei, jedoch kann man jede beliebige Fernbedienung (welche über einen IR Sender verfügt) verwenden. Ich nutzte kurzerhand die Fernbedienung vom DVD Player.

Vorbereitung

Zunächst einmal müssen wir die IR Fernbedienung auslesen. D.h. die Daten welche das Gerät sendet empfangen und “speichern”. Ich möchte zunächst einmal die LEDs schalten sowie das Relais schalten.

Auslesen der Fernbedienung

#include <IRremote.h>

int irPin = 10; //Pin am Arduino Nano für die IR LED

IRrecv irrecv(irPin); //Objekt initialisieren für die IR Übertragung
decode_results results;

void setup() {
  pinMode(irPin, INPUT);  //Den IR Pin als Eingang deklarieren.
  irrecv.enableIRIn(); //Den IR Pin aktivieren
  Serial.begin(9600); //Serielle kommunikation mit 9600 Baud beginnen.
}
 
void loop(){
   if (irrecv.decode(&results)) { //Wenn etwas gelesen wurde dann...
      //Ausgabe des Wertes auf die Serielle Schnittstelle.
      int value = results.value;
      Serial.println(value, DEC);
      irrecv.resume(); // auf den nächsten Wert warten
 }
}

Als Ausgabe auf der seriellen Schnittstelle erhält man einen Zahlenwert, dieser ist je nach gedrückter Taste unterschiedlich. Es ist jedoch darauf zu achten das die Daten ggf. mehrfach gesendet werden. Dieses sollte man im Quellcode abfangen.

Beispiel #1 – Schalten von LEDs und dem Relais

#include <IRremote.h>

//LEDs
#define led1 3
#define led2 4 //Power On
#define led3 5
#define led4 6 //Power Off

//IR Receiver am digitalen Pin D10
#define irPin  10

//Relais am digitalen Pion D12 angeschlossen
#define relais 12

IRrecv irrecv(irPin); //Objekt initialisieren für die IR Übertragung
decode_results results;

//Variablen für das speichern der Status
boolean isPowerOn = true;
boolean relaisIsActive = true;
boolean led1IsActive = false;
boolean led3IsActive = false;

//Konstante für die Zeitberechnung 
const int timeGap = 1500;
long lastReceivedValueTime = -1;

void setup() {
  pinMode(irPin, INPUT);  //den digitalen Pin des IR Empfängers als Eingang deklarieren
  pinMode(relais, OUTPUT);  //den digitalen Pin des Relais als Eingang deklarieren

  irrecv.enableIRIn(); //Den IR Pin aktivieren
  Serial.begin(9600); //Serielle kommunikation mit 9600 Baud beginnen.

  //Initialiesieren
  //Das "Gerät" ist AUS
  togglePowerState();
}

void loop() {
  if (irrecv.decode(&results)) { //Wenn etwas gelesen wurde dann...
    //lesen des aktuellen Wertes 
    int value = results.value;
    //Ausgabe des Wertes auf die Serielle Schnittstelle.
    Serial.println(value, DEC);
    //lesen der aktuellen Millisekunde seid dem der Microcontroller gestartet wurde
    long currentTime = millis();
    //Wenn seid der letzten aktion mindestens "timeGap" Sekunden verstrichen sind, dann...
    if ((currentTime+timeGap)> lastReceivedValueTime) {
      //ersetzen des Zeitstempels
      lastReceivedValueTime = currentTime+timeGap;
      switch (value) {
        case 1223: togglePowerState(); break; //Power On / Off
        case 1090: activateLed1(); break; //LED1 (blau), aktivieren / deaktivieren
        case 1068: toggleRelais(); break; //Relais, aktivieren / deaktivieren
        case 1116: activateLed3(); break; //LED3 (gelb), aktivieren / deaktivieren
      }
    }
    
    irrecv.resume(); // auf den nächsten Wert warten
  }
}

void activateLed1() {
  //Wenn aktiv dann...
  if (isPowerOn) {
    led1IsActive = !led1IsActive;
    toggleState(led1IsActive, led1);
  }
}

void activateLed3() {
  //Wenn aktiv dann...
  if (isPowerOn) {
    led3IsActive = !led3IsActive;
    toggleState(led3IsActive, led3);
  }
}

void toggleRelais() {
  //Wenn aktiv dann...
  if (isPowerOn) {
    relaisIsActive = !relaisIsActive;
    toggleState(relaisIsActive, relais);
  }
}

//Wechselt einen Status am digitalen Pin
//wenn der "state" TRUE ist dann wird der "pin" auf HIGH gesetzt
//wenn der "state" FALSE ist dann wird der "pin" auf LOW gesetzt
void toggleState(boolean state, int pin) {
  if (state) {
    digitalWrite(pin, HIGH);
  } else {
    digitalWrite(pin, LOW);
  }
}

void togglePowerState() {
  digitalWrite(led2, LOW);
  digitalWrite(led4, LOW);

  isPowerOn = !isPowerOn;
  if (isPowerOn) {
    digitalWrite(led2, HIGH);
  } else {
    digitalWrite(led4, HIGH);
    digitalWrite(led1, LOW);
    digitalWrite(relais, HIGH);

    relaisIsActive = false;
    relaisIsActive = false;
    led1IsActive = false;
    led3IsActive = false;
  }
}

Drehpotentiometer

Den Drehpotentiometer habe ich bereits bei den LEDs verwendet. Auch habe ich dem Bauelement folgenden Beitrag Bauteile: 50kOhm Drehpotentiometer gewidmet. (Auch wenn in diesem Beitrag ein 50k Ohm Drehwiderstand verwendet wird ist dieses grundsätzlich gleich.)

Ein Drehpotentiometer verfügt über 3 Anschlüsse an welche die Spannung (5V), der Minus Pol (GND) sowohl der analoge Pin des Arduino angeschlossen wird.

Nun können wir mit dem Befehl “analogRead(<PIN>);” den aktuellen Wert des Drehpotentiometers auslesen und weiterverwenden.

Quellcode

#define drehpoti A0

void setup() {
  //beginn der seriellen Kommunikation mit 9600 baud
  Serial.begin(9600);  
}

void loop() {
  //auslesen des Wertes des Drehpotentiometers
  //und speichern in einer Variable
  //der Wert liegt Ganzzahlig zwischen 0 und 1023
  unsigned int value = analogRead(drehpoti);
  //ausgeben des Wertes auf der seriellen Schnittstelle
  Serial.println(value);  
  
  //oder 
  //gleichzeitiges auslesen des Wertes und ausgabe
  //auf der seriellen Schnittstelle
  //Serial.println(analogRead(drehpoti));  
}

Video

Temperatur & Luftfeuchtigkeitssensor DHT11

Mit dem Sensor DHT11 läßt sich die Temperatur sowie die relative Luftfeuchtigkeit messen.

Der Sensor hat folgende Technische Daten:

• Messbereich der relativen Luftfeuchtigkeit 20% bis 90%
• Toleranz des Messbereiches für die relative Luftfeuchtigkeit ±5%
• Messbereich der Temperatur 0 bis 60°C
• Toleranz des Messbereiches für die Temperatur ±2°C
• Betriebsspannung 5V

Für das auslesen der Sensordaten verwende ich die Adafruit Bibliothek welche über den Bibliotheksverwalter der Arduino IDE installiert werden kann.

Zunächst muss nach dem Begriff “dht11” (1) gesucht werden, es wird dann alles aufgelistet was mit diesem Begriff zutun hat. Ich wähle hier wie bereits erwähnt die Adafruit Bibliothek und klicke auf die Schaltfläche “Installieren” (2). Nachdem diese Bibliothek installiert wurde kann der Dialog über die Schaltfläche “Schließen” (3) verlassen werden.

Für die Installation der Bibliothek werden einige zusätzliche Bibliotheken benötigt , hier klicke ich auf “Install all”.

Der Adafruit Bibliothek zum Sensor DHT11 liegen einige Beispiele bei welche man unter “Datei” > “Beispiele ” > “DHT sensor library”.

Quellcode

#include "DHT.h" //einbinden der Adafruit Blibothek DHT11

//der Sensor ist am digitalen Pin D3 angeschlossen
#define DHTPIN 3 

//Die verwendete Bibliothek kann für den DHT11, DHT22 verwendet werden, daher
//muessen wir definieren welchen Sensor wir ansprechen möchten.
#define DHTTYPE DHT11

//initialisieren eines Objektes fuer das spaetere auslesen der Daten
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  //beginn der seriellen Kommunikation mit 9600 baud
  Serial.begin(9600);

  //beginn der Kommunikation mit dem Sensor
  dht.begin();

  //ausgeben eines Tabellenkopfes auf der seriellen Schnittstelle
  Serial.println("rel. Luftfeuchtigkeit\t\t|\tTemperatur");
}

void loop() {
  //eine kleine Pause von 2sek.
  //Der DHT11 Sensor liefert alle 1,5sek. einen neuen Messwert.
  delay(2000);

  //lesen der Daten
  float h = dht.readHumidity(); //relative Luftfeuchtigkeit
  float t = dht.readTemperature(); //Temperatur in Celsius
  float f = dht.readTemperature(true); //Temperatur in Fahrenheit

  //wenn eines der gelesenen Werte ungueltig ist dann...
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Fehler beim lesen der Daten vom DHT Sensor!");
    return;
  }

  //Ausgabe der Daten auf der seriellen Schnittstelle.
  Serial.print(h);
  Serial.print("%");
  Serial.print("\t\t\t\t|\t");
  Serial.print(t);
  Serial.print("°C");
  Serial.print(" | ");
  Serial.print(f);
  Serial.print("°F");
  Serial.println("");
}

Video

Im nachfolgenden Video habe ich die Temperatur mit einem Fön etwas erhöht.

Taster

Um die verbauten Taster verwenden zu können muss man eigentlich nur den prüfen ob der jeweilige digitale Pin auf HIGH (Taster ist gedrückt)  oder LOW (der Taster ist nicht gedrückt) ist. 
Jedoch gibt es hier eventuell ein kleines Problem das der Taster prellt d.h. das mehrere Werte auf einmal empfangen und verarbeitet werden. Wie man einen Taster entprellt habe ich im Beitrag Arduino Lektion 87: Taster entprellen ausführlich beschrieben.

Quellcode

#include <Bounce2.h> //Bibliothek zum entprellen der Taster

//Die Taster sind am digitalen Pin D3..D6 angeschlossen
#define sw1 3
#define sw2 4
#define sw3 5
#define sw4 6

//Intervall zum entprellen auf 50ms
const int INTERVAL = 50;

//Initialisieren von Objekten für jeden Taster
Bounce b1 = Bounce(sw1, INTERVAL);
Bounce b2 = Bounce(sw2, INTERVAL);
Bounce b3 = Bounce(sw3, INTERVAL);
Bounce b4 = Bounce(sw4, INTERVAL);

void setup() {
  //beginn der seriellen Kommunikation mit 9600 baud
  Serial.begin(9600);

  //setzen das die digitalen Pins als Eingänge funktionieren
  pinMode(sw1, INPUT);
  pinMode(sw2, INPUT);
  pinMode(sw3, INPUT);
  pinMode(sw4, INPUT);
}

void loop() {
  //aktualisieren der Zustände
  b1.update();
  b2.update();
  b3.update();
  b4.update();

  //Wenn der Taster 1 gedrückt ist, dann...
  if(b1.fell()){
    msgFell(1);
  } else if(b1.rose()){ //Wenn der Taster 1 wieder losgelassen wird, dann...
    msgRose(1);
  } 

  if(b2.fell()){
    msgFell(2);
  }else if(b2.rose()){
    msgRose(2);
  } 
  
  if(b3.fell()){
    msgFell(3);
  }else if(b3.rose()){
    msgRose(3);
  }

  if(b4.fell()){
    msgFell(4);
  }else if(b4.rose()){
    msgRose(4);
  }
}

//Text auf der seriellen Schnittstell ausgeben. Das der Taster gedrückt ist.
void msgFell(int taster){
  Serial.print("Taster ");
  Serial.print(taster);
  Serial.println(" ist gedrückt!");
}

//Text auf der seriellen Schnittstell ausgeben. Das der Taster wieder losgelassen wurde.
void msgRose(int taster){
  Serial.print("Taster ");
  Serial.print(taster);
  Serial.println(" wurde wieder losgelassen!");
}

Video

RGB LED

Auf dem multifunktionalem Shield ist auch eine RGB LED verbaut. Die Farben dieser LED werden über jeweils einen einzelnen Pin gesetzt.

Die Pins werden wiefolgt mit dem Arduino UNO verbunden:

RGB LED	Arduino UNO
LED-R “S”	digitaler PWM Pin D3
LED-G “S”	digitaler PWM Pin D5
LED-B “S”	digitaler PWM Pin D9

Die Pins für die Versorgungsspannung werden jeweils an 5V bzw. an GND angeschlossen.

Beispiel #1 – setzen einer Farbe

Jeder Wert der Farbe (rot, grün, blau) kann zwischen 0 und 255 liegen. Einen RGB Color Picker findest du zbsp. unter https://www.w3schools.com/colors/colors_picker.asp.

//Pin für die rote Farbe der LED am digitalen PWM Pin D3 angeschlossen
#define led_r 3 
//Pin für die grüne Farbe der LED am digitalen PWM Pin D5 angeschlossen
#define led_g 5
//Pin für die blaue Farbe der LED am digitalen PWM Pin D9 angeschlossen
#define led_b 9

void setup() {
  //setzen der Pins als Ausgänge
  pinMode(led_r, OUTPUT);
  pinMode(led_g, OUTPUT);
  pinMode(led_b, OUTPUT);
}

void loop() {
  //schreiben der RGB Werte auf die einzelnen Ausgänge
  analogWrite(led_r, 125);
  analogWrite(led_g, 25);
  analogWrite(led_b, 95);
}

Beispiel #2 – Schleife über die Farbwerte

Wenn man nun jeweils 3 Schleifen ineinander verpackt kann man die möglichen Farben der LED anzeigen lassen.

//Pin für die rote Farbe der LED am digitalen PWM Pin D3 angeschlossen
#define led_r 3
//Pin für die grüne Farbe der LED am digitalen PWM Pin D5 angeschlossen
#define led_g 5
//Pin für die blaue Farbe der LED am digitalen PWM Pin D9 angeschlossen
#define led_b 9

void setup() {
  //setzen der Pins als Ausgänge
  pinMode(led_r, OUTPUT);
  pinMode(led_g, OUTPUT);
  pinMode(led_b, OUTPUT);
}

void loop() {
  //Eine Schleife von 0 bis 255 in 5er Schritten
  for (int r = 0; r <= 255; r= r+5) {
    //setzen der Farbe "rot"
    analogWrite(led_r, r);
    for (int g = 0; g <= 255; g= g+5) {
      //setzen der Farbe "grün"
      analogWrite(led_g, g);
      for (int b = 0; b <= 255; b=b+5) {
        //setzen der Farbe "blau"
        analogWrite(led_b, b);
        delay(15); //eine kleine Pause von 15ms.
      }
    }
  }
}

Video

Da die RGB LED deutlich zu hell für meine Webcam ist, kann ich den Farbwechsel leider nicht so aufnehmen wie es in Realität ist.

Rainbow LEDs

Die drei Rainbow LEDs vom Typ SK6812 sind einzeln steuerbar. Dazu benötigt man jedoch eine zusätzliche Bibliothek.

Ich habe einige Bibliotheken durchprobieren müssen bis ich eine vernünftige, handlebare gefunden habe. Es ist die FastLED Bibliothek geworden.

Auch diese Bibliothek wird bzw. kann wieder über den Bibliotheksverwalter der Arduino IDE installiert werden. Hier muss zunächst nach “FastLED” gesucht werden (1). Der erste Eintrag ist auch gleich der richtige zum Installieren. Hier betätigen wir die Schaltfläche “Installieren” (2) und können danach den Dialog mit der Schaltfläche “Schließen” (3) verlassen.

Der Bibliothek liegen einige Beispiele bei, von diesen verwende ich das “Fire2012” in welchem ich nur die Anzahl der LEDs sowie den Pin ändern musste.

Video

Fazit

Das multifunktionale Shield “Easy Module MIX V1” von YwRobot bietet sehr viele Möglichkeiten sich mit dem Arduino und die damit verbundene Programmierung vertraut zu machen. Da das Shield nicht wie die anderen bisher vorgestellten auf den Arduino gesteckt werden muss kommt man um eine Verkabelung nicht drum rum aber es ist alles sehr gut Beschriftet und da das Shield alles mitbringt brauchen auch keine zusätzlichen Bauteile wie Vorwiderstände vorgeschaltet werden.

Man könnte also dieses Shield auch mit einem Arduino Nano, Micro betreiben. Es wäre auch denkbar das Shield am Raspberry PI zu betreiben und somit die Programmierung in Phyton3 zu vollziehen. 

Ich finde dieses Shield gut gelungen jedoch der Preis mit knapp 10$ ist doch sehr hoch.