Hitzeampel

Zum Einstieg

• Die Programmierlogik der Arduino IDE
• Motoren – der richtige für dein Projekt
• LCD – dein praktischer, bunter Bildschirm
• Temperatur- und Feuchtigkeitssensor: Wir messen Umweltdaten!
• Lichteffekte selbst erzeugen: LED-Streifen mit dem Arduino steuern

• Ladet euch die Schablonen herunter und druckt sie auf DINA4-Papier aus.
• Die Vorlagen beinhalten sowohl die Schnittlinien (in schwarzer Farbe) als auch verschiedene Hinweise (in grauer Farbe). Die grauen Linien könnt ihr beim Schneiden ignorieren.
• Als Hinweis ist auf jeder Vorlagenseite ein Maßstab zu finden. Dieser hilft euch, zu überprüfen, ob die Vorlagen auch wirklich in der richtigen Größe ausgedruckt wurden.
• Überprüft, ob die gezeichneten 10 cm auch der Realität entsprechen. Falls es Abweichungen gibt, könnt ihr in den Einstellungen des Druckers angeben, die Seiten leicht skaliert (größer oder kleiner) zu drucken. So könnt ihr die Abweichungen ausgleichen.
• Ihr könnt die Vorlagen auch nutzen, falls ihr mit einem Laser-Cutter arbeitet.
• Die Längsteile (Seite 1 der Vorlagen) sind zu groß, um auf einem DIN-A4-Blatt abgebildet zu sein. Daher müsst ihr beim Schneiden über die Ränder des Papiers hinaus gehen. Es ist genau markiert, ab welchem Punkt noch 4 cm nach außen eingehalten werden sollen. Zusätzlich bietet es die Möglichkeit, die Vorlagen anzupassen, falls dein Schuhkarton eine andere Größe hat. In dem Fall könnt ihr die Enden einfach länger oder kürzer schneiden.

• Nutzt die Vorlagen, um die Formen aus den Pappbögen herauszuschneiden. Ihr könnt sie entweder mit einer Schere aus dem Papier ausschneiden und dann mit einem Bleistift auf die Pappbögen übertragen. Oder ihr legt die Vorlage direkt auf den Pappbogen und schneidet mit einem Cutter-Messer entlang der Linien durch Papier und Pappbogen.
• Seid besonders sorgfältig. Je sauberer die Schnittkanten sind, desto besser passen die Teile nachher zusammen.

• Nun fehlen noch Aussparungen im Schuhkarton-Deckel: Legt dazu den Schuhkarton vor euch und achtet darauf, dass er sich „nach links“ öffnen lässt.
• Nehmt die Schnittvorlage und legt diese mittig und bündig mit der unteren Kante auf den geschlossenen Schuhkarton. Nun könnt ihr die Ausschnitte für das Display, die Knöpfe und das Papier ausschneiden.
• Als letzten Schritt müsst ihr noch das Papier, das sich im Sichtfenster der Hitzeampel bewegen soll, ausschneiden. Dazu könnt ihr das Rechteck direkt auf der Vorlage mit einer Schere oder einem Cutter herausschneiden.

Ihr habt alle Einzelteile ausgeschnitten? Super, dann könnt ihr nun die Innenstruktur zusammenbauen. Dabei steckt ihr alle Pappteile so zusammen, wie es auf den Bildern gezeigt wird.

• Wenn die Teile zu locker sitzen, könnt ihr sie auch mit Heißkleber zusammenkleben. So bekommt die Struktur mehr Stabilität.
• Wie auch im Video zu sehen, bildet die Innenstruktur verschiedene Hohlräume, in die die elektronischen Komponenten eingesetzt werden.
• Als nächstes setzt ihr das Innenskelett in den Karton ein. Falls nötig, fixiert es mit Heißkleber.
• Achtet dabei darauf, dass der Karton, wie auf dem Bild, „nach links“ geöffnet werden kann und die Innenstruktur in der richtigen Richtung eingesetzt wird.

• Als Erstes verbindet ihr den Mikrocontroller mit dem Grove Shield und setzt beides zusammen in den entsprechenden Hohlraum in der Innenstruktur.
• Achtet dabei darauf, dass alle Pins sorgfältig und bis zum Anschlag eingesteckt sind.

• Als nächstes verbindet ihr den LED-Streifen mit dem dazugehörigen Grove Verbindungskabel und setzt diesen in den gezeigten Hohlraum.
• Ihr könnt ihn auch festkleben, falls er nicht fest genug sitzt.

