Arduino Lektion 88: Rich Shield von Open-Smart

In diesem Tutorial möchte ich das Rich Shield von Open-Smart vorstellen.

Das Rich Shield von Open-Smart verfügt über:

• zwei Taster,
• ein Drehpotentiometer,
• einen NTC-Widerstand (Heißleiter),
• einen Fotowiderstand,
• vier LEDs (rot, grün, blau, gelb),
• einen Piezo Buzzer,
• einen DHT11 Sensor (Temperatur & Luftfeuchtigkeit),
• eine 4fach 7 Segmentanzeige (TM1637),
• eine Infrarot Diode,
• einen Spannungsmesser

Zusätzlich verfügt das Shield über Pins an welche separat VCC, GND, SDA, SCL sowie TX und RX abgenommen werden kann. Eine Klemmleiste für den Anschluss von Vin rundet dieses Shield sehr gut ab.

Das Shield verfügt wie oben erwähnt über eine Infrarot Diode, um diese zu nutzen, kann man entweder extra eine Fernbedienung erwerben.

Oder aber man nutzt eine vorhandene von einem Fernseher, DVD-Player oder Receiver. Auch einige ältere Handys verfügen über eine IR Schnittstelle, hier könnte man mit einer entsprechenden App die Signale senden.

Bezug

Dieses Multifunktionale Rich Shield habe ich über ebay.de für knapp 7 € erstanden. Mittlerweile gibt es sogar Verpackungen welche eine IR Fernbedienung enthalten.

Die Lieferung erfolgt in einer einfachen Plastikverpackung, mit Schaumstoff gepolstert.

Ein PDF Dokument mit der technischen Beschreibung der Sensoren & Aktoren, findest du auf der Seite von https://www.arduinoall.com.

Sensoren & Aktoren auf dem Shield

LEDs

Die vier, verschiedenfarbigen LEDs können jeweils über digitale Pins angesprochen werden.

//definieren der LEDs
#define LED_1 4 //LED1 rot
#define LED_2 5 //LED2 grün
#define LED_3 6 //LED3 blau
#define LED_4 7 //LED4 gelb

Sketch

Im nachfolgenden möchte ich ein einfaches Lauflicht mit den LEDs durchführen.

//definieren der LEDs
#define LED_1 4 //LED1 rot
#define LED_2 5 //LED2 grün
#define LED_3 6 //LED3 blau
#define LED_4 7 //LED4 gelb

//Array mit den Pins für die LEDs
int leds[] = {LED_1, LED_2, LED_3, LED_4};

//definieren der Werte für die Pausen 
//zwischen den einzelnen LEDs
const int LONG_PAUSE = 250;
const int SHORT_PAUSE = 75;

void setup() {
  //setzen der LED als Ausgang
  pinMode(LED_1, OUTPUT);
  pinMode(LED_2, OUTPUT);
  pinMode(LED_3, OUTPUT);
  pinMode(LED_4, OUTPUT);
}

void loop() {
  //Das Array mit den Pins für die LEDs
  //von Anfang (INDEX=0) bis zum Index 3 durchlaufen
  for(int i=0;i<4;i++){
    //aktivieren der LED
    digitalWrite(leds[i], HIGH);
    delay(LONG_PAUSE); //lange Pause
    //deaktivieren der LED
    digitalWrite(leds[i], LOW);
    delay(SHORT_PAUSE); //kleine Pause
  }

  delay(SHORT_PAUSE); //kleine Pause

  //Das Array mit den Pins für die LEDs
  //vom Ende (INDEX=3) bis zum Anfang Index 0 durchlaufen
  for(int i=3;i>=0;i--){
    //aktivieren der LED
    digitalWrite(leds[i], HIGH);
    delay(LONG_PAUSE); //lange Pause
    //deaktivieren der LED
    digitalWrite(leds[i], LOW);
    delay(SHORT_PAUSE); //kleine Pause
  }
}

Video

Piezo Buzzer

