http://555circuitslab.com
https://oshpark.com/shared_projects/HOyjPT7S

​Abbildung 14.2 zeigt die Grundschaltung des Sensor-Boards. Die Schaltung ist auf ein Minimum reduziert und ähnelt der Minimalschaltung aus Kapitel 1.

Auf dem ATmega328-Microcontroller ist wie auf allen Arduino-Boards ein Bootloader installiert. Programme werden in dieser Schaltung über den FTDI-Anschluss (K2) und einen USB-Serial-Wandler oder den Programmieranschluss ICSP (K3) und einen Programmieradapter, beispielsweise ein AVRISP mkII (http://www.atmel.com/tools/AVRISPMKII.aspx), hochgeladen.

Die Versorgungsspannung von 3,3 V oder 5 V wird direkt am Stecker K1 angeschlossen.

Die Eingänge und Ausgänge des Sensor-Boards sind auf die Stiftleisten K4 bis K7 geführt. Auf der Leiterplatte sind dabei die Signalbezeichnungen gemäß Arduino-Standard aufgedruckt. Das Signal PD0 des Microcontrollers ist beispielsweise der digitale Ein- oder Ausgang D0, der in der Praxis als Signal RX verwendet wird.

Die Taktfrequenz kann je nach Bedarf gewählt werden. Bei einem Sensor-Board mit 8 MHz kann der Quarz mit den Kondensatoren (Q1) weggelassen werden. Hier ist zu beachten, dass in diesem Fall ein spezieller Bootloader geladen und in der IDE ein anderes Board, ATmega328 on a breadboard (8 MHz internal clock), ausgewählt werden muss. Im nachfolgenden Abschnitt werden der Grund und der Einsatz eines Boards mit einer Taktfrequenz von 8 MHz beschrieben.

Die Konfiguration dieses 8-MHz-Boards kann von der Arduino-Website geladen werden.

https://www.arduino.cc/en/uploads/Tutorial/breadboard-1-6-x.zip

Auf derselben Webseite sind weitere Erklärungen zu dieser Board-Variante beschrieben.

https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard

Mit dem Bestückungsplan aus Abbildung 14.3 gelingt der Aufbau des Sensor-Boards auch einem Einsteiger. Im ersten Schritt lötet man die SMD-Komponenten auf das Board, anschließend den IC-Sockel für den Microcontroller und, je nach Bedarf, die einzelnen Stiftleisten.

​Die Programmierung des Sensor-Boards kann auf zwei verschiedene Arten erfolgen, wobei bei beiden Arten ein zusätzlicher externer Adapter benötigt wird:

• via FTDI-Stecker (K2)

• via ICSP-Anschluss (K3)

Für Programmierung über den FTDI-Stecker wird ein sogenannter USB-Serial-Adapter benötigt, da auf dem Sensor-Board keine USB-Schnittstelle zur Verfügung steht. Dieser kleine Wandler ist das Bindeglied zwischen dem USB-Anschluss des Rechners und dem Microcontroller auf dem Sensor-Board.

Diese USB-Serial-Wandler, oft auch als FTDI-Wandler benannt, gibt es als Leiterplatten- oder als Kabel-Version.

In Abbildung 14.4 sind die beiden Varianten dargestellt, links die Leiterplattenvariante und rechts das sogenannte FTDI-Kabel.

Beide Versionen dieses USB-Serial-Wandlers werden am 6-poligen FTDI-Anschluss des Sensor-Boards angeschlossen (Abbildung 14.5).

Diese Adapter sind recht günstig und bei verschiedenen Händlern verfügbar.

Für die Programmierung des Sensor-Boards via ICSP-Anschluss (K3) ist ein externes Programmiergerät erforderlich. Das Programmiergerät wird am 2x3-poligen Anschluss mit der Bezeichnung ICSP angeschlossen.

Der Programmupload über den ICSP-Anschluss erfolgt via SPI-Schnittstelle und erfordert keinen Arduino-Bootloader auf dem Microcontroller des Sensor-Boards.

Mögliche Programmieradapter sind:

https://learn.adafruit.com/usbtinyisp

http://www.atmel.com/tools/avrispmkii.aspx

https://www.arduino.cc/en/Tutorial/ArduinoISP

Um den Stromverbrauch eines Arduino-Boards so gering wie möglich zu halten, sollten auf dem Board folgende Punkte in Betracht gezogen werden:

• Unnötige Hardware entfernen

• Keine LED oder Anzeige-Elemente im Dauerbetrieb

• Betriebsspannung minimieren

• Taktfrequenz minimieren

• Nicht verwendete Funktionen im Microcontroller deaktivieren

• Software für Sleep-Funktionen einsetzen

Das Standard-Board Arduino Uno eignet sich nicht optimal für den Batteriebetrieb​, da die oben aufgelisteten Punkte nicht ohne Aufwand umgesetzt werden können.

https://github.com/rocketscream/Low-Power/

https://github.com/jcw/jeelib

http://jeelabs.org/2011/12/13/developing-a-low-power-sketch/

Das Sensor-Board aus dem ersten Teil dieses Kapitels ist speziell für batteriebetriebene Sensor-Anwendungen realisiert, um Sensordaten zu erfassen und anschließend weiterzuverarbeiten oder weiterzusenden.

Für den Batteriebetrieb​ und die Phasen, in denen keine Sensordaten eingelesen oder verarbeitet werden, kann das Board mit der Low-Power-Library in den Sleep-Mode versetzt werden. Sensordaten werden meist in einem längeren Rhythmus abgefragt.

In diesem Beispiel verwenden wir den längsten Rhythmus der Bibliothek und lassen das Board jeweils für acht Sekunden im Sleep-Modus.

Im ersten Schritt wird im Programmcode die nötige Bibliothek geladen.

//
// Sensor-Board im Low-Power-Betrieb
//
 
#include "LowPower.h"

In der Setup-Funktion sind keine Aktionen nötig. Die serielle Schnittstelle wird nicht gestartet.

void setup()
{
  // keine Funktionen notwendig  
}

Im Hauptprogramm startet der Programmdurchlauf mit der Sleep-Phase von acht Sekunden.

void loop()
{
  // Sleep-Modus für 8 Sekunden, ADC aus, BOD aus
  LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);

Anschließend kann das Sensor-Board nach der Pause Sensorwerte verarbeiten oder andere Funktionen ausführen.

  // Sensorwerte weiterverarbeiten, beispielsweise Daten senden oder speichern
  //..
}