• Der Servomotor wird am oberen Rand der Innenstruktur, wie auf dem Bild gezeigt, direkt an die Pappe geklebt. Achtet darauf, dass die Motorachse mit dem kleinen Schlitz in der Pappe auf einer Linie liegt.
• Wie ihr seht, sind in den quer liegenden Pappteilen auch kleine Schlitze eingelassen, die als Kabelführung genutzt werden können. Hier könnt ihr vor allem die Kabel vom Servomotor und vom LED-Streifen zum Mikrocontroller führen, ohne dass sie mit anderen Komponenten in die Quere kommen.
• In der rechten, unteren Ecke sind zwei runde Aussparungen für die Führt sie von oben durch beide Löcher, um sie in der Hitzeampel zu verstauen.

• Als nächstes finalisiert ihr den Karton-Deckel. Dazu klebt ihr sowohl das LCD-Display als auch die Knöpfe in die entsprechenden Aussparungen.
• Denkt daran, erst die Kabel zu verbinden, bevor ihr sie mit dem Deckel verklebt. Es reicht, wenn ihr das LCD-Display nur an seinen Ecken mit der Pappe verklebt.

• Schließlich fehlen noch der Temperatur- und Luftfeuchtigkeitssensor, sowie der passive Buzzer. Auch die werden in die Innenstruktur eingeklebt. Die Position ist dabei nicht so wichtig. Achtet nur darauf, dass die Grove Verbindungskabel lang genug sind bis zum Mikrocontroller.
• Wir haben den Temperatur- und Luftfeuchtigkeitssensor im seitlichen Hohlraum direkt neben dem LED-Streifen und den Buzzer unten neben dem Mikrocontroller

Ihr habt alle Komponenten eingebaut? Super, dann musst du noch alle Kabel, die lose herumhängen, mit dem Mikrocontroller verbinden.

• Dafür nehmt ihr die Kabelenden und steckt diese auf das Grove Shield in die entsprechenden Steckplätze. Diese sind auch beschriftet.
• Die Zuordnung ist wie folgt:
  • LCD-Bildschirm –> I2C
    (welcher I2C-Steckplatz ist egal)
  • Temperatursensor –> D2
  • Servomotor –> D3
  • LED-Streifen –> D4
  • Passive Buzzer –> D5
  • Plus-Knopf –> D7
  • Minus-Knopf –> D8

• Damit ist die Verkabelung abgeschlossen. Um das sich bewegende Papier einzubauen, müsst ihr die Hitzeampel erst programmieren.

• Ladet die Arduino IDE von Arduino Website herunter und installiert sie auf eurem Computer.
• Mit der Software werden normalerweise alle Treiber zur Erkennung des Mikrocontrollers
• Falls ihr Probleme haben solltet, kann es sein, dass ihr die Treiber für den Seeeduino manuell installieren müsst. Informationen dazu findet ihr hier.
• Öffnet nun das Programm Arduino IDE und erstellt einen neuen „Sketch” über File –> „New Sketch“.

• Verbindet den Seeeduino Mikrocontroller mit Hilfe des Mikro-USB-Kabels mit dem Laptop oder Computer.
• Öffnet nun die Arduino IDE und wählt in der oberen grünen Menüleiste bei „Select Board” den Seeeduino
• Falls der Seeeduino nicht erkannt wird, schaut euch die Infos im Seeed-Wiki zur manuellen Installation der Board-Treiber an.

• Zunächst müssen die notwendigen Bibliotheken (Englisch: Library) installiert werden.
• Geht dazu im Menü auf „Sketch“ –> „Bibliothek einbinden“ –> „Bibliothek verwalten“ und gebt dort in der Suche folgende Bibliotheken ein und klickt dann jeweils auf „Install“:
  • Adafruit NeoPixel
  • Grove – LCD RGB Backlight
  • Grove Temperature and Humidity Sensor

Kopiert den untenstehenden Code und fügt ihn in die Arduino IDE ein.

//Bibliotheken einbinden
#include "Adafruit_NeoPixel.h" //"Adafruit NeoPixel" für die LED-Bar
#include <Wire.h>
#include "rgb_lcd.h" //"Grove - LCD RGB Backlight"
#include "Grove_Temperature_And_Humidity_Sensor.h" //"Grove Temperature And Humidity Sensor"
#include <Servo.h>

//Vorbereitungen für LED-Bar
#define PIN 4
#define NUMPIXELS 10
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

//Vorbereitungen für den Temperatur-Sensor
#define DHTTYPE DHT22 // wird ein anderer Sensor eingesetzt, muss DHT22 durch den jeweiligen Namen ersetzt werden
#define DHTPIN 2 // bei einem DHT10 oder DHT20 entfällt diese Zeile
DHT dht(DHTPIN, DHTTYPE); // und der erste Parameter "DHTPIN" in der Klammer

//Vorbereitungen für das LCD-Display
rgb_lcd lcd;