Mit dem Piezo Buzzer kann man verschiedene Töne und sogar einfach Lieder abspielen.

Sketch

Im nachfolgenden möchte ich einen kleines Sketch zeigen welches ich bereits für das Wemos D1 mini Shield: Buzzer Shield entwickelt habe. Es spielt auf dem Piezo Buzzer das Kinderlied “Alle meine Entchen.” ab.

int buzzer=3;

#define a  1136 //Note a
#define c  1915 //Note c
#define d  1700 //Note d
#define e  1519 //Note e
#define f  1432 //Note f
#define g  1275 //Note g

//Die Noten
int notes[] = {c, d, e, f, g, g,-1, a, a, a, a, g,-1, a, a, a, a, g,-1, f, f, f, f, e, e,-1, d, d, d, d, c};
//Die länge der Note
int takt[] =  {2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 2};
int tempo = 225; //Das Tempo des Liedes

void setup() {
  Serial.begin(9600); //Begin der seriellen Kommunikation mit 9600 Baud
  pinMode(buzzer, OUTPUT); //Setzen des Buzzers als Ausgangssignal
}

void loop() {  
  int numberOfNotes = sizeof(notes)/sizeof(int);
  int numberOfTakt = sizeof(takt)/sizeof(int);
  if(numberOfNotes != numberOfTakt){
    Serial.println("Die Anzahl der Noten & Takte stimmen nicht überein!");
    return;
  }
  
  //Für jede Note im Array 
  for(int i=0; i<numberOfNotes; i++){
    int value = notes[i]; //Holen der Note aus dem Array an der Position i
    // den Takt * das Tempo
    int t = takt[i]* tempo;
    //Wenn die Note den Wert -1 hat dann
    //eine Pause einlegen
    if (notes[i] == -1) {
      delay(t);
    } else {
      //Wenn die Note nicht den Wert -1 hat
      //dann die Note wiedergeben
      playNote(value, t);  
    }
    //Eine kleine Pause zwischen den Noten.
    delay(tempo / 2); 
  }
 //Nachdem das Lied abgespielt wurde eine Pause von 5 sek. einlegen.
  delay(5000);
}

//Funktion zum abspielen einer Frequenz.
//Erwartet eine Freuqenz (tone) und eine Dauer (duration)
void playNote(int tone, int duration) {
  long dn = duration * 1000L;
  for (long i = 0; i < dn; i += tone * 2) {
    setBuzzerState(tone, HIGH);
    setBuzzerState(tone, LOW);
  }
}

void setBuzzerState(int tone, int value){
    digitalWrite(buzzer, value);
    delayMicroseconds(tone);
}

Video

Taster

Das Shield verfügt über 2 große Taster mit gelben Köpfen.

Diese Taster sind mit “K1” & “K2” beschriftet, sowie über die digitalen Pins 10 & 9 erreichbar.

Sketch

#include <Bounce2.h>

#define K1 9 //Taster K1 am digitalen Pin D9
#define K2 8 //Taster K2 am digitalen Pin D8

int index = 0;

Bounce btnK1 = Bounce(K1, 50);
Bounce btnK2 = Bounce(K2, 50);

void setup() {
  Serial.begin(9600);
  pinMode(K1, INPUT);
  pinMode(K2, INPUT);
  
  digitalWrite(K1, HIGH);  
  digitalWrite(K2, HIGH);  
}

void loop() {
  btnK1.update();
  btnK2.update();

  //Wenn der Taster K1 gedrückt wird,
  //dann soll der Index um eins erhöht erwerden.
  if(btnK1.fell()){
    index = index+1;
    Serial.println(index);
  }

  //Wenn der Taster K2 gedrückt wird,
  //dann soll der Index um eins verringert werden.
  if(btnK2.fell()){
    index = index-1;
    Serial.println(index);
  }
  
}

Video

Drehpotentiometer

Der Drehpotentiometer ist am analogen Pin A0 angeschlossen und trägt die Bezeichnung “KNOB”.