Bis es anschließend im nächsten Programmdurchlauf wieder in den Sleep-Mode gesetzt wird.

Die Sleep-Funktion der JeeLib-Bibliothek kann grundsätzlich wie die Delay-Funktion delay() eingesetzt werden. Dazu wird folgende Funktion verwendet:

Sleepy::loseSomeTime(Zeit_in_Millisekunden);

Um diese Sleep-Funktion zu nutzen, muss die JeeLib-Bibliothek geladen werden.

#include <JeeLib.h>

Nun muss ein Stück Code eingefügt werden, um Run-Time-Fehler abzufangen.

ISR(WDT_vect) { Sleepy::watchdogEvent(); }

Nach der Deklaration der benötigten Variablen

int valSensor;
int SensorPin=0;
int LEDPin=6;

werden in der Setup-Funktion nötige Voreinstellungen gemacht. In diesem Beispiel wird der Ausgang für die LED gesetzt.

void setup()
{
  // LED-Ausgang setzen
  pinMode(LEDPin, OUTPUT);
}

Im Hauptprogramm kann nun die eigentliche Funktionalität unseres Sensor-Boards ausgeführt werden. Im Beispiel wird zuerst ein Analogwert am Eingang A0 eingelesen.

void loop()
{
  // Analogwert einlesen
  valSensor = analogRead(SensorPin);

Danach können weitere Funktionen ausgeführt werden. Als Beispiel wird kurz die Leuchtdiode ein- und dann wieder ausgeschaltet.

// Sensorwert weiterverarbeiten
  // ...
  // Anzeige Messvorgang
  digitalWrite(LEDPin, HIGH);
  Sleepy::loseSomeTime(100);
  digitalWrite(LEDPin,LOW);

Die kurze Verzögerungszeit zwischen Ein- und Ausschalten der LED wird mit der Sleep-Funktion Sleepy::loseSomeTime(100) ausgeführt.

Anschließend wird das Board für 10000 Millisekunden, das entspricht zehn Sekunden, in den Sleep-Mode versetzt.

  // Sleep-Modus für 10 Sekunden
  Sleepy::loseSomeTime(10000);
}

Die maximale Sleep-Dauer kann maximal 60 Sekunden, also 60000 Millisekunden betragen. Falls Sie eine längere Sleep-Dauer benötigen, können Sie, gemäß dem Entwickler der JeeLib-Bibliothek, eine For-Schleife ausführen.

for (byte i = 0; i < 120; ++i)
      Sleepy::loseSomeTime(60000);

Mit 120 Durchläufen bekommt man so eine Verzögerung von 120 Minuten.