//Vorbereitungen für den Servomotor
Servo ServoMotor;

//Globale Variablen deklarieren
int colorR, colorG, colorB = 0; //Variablen für die Lichtfarben | R:Rot, G:Gruen, B:Blau

int MotorPosition = 0; //Variable für die Motor-Position
int MinMotorPos = 40; //Hier können die Grenzwerte des Motor-Bewegungsraums definiert werden
int MaxMotorPos = 130;

int Buzzer = 5; //Pin-Anschluss vom passiven Buzzer

int Taster1Pin = 7; //Pins der Taster
int Taster2Pin = 8;
bool Taster1, Taster2, Eingabe; //Variablen zum Erkennen, ob die Taster gedrückt wurden

float WunschTemp = 22; //Variable der anpassbaren Wunsch-Temperatur
int MotorTempBereich = 10; //Temperatur-Bereich in dem der Motor seine maximale Bewegung durchführt
float aktTemp, aktHum = 0; //Variablen zum Speichern der aktuellen Temperatur und Luftfeuchtigkeit
int TempVergleich = 0; // -1 zu kalt, 0 genau richtig, 1 zu warm

unsigned long Zeitstempel = 0; //Zeitstempel, der genutzt wird, um alle Aktionen zu timen
int AktionsIntervall = 2000; //in ms, die Dauer, bis eine erneute Aktion (z.B. Tonwiedergabe, Motorpositionierung, Temperaturmessung) durchgeführt wird

//******************************************************
// void setup()
//******************************************************

void setup() {
pixels.setBrightness(255);
pixels.begin();

lcd.begin(16, 2);

Wire.begin();
Serial.begin(9600);

dht.begin();

pinMode(Buzzer, OUTPUT);
pinMode(Taster1Pin, INPUT);
pinMode(Taster2Pin, INPUT);

ServoMotor.attach(3);
}

//******************************************************
// void loop()
//******************************************************

void loop() {

check_Taster();
if (Eingabe) { //wurde ein Taster gedrückt, wird die Wunsch-Temperatur entsprechend angepasst in 0.5er Schritten
WunschTemp = WunschTemp + 0.5 * (Taster1 - Taster2);
Zeitstempel = millis();
lcd.clear(); //Am Display wird die Wunsch-Temperatur-Änderung angezeigt
lcd.print(" * WunschTemp * ");
lcd.setCursor(5, 1);
lcd.print(WunschTemp);
}

if (millis() - Zeitstempel >= AktionsIntervall) { //der folgende Abschnitt wird immer exakt nach der Zeit "Aktionsintervall" ausgeführt
Zeitstempel = millis();
check_Sensor();

lcd.setCursor(0, 0); //Allgemeine Temperatur-Anzeige
lcd.print(" | Temperatur | ");
lcd.setCursor(0, 1);
lcd.print(" | | ");
lcd.setCursor(5, 1);
lcd.print(aktTemp);
lcd.print(" C");

check_MotorPosition();
ServoMotor.write(MotorPosition);

check_TempDifferenz();

switch (TempVergleich) { //je nachdem ob die Temperatur höher oder niedriger als die Wunsch-Temperatur ist, werden unterschiedliche "case" durchgeführt
case -1: //die aktuelle Temperatur ist zu kalt
colorR = 0;
colorG = 0;
colorB = 255;
BuzzerAktion(1);
break;

case 0: //die aktuelle Temperatur ist genau richtig
colorR = 0;
colorG = 255;
colorB = 0;
BuzzerAktion(0);
break;

case 1: //die aktuelle Temperatur ist zu warm
colorR = 255;
colorG = 0;
colorB = 0;
BuzzerAktion(2);
break;
}

lcd.setRGB(colorR / 5, colorG / 5, colorB / 5); //Display-Hintergrundfarbe anpassen, allerdings nur mit gedimmter Farbe
LEDchange(colorR, colorG, colorB); //LED-Farben anpassen
}
delay(10);
}

//******************************************************
// weitere Funktionen
//******************************************************

void BuzzerAktion(int Melodie) { //Hier werden Buzzer-Melodien oder Sounds zusammengestellt. Diese können oben mit der jeweiligen Nummer abgespielt werden
switch (Melodie) {
case 0:
noTone(Buzzer);
break;

case 1: //kurzes Knacken, zeigt kalte Temperatur an
tone(Buzzer, 2000);
delay(10);
noTone(Buzzer);
delay(100);
tone(Buzzer, 2000);
delay(10);
noTone(Buzzer);
delay(500);
tone(Buzzer, 2000);
delay(10);
noTone(Buzzer);
delay(100);
tone(Buzzer, 2000);
delay(10);
noTone(Buzzer);
break;

case 2: //tiefes Brummen, zeigt warme, schwere Temperaturen an
tone(Buzzer, 100);
delay(100);
noTone(Buzzer);
delay(300);
tone(Buzzer, 100);
delay(100);
noTone(Buzzer);
delay(300);
break;

default:
break;
}
}