Und liefert somit Werte von 0 bis 1023. 

Sketch

Im nachfolgenden Sketch verwende ich den Drehpotentiometer, um die 4 LEDs zu steuern. Je nachdem wie der aktuelle Wert ist, wird eine der vier LEDs aktiviert.

#define KNOB A0 //Drehpotentiometer am analogen PIN A0

//definieren der LEDs
#define LED_1 4 //LED1 rot
#define LED_2 5 //LED2 grün
#define LED_3 6 //LED3 blau
#define LED_4 7 //LED4 gelb

//alle vier LEDs zu einem Array zusammenfassen
//dieses ist für das Mapping später von Vorteil.
int leds[] = {LED_1, LED_2, LED_3, LED_4};

void setup() {
  Serial.begin(9600);
  //setzen der LEDs als Ausgang
  pinMode(LED_1, OUTPUT);
  pinMode(LED_2, OUTPUT);
  pinMode(LED_3, OUTPUT);
  pinMode(LED_4, OUTPUT);
}

void loop() {
  //lesen des aktuellen Wertes am analogen Pin A0
  int value = analogRead(KNOB);
  Serial.print("analoger Wert: ");
  Serial.println(value);

  //mappen des Wertes vom Drehpotentiometers 
  //auf einen Wert zwischen 0 und 3.
  int led = map(value,0,1023,0,3);
  Serial.print("LED: ");
  Serial.println(led);

  //zurücksetzen der LEDs
  resetLEDs();
  //aktivieren der LED
  digitalWrite(leds[led], HIGH);
}

//Funktion um die LEDs wieder zurück zu setzen.
void resetLEDs(){
  digitalWrite(LED_1, LOW);
  digitalWrite(LED_2, LOW);
  digitalWrite(LED_3, LOW);
  digitalWrite(LED_4, LOW);
}

Video

4fach 7 Segmentanzeige (Tm1637)

Das Shield verfügt über eine 4fach 7 Segmentanzeige vom Typ 1637, dieses hat einen deutlichen Vorteil gegenüber dem RTC Shield von Open-Smart welches über eine Segmentanzeige vom Typ 1636 verfügt.

Für die Segmentanzeige 1637 gibt es einige Bibliotheken, welche uns die Arbeit mit diesem Modul vereinfachen und somit Zahlen und Buchstaben anzeigen lassen.

Da das Rich Shield über die Sensoren DHT11, NTC-Widerstand, Spannungs Sensor sowie eines Fotowiderstandes verfügt können wir auf diesem Display uns die Werte anzeigen lassen.

Sketch

Im nachfolgenden verwende ich die Bibliothek TM1636 welche eigentlich für das RTC Shield von Open-Smart entwickelt wurde. Jedoch funktioniert diese auch sehr gut für das mir nun vorliegende Rich Shield.

Diese Bibliothek habe ich um 2 Funktionen erweitert, um zum einen eine Uhrzeit sowie eine Zahl anzeigen zu lassen. (Dieses kann je nach Wunsch um die Buchstaben  erweitert werden.) Hierzu habe ich das separate Tutorial Arduino Lektion 89: 4fach Segmentanzeige TM1636 / TM1637 (Beispiel Zahl) auf diesen Blog veröffentlicht.

Was man hier jedoch anpassen muss, sind die Pins für CLK und DIO. Diese sind bei dem RTC & Rich Shield unterschiedlich.

#include "TM1636.h"
#include <math.h>
#include "functions.h"

//Pins für das RTC Shield
//#define CLK 7
//#define DATA 8

//Pins für das Rich Shield
#define CLK 10
#define DATA 11

double number = 0;

TM1636 tm1636(CLK, DATA);

void setup(){
  Serial.begin(9600);
  //Initialisieren der Anzeige.
  tm1636.init();
}

void loop(){      
  tm1636.display(getNumber(++number));         
  //eine kleine Pause 500ms.
  delay(25);
  if(number > 9999){
    number = 0;
  }
}