• 1 Leiterplatte Sensor-Shield, Rev. A (http://555circuitslab.com/)

• 2 Headerleiste 6-polig (JP1, JP2)

• 2 Headerleisten 8-polig (JP3, JP4)

• 5 Grove-Stecker 4-polig (J1, J2, J3, J4, J5)

• 1 Stiftleiste 4-polig (DHTx, JP8)

• 4 Widerstände 1 kOhm (R4, R5, R6, R7)

• 1 Widerstand 4,7 kOhm (R3)

• 2 Widerstände 10 kOhm (R1, R2)

• 1 RGB-LED 5 mm (RGB)

• 1 LED grün 3 mm (PWR)

Die Ansteuerung der RGB-LED erfolgt über drei Anschluss-Pads. Wie bereits erwähnt, können die drei internen Leuchtdioden über ein GND-Signal angesteuert werden. In der Praxis führt man die drei Anschlüsse der RGB-Leuchtdiode auf freie digitale Pins. Im Beispiel werden die Pins D9, D10 und D11 verwendet (Abbildung 13.4).

Über die 4-polige Stiftleiste kann direkt ein Umweltsensor der DHT-Reihe angeschlossen werden. Die Anwendung mit dem DHT-Sensor ist in Abschnitt 9.1.1 beschrieben.

Anschlussmöglichkeit für zwei digitale Grove-Module.

Auf dem Grove-Stecker sind folgende Signale angeschlossen (Tabelle 13.1).

Anschlussmöglichkeit für zwei Grove-Sensoren, die über den I2C-Bus angesteuert werden. Die I2C-Bus-Leitungen sind auf die Anschluss-Pins A4 (SCA) und A5 (SCL) geführt.

Auf dem Grove-Stecker sind folgende Signale angeschlossen (Tabelle 13.2).

Beispiele für passende Grove-Module mit I2C sind:

Barometer-Sensor

http://www.seeedstudio.com/wiki/Grove_-_Barometer_Sensor

OLED-Display

http://www.seeedstudio.com/wiki/Grove_-_OLED_Display_96*96

Anschlussmöglichkeit für ein analoges Grove-Modul.

Auf dem Grove-Stecker sind folgende Signale angeschlossen (Tabelle 13.3).

Beispiele für passende analoge Grove-Module:

http://www.seeedstudio.com/wiki/Grove_-_Air_Quality_Sensor_v1.3

http://www.seeedstudio.com/wiki/Grove_-_Loudness_Sensor

Anschlussmöglichkeit für einen externen NTC-Temperatursensor.

Anschlussmöglichkeit für einen externen Fotowiderstand (LDR).

Die jeweils drei Lötpads mit +5 V und GND liefern die Versorgungsspannung für eigene Anwendungen.

Die freien Lötpads der Prototypenfläche können für eigene Schaltungen und Funktionen verwendet werden.

Die Ansteuerung der RGB-LED erfolgt mittels der digitalen Pins D9, D10 und D11. Wie bereits erwähnt, müssen dazu die drei Signale mit der RGB-Leuchtdiode gemäß Abbildung 13.4 verdrahtet werden.

Für die Darstellung einer Farbe muss nun der sogenannte RGB-Code mit den Farbwerten für Rot, Gelb und Blau übergeben werden. Dabei wird für die Ansteuerung die Funktion setColor() verwendet. Im Funktionsaufruf werden die Farbwerte für die drei Farben übergeben.

​setColor(Wert Rot, Wert Grün, Wert Blau);

In der Funktion selbst werden die im Funktionsaufruf übergebenen Farbwerte als PWM-Signal ausgegeben. Da die RGB-LED als Common-Anode-Typ mit einem LOW-Signal leuchtet, muss auch der PWM-Wert invertiert werden. Dazu wird der Farbwert von 255 subtrahiert.

void setColor(int red, int green, int blue)
{
  // RGB-Werte ausgeben
  analogWrite(redPin, 255-red);
  analogWrite(greenPin, 255-green);
  analogWrite(bluePin, 255-blue);
}

Möchten Sie beispielsweise die RGB-LED in der Farbe Violett darstellen, sieht der Aufruf wie folgt aus:

setColor(200, 0, 255);

Listing 13.1 zeigt die Ansteuerung der RGB-Leuchtdiode und die Darstellung von verschiedenen Farben.

int redPin = 9;
int greenPin = 10;
int bluePin = 11;
 
void setup()
{
  // Pins als Ausgänge setzen
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}
 
void loop()
{
  // gelb
  setColor(250, 105, 0);
  delay(1000);
 
  // orange
  setColor(250, 40, 0);
  delay(1000);
 
  // rot
  setColor(255, 0, 0);
  delay(1000);
 
  // blau
  setColor(10, 10, 255);
  delay(1000);
 
  // pink
  setColor(255, 0, 100);
  delay(1000);
 
  // violett
  setColor(200, 0, 255);
  delay(1000);
 
  // grün
  setColor(0, 255, 0);
  delay(1000);
 
  // weiss
  setColor(255, 255, 255);
  delay(1000);}
 
void setColor(int red, int green, int blue)
{
  // RGB-Werte ausgeben
  analogWrite(redPin, 255-red);
  analogWrite(greenPin, 255-green);
  analogWrite(bluePin, 255-blue);
}

Listing 13.1: Farben ausgeben mit RGB-LED

Die auf dem Sensor-Shield integrierte RGB-LED kann als Anzeige-Element für viele Anwendungsfälle verwendet werden. Bekanntlich kann die RGB-Leuchtdiode einen großen Farbbereich darstellen und eignet sich somit ideal als optisches Display für verschiedene Mess- oder Sensorwerte.

​Dieses Projekt beschreibt einen kleinen optischen Monitor, der den gemessenen Analogwert nicht als absolute Zahl, sondern als Farbe ausgibt. Der Farbbereich ist in zwölf Stufen aufgeteilt. Abbildung 13.5 zeigt die Farbe als sogenanntes »RGB Color Wheel«.

Bei jeder Farbe ist zusätzlich der RGB-Code der Farbe angegeben, der später im Programmcode verwendet wird, um die jeweilige Farbe darzustellen.

​Der RGB-Monitor wandelt einen am Analogeingang (A0) gemessenen Analog-Wert in eine Farbe des »Color Wheels« um. Der Messbereich beträgt dabei 0 bis 5 Volt und kann von einem Sensor oder einem anderen Teil der Schaltung geliefert werden. Im Beispiel wird die Spannung mittels eines verstellbaren Widerstands, Potenziometer genannt, generiert.

int color=12;
int colorValue=3;

int redPin = 9;
int greenPin = 10;
int bluePin = 11;

int TempPin = 0;
int valA0=0;
int valAmap=0;

int ledRGB[12][3] = {
  {255, 0, 0}, 
  {255, 127, 0}, 
  {255, 255, 0},
  {127, 255, 0},
  {0, 255, 0},
  {0, 255, 127},
  {0, 255, 255},
  {0, 127, 255},
  {0, 0, 255},
  {127, 0, 255},
  {255, 0, 255},
  {255, 0, 127}
  };

void setup()
{
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  Serial.begin(9600);
  Serial.print("RGB Matrix..");
}

void loop()
{
  // Analogwert einlesen
  valA0=analogRead(TempPin);
  valAmap=map(valA0, 0, 1023, 0, 11);

  // Werte RGB Color
  // LED rot
  int colR=ledRGB[valAmap][0];
  // LED grün
  int colG=ledRGB[valAmap][1];
  // LED blau
  int colB=ledRGB[valAmap][2];

  // Ausgabe Wert
  Serial.println(valAmap);

  setColor(colR, colG, colB);

void setColor(int red, int green, int blue)
{

  red=255-red;
  green=255-green;
  blue=255-blue;

  analogWrite(redPin, red);
  analogWrite(greenPin, green);
  analogWrite(bluePin, blue);
}

int color=12;
int colorValue=3;
 
int redPin = 9;
int greenPin = 10;
int bluePin = 11;
 
int TempPin = 0;
 
int valA0=0;
int valAmap=0;
 
int ledRGB[12][3] = {
  {255, 0, 0}, 
  {255, 127, 0}, 
  {255, 255, 0},
  {127, 255, 0},
  {0, 255, 0},
  {0, 255, 127},
  {0, 255, 255},
  {0, 127, 255},
  {0, 0, 255},
  {127, 0, 255},
  {255, 0, 255},
  {255, 0, 127}
  };
 
void setup()
{
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  Serial.begin(9600);
  Serial.print("RGB Matrix..");
}
 
void loop()
{
  // Analogwert einlesen
  valA0=analogRead(TempPin);
  valAmap=map(valA0, 0, 1023, 0, 11);
  // Werte RGB Color
  // LED rot
  int colR=ledRGB[valAmap][0];
  // LED grün
  int colG=ledRGB[valAmap][1];
  // LED blau
  int colB=ledRGB[valAmap][2];
  // Ausgabe Wert
  Serial.println(valAmap);
  // Ansteuerung RGB
  setColor(colR, colG, colB);
  delay(50);
}
 
void setColor(int red, int green, int blue)
{
  red=255-red;
  green=255-green;
  blue=255-blue;
  analogWrite(redPin, red);
  analogWrite(greenPin, green);
  analogWrite(bluePin, blue);
}