void check_MotorPosition() { //errechnet die nächste Position des Motors anhand der aktuellen Temperatur und der Differenz zur Wunsch-Temperatur
int MinTempbereich = WunschTemp - MotorTempBereich / 2;
int MaxTempBereich = WunschTemp + MotorTempBereich / 2;
MotorPosition = map(aktTemp, MinTempbereich, MaxTempBereich, MinMotorPos, MaxMotorPos);
if (MotorPosition < MinMotorPos) {
MotorPosition = MinMotorPos;
} else if (MotorPosition > MaxMotorPos) {
MotorPosition = MaxMotorPos;
}
}

void check_Sensor() { //liest den Temperatur- und Luftfeuchtigkeitssensor aus und speichert die Variablen ab
float temp_hum_val[2] = { 0 };
if (!dht.readTempAndHumidity(temp_hum_val)) {
aktHum = temp_hum_val[0];
aktTemp = temp_hum_val[1];
} else {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("sensor-error");
delay(5000);
}
}

void LEDchange(int r, int g, int b) { //ein Makro, um immer alle LEDs gleichzeitig mit einer aktuellen Farbe umzuschalten
for (int i = 0; i < NUMPIXELS; i++) {
pixels.setPixelColor(i, r, g, b);
}
pixels.show();
}

void check_Taster() { //überprüft, ob ein Taster gedrückt wird
Taster1 = digitalRead(Taster1Pin);
Taster2 = digitalRead(Taster2Pin);
if (Taster1 || Taster2) {
Eingabe = 1;
delay(300);
} else {
Eingabe = 0;
}
}

void check_TempDifferenz() { //überprüft ob die aktuelle Temperatur über oder unter der Wunsch-Temperatur liegt
if (aktTemp > WunschTemp + 1) {
TempVergleich = 1;
} else if (aktTemp < WunschTemp - 1) {
TempVergleich = -1;
} else {
TempVergleich = 0;
}
}

• Klickt auf den Pfeil-Button in der Arduino IDE, um den Code auf den Seeeduino zu laden.
• Hat das geklappt, müsste die Hitzeampel nun endlich leuchten und funktionieren.
• Überprüft, ob das LCD-Display die aktuelle Temperatur anzeigt, und ob die Wunschtemperatur mit den Buttons eingestellt werden kann.

• Nachdem alle elektronischen Komponenten verbunden und geprüft wurden, könnt ihr die Powerbank zur Stromversorgung anschließen.
• Trennt das USB-Kabel vom Laptop und verbindet stattdessen die Powerbank mit dem
• Verstaut das Stromkabel in der vorgesehenen Aussparung. Nun kann die Hitzeampel allein – ohne zusätzlichen Laptop – genutzt werden.

• Bereitet zunächst das Papier mit dem Arm des Servomotors
• Dafür klebt ihr den Kunststoff-Arm mittig unten auf das Papier. Achtet darauf, dass die Achse nach links zeigt und dass ihr nur die Spitze des Arms mit dem Papier verklebt, so wie es im linken Bild gezeigt wird.
• Ist der Kleber vollständig ausgehärtet, bewegt den Motor in die richtige Position. Dazu stellt ihr die Wunschtemperatur mit Hilfe der Plus- und Minus-Knöpfe auf einen hohen Wert ein (mindestens 5 °C höher als die aktuelle Temperatur).
• Ihr müsstet hören, dass sich der Motor kurz nach dem Einstellen bewegt hat.
• Nun könnt ihr den Kunststoff-Arm, der mit dem Papier verklebt ist, auf die geriffelte Achse des Motors stecken. Dabei sollte der Arm in etwa 45 ° nach oben geneigt sein, wie im Video gezeigt.
• Klebt dann das untere Ende des Papiers am Pappsteg unterhalb des LED-Streifens
• Strafft dabei das Papier leicht. Zieht es aber nicht zu stark, damit der Motor nicht überlastet oder das Papier reißen könnte.

• Jetzt müsste die Hitzeampel vollständig funktionieren. Schließt den Karton und testet ein letztes Mal, ob die Hitzeampel korrekt auf Temperaturänderungen reagiert und ob ihr mit den Knöpfen die Wunschtemperatur einstellen könnt.
• Abhängig vom Unterschied zwischen der Wunschtemperatur und der gemessenen Temperatur sollte sich die Farbe ändern und das Papier bewegen.