Video

NTC-Widerstand

Der NTC-Widerstand ist am analogen Pin A1 angeschlossen.

Einen NTC-Widerstand (auch als Heißleiter bezeichnet) habe ich bereits im Tutorial Arduino Lektion 84: NTC-Widerstand (Heißleiter) beschrieben. Auch das RTC Shield von Open-Smart welches ich unter Arduino Lektion 85: Multifunktionales Shield von Open-Smart beschrieben habe verfügt  unter anderem über einen NTC-Widerstand. 

Sketch

#include "TM1636.h"
#include <math.h>
#include "functions.h"

//Pins für das RTC Shield
//#define CLK 7
//#define DATA 8

//Pins für das Rich Shield
#define CLK 10
#define DATA 11

TM1636 tm1636(CLK, DATA);

//An welchem analogen Pin der NTC-Widerstand angeschlossen ist
#define PIN A1 

const int ntcWiderstand = 10000; // NTC-Widerstand mit 10 kOhm
const int MAX_ANALOG_VALUE = 1023;


void setup(){
  Serial.begin(9600);
  //Initialisieren der Anzeige.
  tm1636.init();
}

void loop(){      
  double analogValue = analogRead(PIN);
  
  // Konvertieren des analogen Wertes in ein Widerstandswert
  double resistorValue = (MAX_ANALOG_VALUE / analogValue)- 1; 
  resistorValue = ntcWiderstand / resistorValue;

  double kelvin = convert2TempKelvin(analogValue);
  double celsius = convertKelvin2TempCelsius(kelvin);
    
  tm1636.display(getNumber(celsius));         
  
  delay(1000); //eine kleine Pause 1sek.
}

double convert2TempKelvin(float value){
  double temp = log(((10240000/value) - ntcWiderstand));
  temp = 1 / (0.001129148 + (0.000234125 * temp) + (0.0000000876741 * temp * temp * temp));
  return temp;
}

double convertKelvin2TempCelsius(double kelvin){
 return kelvin - 273.15;
}

Download

Fotowiderstand

Der Fotowiderstand ist am analogen Pin A2 angeschlossen. In einem früheren Tutorial habe ich bereits eine kleine Schaltung mit einem Fotowiderstand erzeugt und auch das RTC Shield von Open-Smart besitzt ein solches Bauteil.

Download

Video

DHT11 Sensor

Der DHT11 Sensor kann die Temperatur und die relative Luftfeuchtigkeit messen. Diesen Sensor (und den großen Bruder DHT22) habe ich bereits im Tutorial Arduino Lektion 6: Sensor DHT11, Temperatur und relative Luftfeuchtigkeit messen erläutert. In diesem Abschnitt möchte ich nun darauf eingehen wie dieser Sensor am Rich Shield betrieben werden kann.

Der DHT11 Sensor ist über den digitalen Pin D12 angeschlossen.

Sketch – auslesen & Ausgabe auf dem seriellen Monitor

Im nachfolgenden Sketch möchte ich zeigen wie man mit der Adafruit DHT11 Bibliothek den DHT11 Sensor auslesen und die Werte auf dem seriellen Monitor ausgeben kann. 

Für diesen Sketch benötigst du neben der Bibliothek “DHT sensor library by Adafruit Version 1.3.3” auch zusätzlich die Adafruit Sensor Bibliothek welche du auf dem GitHub Repository von Adafruit herunterladen kannst.

#include "DHT.h"

//der DHT11 Sensor ist am digitalen Pin D12 angeschlossen
#define DHTPIN 12    


#define DHTTYPE DHT11 


DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  Serial.println("DHT11 Sensortest");
  Serial.println("****************");
  Serial.println("");
  dht.begin();
}

void loop() {
  //Der DHT11 Sensor liefert alle 1,5 Sekunden einen neuen Wert.
  delay(1500); //kleine Pause von 1,5 sek.

  //auslesen der relativen Luftfeuchtigkeit
  float luftfeuchtigkeit = dht.readHumidity();
  
  //auslesen der Temepratur in Celsius
  float temperaturCelsius = dht.readTemperature();
  //Wenn man der Funktion ein true übergibt, 
  //erhält man den Wert in Fahrenheit.

  //Prüfen ob gültige Zahlenwerte gelesen wurden, wenn
  //dieses nicht so ist dann soll eine Fehlermeldung ausgegeben
  //werden und die loop an der Stelle verlassen werden.
  if (isnan(luftfeuchtigkeit) || isnan(temperaturCelsius)) {
    Serial.println("Fehler beim lesen des DHT11 Sensors");
    return;
  }

  //ausgeben des Wertes für die relative Luftfeuchtigkeit
  Serial.print("relative Luftfeuchtigkeit: ");
  Serial.print(luftfeuchtigkeit);
  Serial.println("%");

  //ausgeben des Wertes für die Temperatur in Celsius
  Serial.print("Temperatur: ");
  Serial.print(temperaturCelsius);
  Serial.println("°C");
}

Video

Sketch – ausgeben der Temperatur und der relativen Luftfeuchtigkeit auf der 4fach 7 Segmentanzeige

Da das Rich Shield neben dem DHT11 Sensor, auch über eine 4fach 7 Segmentanzeige und zwei Taster verfügt, wollen wir diese nutzen, um die Daten nicht auf den seriellen Monitor uns anzeigen zu lassen, sondern eben über diese 4fach 7 Segmentanzeige. Dazu nutzen wir die Taster um zwischen den Werten für die relative Luftfeuchtigkeit (H), der Temperatur in °C (C) und der Temperatur in °F (F) zu wechseln.

Ablauf:

Wenn der Benutzer auf den linken Taster klickt, so soll ein Index um einen Zähler hinauf (+) gezählt werden.
Wenn der Benutzer auf den rechten Taster klickt, so soll ein Index um einen Zähler hinab (-) gezählt werden.

Wenn der Index gleich 1 ist, dann soll die relative Luftfeuchtigkeit angezeigt werden.
Format der Ausgabe ist 3-stellig, ganzzahlig.
Zusätzlich wird die rote LED aktiviert.

Wenn der Index gleich 2 ist, dann soll die Temperatur in Celsius angezeigt werden.
Format der Ausgabe 3-stellig, ganzzahlig.
Zusätzlich wird die grüne LED aktiviert.

Wenn der Index gleich 3 ist, dann soll die Temperatur in Fahrenheit angezeigt werden.
Format der Ausgabe 3-stellig, ganzzahlig.
Zusätzlich wird die blaue LED aktiviert.

Download

Video

In dem Video kommt leider die Helligkeit der grünen LED nicht so ganz zur Geltung.

Infrarot Diode (IR-Empfänger)

Die Infrarot Diode auf dem Rich Shield ist am digitalen Pin D3 angeschlossen.

Eine Schaltung mit einer Infrarot Diode habe ich bereits in dem Tutorial Arduino Lektion 20: IR Fernbedienung auslesen ausführlich erläutert.

Sketch

Zunächst einmal muss man die verwendete IR Fernbedienung auslesen, hier hat jede Taste ihren eigenen Code. Der Einfachheit lasse ich mir diese Werte auf dem seriellen Monitor der Arduino IDE ausgeben.

#include <IRremote.h>

#define IR_DIODE 2 //IR Diode am digitalen Pin D2

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

void setup() {   
  pinMode(IR_DIODE, 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.
      Serial.println(results.value);      
      irrecv.resume(); // auf den nächsten Wert warten
 }
}

Für den nachfolgenden Sketch verwende ich nun eine einfache Fernbedienung welche über ebay.de für knapp 4 € inkl. Versandkosten erstanden werden kann.

Folgende Funktionen möchte ich mit der Fernbedienung ausführen:

• Taste 1 – LED1 aktivieren / deaktivieren
• Taste 2 – LED2 aktivieren / deaktivieren
• Taste 3 – LED3 aktivieren / deaktivieren
• Taste 4 – LED4 aktivieren / deaktivieren

#include <IRremote.h>

#define IR_DIODE 2 //IR Diode am digitalen Pin D2

//definieren der LEDs 
#define LED_1 4 //LED1 rot 
#define LED_2 5 //LED2 grün 
#define LED_3 6 //LED3 blau 
#define LED_4 7 //LED4 gelb

int led1Status = 0;
int led2Status = 0;
int led3Status = 0;
int led4Status = 0;

const int TASTE_1 = 12495;
const int TASTE_2 = 6375;
const int TASTE_3 = 31365;
const int TASTE_4 = 4335;
const int MAGIC_NUMBER = -1;

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

void setup() {
  pinMode(LED_1, OUTPUT);
  pinMode(LED_2, OUTPUT);
  pinMode(LED_3, OUTPUT);
  pinMode(LED_4, OUTPUT);
      
  pinMode(IR_DIODE, 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;
      switch(value){
       case TASTE_1: toggleLED(LED_1, led1Status); break;
       case TASTE_2: toggleLED(LED_2, led2Status); break;
       case TASTE_3: toggleLED(LED_3, led3Status); break;
       case TASTE_4: toggleLED(LED_4, led4Status); break;
       case MAGIC_NUMBER: break; //Nichts machen wenn die Zahl ausgegeben wird.
      }
      irrecv.resume(); // auf den nächsten Wert warten
 }
}

void toggleLED(int pin, int ledStatus){
  int newLedStatus = ledStatus == LOW ? HIGH : LOW;
  switch(pin){
    case LED_1: led1Status= newLedStatus; break;
    case LED_2: led2Status= newLedStatus; break;
    case LED_3: led3Status= newLedStatus; break;
    case LED_4: led4Status= newLedStatus; break;
  }
  Serial.print("LED an Pin ");
  Serial.print(pin);
  Serial.print(newLedStatus==HIGH?" aktivieren":" deaktivieren");
  Serial.println("!");
  digitalWrite(pin, newLedStatus);
}

Video

Spannungsmesser

Der Spannungsmesser am Rich Shield ist über eine kleine Schraubklemme zu erreichen.

Es gibt leider keine Angabe welcher Spannungsbereich gemessen werden kann. Jedoch gibt es von Open-Smart den Spannungssensor auch einzeln zu erwerben und dieser hat einen Messbereich <25V somit gehe ich aktuell davon aus das dieses auch bei diesem Model so sein wird. Jedoch möchte ich dieses nicht testen um mir ggf. das Board oder den Microcontroller nicht zu zerstören.

Sketch

Ich habe bereits einen Spannungssensor im Tutorial Arduino Lektion 54: Spannungssensor ausführlich beschrieben, jedoch ist dieser Sensor etwas anders aufgebaut und verfügt über andere Widerstände.

• R11 mit 180kOhm,
• R7 mit 820kOhm

#define SENSOR A3
const float R1 = 820000.0f; //  Der Widerstand R2 hat eine größe von 820 kOhm
const float R2 = 180000.0f; // Der Widerstand R1 hat eine größe von 180 kOhm
const float MAX_VIN = 5.0f;
void setup(){
   Serial.begin(9600);
   pinMode(SENSOR, INPUT);
}
void loop(){
  float vout = (analogRead(SENSOR) * MAX_VIN) / 1024.0f;
  float vin = vout / (R2/(R1+R2)); 
   
  Serial.print("Eingangsspannung ");
  Serial.print(vin,2);
  Serial.println("V");
  delay(500);
}

Video

Multifunktionale Shields

Mit diesem Rich Shield habe ich nun das 4. Multifunktionale Shield vorgestellt.

• Arduino Lektion 36: Multifunktionales Shield
• Arduino Lektion 57: Multifunktionales Shield (Teil2)
• Arduino Lektion 85: Multifunktionales Shield von Open-Smart