Smart Cube: Die nächste Generation der Smart-Home-Steuerung

Komponenten und Zubehör

Komponente	Anzahl	Hinweis
Arduino 101 (Intel Curie)	1
LEDs (generisch)	5	1 blau, 1 gelb, 1 grün, 2 rot
Widerstand 220Ω	5
Steckplatine	1	Nicht zwingend nötig
Seeed Base Shield V2	1
Seeed Grove LCD RGB Backlight	1
Seeed Grove Sound Sensor	1
Seeed Grove Buzzer	1
Seeed Grove Temperatursensor	1
Tastenfeld (Keypad) 4x3	1
Jumper-Kabel	1
9V-Blockbatterie	1
9V-Batterieclip	1
MDF-Platte 20x30 cm, 3mm	1	Für Lasercutter-Gehäuse

Benötigte Werkzeuge und Maschinen

• Lasercutter
• Lötkolben

Apps und Online-Dienste

• Arduino IDE
• Nordic Semiconductor nRF Connect SDK (optional, für BLE-Test)

Projektbeschreibung

Was ist der Smart Cube?

Der Smart Cube ist ein Controller für Ihre Smart-Home-Geräte. Heutzutage wird die intelligente Verwaltung aller Geräte im Haus zur Notwendigkeit. Wir brauchen etwas Einfaches und Intuitives. Der Smart Cube könnte die Lösung sein: ein tragbares Gerät mit Arduino 101 Board und Sensoren, das mit den Geräten und Aktoren in Ihrem Smart Home kommuniziert.

Die Innovation dieses Fernbedienungs-Würfels liegt in der Innovation des Arduino 101 Boards. Es nutzt Bluetooth Low Energy (BLE), um Lichter, Temperatur und TV zu steuern und lässt sich mit dem Smartphone synchronisieren. Die eigentliche Neuerung ist jedoch die Interaktion per Geste mittels Gyroskop und Beschleunigungssensor. Der Würfel hat 6 Seiten, jede steuert eine bestimmte Funktion. Die gewünschte Funktion wird erkannt, indem der Gyroskop die obere Seite bestimmt. Beispiel: Legen Sie den Würfel mit der „Licht-Seite“ nach oben, um das Licht im Raum einzuschalten. Schütteln Sie den Würfel, um es auszuschalten.

Wenn eine Seite für mehr als 2 Sekunden OBEN liegt und sich nicht bewegt, wird die zugehörige Funktion aktiviert. Diese Verzögerung gibt Ihnen Zeit, den Würfel zu drehen und die gewünschte Seite zu finden, ohne versehentlich andere Funktionen auszulösen. Schütteln Sie den Würfel länger als 2 Sekunden, wird die zuletzt aktivierte Funktion beendet.

Dieses Projekt hilft Ihnen, einen intelligenten Controller zu bauen. Das Gerät benötigt einen Empfänger (Smart Central in der Abbildung), der die Daten interpretiert und die Funktionen Ihres Smart Homes verwaltet. Die Haupt-Ausgabe des Würfels ist ein BLE-Signal, das vielfältig nutzbar ist: Verbinden Sie den Würfel mit einer Smartphone-App (oder bauen Sie Ihre eigene), oder bauen Sie eine Basisstation mit einem weiteren Arduino, die die BLE-Daten empfängt und direkt die Hausgeräte steuert. Da die Anwendungsfälle vielfältig sind, hängt dieser Teil von Ihren Bedürfnissen ab. In dieser Anleitung sehen wir, wie man den Smart Cube baut und wie man ihn anpasst.

Funktionen der sechs Seiten

Die Code-Struktur ist leicht anpassbar (wir analysieren den Code später), sodass Sie entscheiden können, welche Funktionen Sie steuern. Dies sind meine gewählten Funktionen:

• LICHTER: Seite OBEN → Licht im aktuellen Raum EIN (via BLE). Schütteln → Licht AUS, gelbe LED an dieser Seite leuchtet (Würfel im Dunkeln finden).
• TEMPERATUR: Seite OBEN → Klimaanlage bei Wärme / Heizung bei Kälte (via BLE). Temperatursensor misst Raumtemperatur. Blaue LED = Kühlung an (Schneeflocke), rote LED = Heizung an (Sonne).
• TIMER: Seite OBEN → Countdown auf LCD-Display starten. Buzzer als Alarm bei Ablauf. Schütteln → Timer stoppen, Restzeit anzeigen. Bei Ablauf: LCD-Farbe Blau→Rot, 3x Summer-Ton.
• TV: Seite OBEN → TV EIN. Würfel wird zur Fernbedienung. Tastenfeld (Zahlen) nur aktiv, wenn diese Seite OBEN liegt (verhindert versehentliches Drücken). Gedrückte Zahl via BLE an Zentrale, die mit TV verbunden ist. Schütteln → TV AUS.
• SOUND: Seite OBEN → LED-Helligkeit folgt Geräuschpegel (Sound-Sensor). Schütteln → Funktion beenden. (Optional: Händeklatschen als Trigger für eigene Aktionen).
• AUS (OFF): Neutralposition – nichts passiert. Zum schnellen Alles-AUS: OFF-Seite OBEN + Schütteln (wie Home-Button am Smartphone). Rote LED für Auffindbarkeit im Dunkeln.

Abweichungen vom ursprünglichen Konzept

Ursprünglich war auch IR-Kommunikation für direkte TV-Steuerung geplant. Da Arduino 101 (aktuell) die nötige IR-Bibliothek nicht unterstützt, werden die Daten via BLE an eine Station gesendet, die diese Bibliothek bereitstellt (z. B. Arduino UNO). Daher entfiel die Radio-Funktion (ähnlich TV-Seite), ersetzt durch die Sound-Sensor-Seite. Diese kann laute Geräusche (Händeklatschen) erkennen und Aktionen auslösen.

Die größte Änderung betrifft das Gehäusematerial: Statt 3D-Druck kam ein Lasercutter zum Einsatz. So lassen sich einzelne Seiten einfach austauschen, wenn man eine Funktion ändern möchte – z. B. Timer-Seite gegen „Katzenfutter-Automatik“ tauschen. Durch die Modularität muss nicht der gesamte Würfel neu gebaut werden!

Los geht's: Bauanleitung

Folgen Sie diesen Schritten für Ihren eigenen Smart Cube. Wir beginnen mit der Hardware: Zuerst die Elektronik zusammenbauen, dann das lasergeschnittene MDF-Gehäuse. Anschließend erkläre ich die Code-Funktionsweise und Anpassungsmöglichkeiten. Nach dem Hochladen des Codes auf den Arduino 101 können Sie die App herunterladen, um die BLE-Ausgabe zu sehen, oder den Würfel direkt mit Ihrem Smart Home verbinden.

Hardware – Elektronik

Starten Sie mit Ihrem Arduino 101. Dies ist der Fritzing-Schaltplan:

Setzen Sie den Grove Base Shield auf das Board und beginnen Sie mit den Verbindungen:

Keypad: Verbinden Sie die Kabel in Reihenfolge mit den Pins: 10, 8, 7, 6, 5, 4, 2.

LED-Anschlüsse:

1. Lange Beinchen (Anode) → 220Ω Widerstand → rotes Kabel (→ Pin)
2. Kurzes Beinchen (Kathode) → weißes Kabel (→ GND)
3. Alles verlöten und mit Isolierband schützen
4. Alle weißen Kabel zu einem gemeinsamen GND-Kabel zusammenlöten

Anschlüsse an Arduino: GRÜN → Pin 9, GELB → Pin 11, ROT → Pin 12, BLAU → Pin 13, ROT (OFF) → Pin A2.

Grove-Sensoren an den Shield anschließen (siehe Schaltplan im Anhang): Buzzer → D3, LCD RGB → I²C, Temperatursensor → A0, Sound-Sensor → A1.

Hardware – Gehäuse

Laden Sie die DXF-Datei für den Lasercutter herunter. Rote Linien = Gravur (Symbole der Seiten), schwarze Linien = Schnitt. Innenmaß des Würfels: 9 cm. Die Datei ist für 3mm Material ausgelegt; bei anderer Dicke anpassen (z. B. mit makercase.com).

Material: MDF (mitteldichte Faserplatte), aber anderes Material ist möglich.

Montage:

• Pappstreifen als Distanzhalter für LEDs einkleben (bündig mit Oberfläche)







• Keypad in Ausschnitt einsetzen, Schutzfolie abziehen, Pins wieder verbinden







• RGB-LCD passt perfekt in den Ausschnitt





• Batterieanschluss: Altes Netzteilgehäuse abgeschnitten, mit Batterieclip verlötet – spart Platz im Würfel

Zwischenstand – so sollte es jetzt aussehen:

Nun: Batterie anschließen, Code hochladen, Würfel schließen!

Tipp: Board und Batterie im Gehäuse fixieren, damit beim Schütteln nichts verrutscht.

Code-Struktur

Den vollständigen, ausführlich kommentierten Code finden Sie im Anhang. Laden Sie ihn per Arduino IDE hoch (Arduino 101 Support in Boardverwalter aktivieren).

Der Code ist in folgende Bereiche gegliedert:

• Bibliotheken & Variablendeklaration: CurieIMU (Beschleunigung/Gyro), CurieBLE, Wire, rgb_lcd, Keypad. Definition der BLE-Services (Automation IO, UUID 1815) und Characteristics (Digital 2A56 für Licht/Temp, Analog 2A58 für TV).
• setup(): Einmalige Initialisierung aller Pins, BLE, Gyroskop, LCD.
• loop() – vier Hauptbereiche:
  1. Orientierungserkennung (aus Arduino-Tutorial): Liest Beschleunigungswerte (X,Y,Z), bestimmt größte Komponente → 6 Orientierungen (0: Prozessor oben/Timer, 1: Prozessor unten/TV, 2: Analog-Pins unten/Temp, 3: Analog-Pins oben/OFF, 4: USB-Anschluss oben/Licht, 5: USB-Anschluss unten/Sound).
  2. Seiten-Aktivierung: Nur wenn Seite >2 Sek. OBEN liegt (millis()-Timing). Beim Wechsel der Orientierung Timer zurücksetzen. Bei Erreichen des Intervalls → entsprechende Face-Variable auf true.
  3. Schüttel-Erkennung (CurieIMU Shock Detection, 7g/2000ms): Wenn Schütteln >2 Sek. erkannt → letzte aktive Face-Funktion beenden, Face-Variable auf false.
  4. Face-Funktionen (nur bei true): Hier läuft die eigentliche Logik (BLE-Senden, LED-Steuerung, Timer-Countdown, Keypad-Abfrage, Sound-Sensor, Temp-Regelung).

Anpassung der Face-Funktionen: Innerhalb der if (faceX == true)-Blöcke können Sie die Logik ändern. Wichtig: Auch den Deaktivierungs-Code im Shake-Bereich anpassen und Face auf false setzen.

App für BLE-Test

Um die BLE-Ausgabe des Würfels zu sehen, laden Sie nRF Connect herunter:

Google Play Store

App öffnen → Geräte suchen → mit „smartcubesketch“ verbinden → drei „Automation IO“-Tabs → Continuous Data Collector starten. Wichtig: Verbindung herstellen, da Licht-, Temp- und TV-Funktionen nur bei aktiver BLE-Verbindung ausgeführt werden.

Funktionsdemo (Video)

Code hochladen, Batterie einlegen, Box schließen – und Sie haben einen SMART CUBE! Ein Video zeigt alle Funktionen im Einsatz.

Fazit & Ausblick

Dieses Projekt ist der erste Schritt zu einem smarten Zuhause. Ziel war es, das Potenzial des Arduino 101 (Beschleunigungssensor, Gyroskop, BLE) für mobile, intuitive Interaktion zu nutzen. Es war mein erstes funktionsfähiges Hardware-Projekt – herausfordernd, lehrreich und lohnend. Ich hoffe, dieser Guide inspiriert Sie, das Projekt an Ihre Bedürfnisse anzupassen.

Zukünftig plane ich die Zentraleinheit (Centraline), die als Brücke zwischen Smart Cube und Aktoren (Lichter, Heizung, TV…) fungiert: BLE-Signale empfangen → Aktionen im Haus ausführen.

Ich bin begeistert von Arduino 101 und dem Grove-Kit (schnelles Prototyping). Hoffentlich dient dieser Ansatz als Inspiration für Ihre Projekte. Personalisieren Sie ihn nach Ihren Wünschen – ich bin gespannt, welche Funktionen Sie erschaffen und in welchen Kontexten Sie ihn einsetzen!

Vielleicht keine Revolution, aber ein neuer Weg, mit dem Zuhause zu interagieren.

Viel Spaß beim Nachbauen – hacken Sie den Würfel!

Code

SMART CUBE – Vollständiger, kommentierter Code (Arduino)

// Bibliotheken
#include "CurieIMU.h"      // Beschleunigungsmesser & Gyroskop
#include        // Bluetooth Low Energy
#include 
#include "rgb_lcd.h"        // LCD
#include          // Keypad

rgb_lcd lcd;                // LCD Initialisierung

// Bluetooth Initialisierung:
BLEPeripheral blePeripheral; // BLE Peripheral Device (das programmierbare Board)

// BLE Services
BLEService lightsService("1815"); // BLE Automation IO (1815) - Licht-Infos
BLEService termoService("1815");  // BLE Automation IO - Temperatur-Infos
BLEService TVService("1815");     // BLE Automation IO - TV-Infos

// BLE Characteristics
BLEUnsignedCharCharacteristic lightsChar("2A56", BLERead | BLENotify); // Digital (2A56) - Licht
BLEUnsignedCharCharacteristic termoChar("2A56", BLERead | BLENotify);  // Digital - Temperatur
BLEUnsignedCharCharacteristic TVChar("2A58", BLERead | BLENotify);     // Analog (2A58) - TV

// Konstanten & Variablen:
// Orientierung & Schütteln
int lastOrientation = -1;
unsigned long previousMillis = 0;
unsigned long interval = 2000;          // Wartezeit in OBEN-Position vor Aktivierung
unsigned long SHAKEpreviousMillis = 0;
unsigned long SHAKEinterval = 2000;     // Schüttel-Dauer für Deaktivierung
boolean keep = false;                   // Verhindert Mehrfach-Aktivierung
int lastFUNCTION = -1;                  // Zuletzt aktive Funktion

// Faces Initialisierung: alle false
boolean face0 = false; // TIMER
boolean face1 = false; // TV
boolean face2 = false; // TEMPERATUR
boolean face3 = false; // OFF
boolean face4 = false; // LIGHTS
boolean face5 = false; // SOUND

// LIGHTS Face
const int LEDlights = 11;

// TEMPERATUR Face
const int pinTemp = A0;
const int LEDhot = 12;
const int LEDcold = 13;
float temperature;
int B = 3975;
float resistance;
float tooHot = 26.0;   // Klimaanlage an [ANPASSBAR]
float tooCold = 23.0;  // Heizung an [ANPASSBAR]

// TIMER Face
int BUZZER = 3;
boolean KEEPtime = false;
int TIMERmillis = 0;
int prevSHOWsecond = 0;
int CountdownInMillis = 0;
int SHOWmillis = 0;
int SHOWminute = 0;
int SHOWseconds = 0;
const int SETminute = 2;  // Timer: 2 Min [ANPASSBAR]
const int SETsecond = 30; // Timer: 30 Sek [ANPASSBAR]

// SOUND Face
const int soundLED = 9;
const int soundSENSOR = A1;
int brightness = 0;

// TV Face
const byte ROWS = 4;
const byte COLS = 3;
char keys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {10,8,7,6};
byte colPins[COLS] = {5,4,2};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

// OFF Face
const int LEDOFF = A2;

void setup() {
  pinMode(LEDlights, OUTPUT);
  pinMode(LEDhot, OUTPUT);
  pinMode(LEDcold, OUTPUT);
  pinMode(soundLED, OUTPUT);
  pinMode(LEDOFF, OUTPUT);
  Serial.begin(9600);
  CountdownInMillis = (SETminute*60 + SETsecond)*1000;
  lcd.begin(16, 2);
  lcd.setRGB(0, 0, 0);

  // IMU Initialisierung
  Serial.println("Initialisiere IMU...");
  CurieIMU.begin();
  CurieIMU.setAccelerometerRange(2);
  CurieIMU.setDetectionThreshold(CURIE_IMU_SHOCK, 7000); // 7g = 7000mg
  CurieIMU.setDetectionDuration(CURIE_IMU_SHOCK, 2000);  // 2000ms
  CurieIMU.interrupts(CURIE_IMU_SHOCK);

  // BLE Setup
  blePeripheral.setLocalName("SmartCubeSketch");
  blePeripheral.setAdvertisedServiceUuid(lightsService.uuid());
  blePeripheral.addAttribute(lightsService);
  blePeripheral.addAttribute(lightsChar);
  lightsChar.setValue(3); // 0=AUS, 1=AN, 3=Initial, 4=nicht genutzt

  blePeripheral.setAdvertisedServiceUuid(termoService.uuid());
  blePeripheral.addAttribute(termoService);
  blePeripheral.addAttribute(termoChar);
  termoChar.setValue(0); // 0=Aus, 1=Kalt an, 2=Warm an, 3=nicht genutzt

  blePeripheral.setAdvertisedServiceUuid(TVService.uuid());
  blePeripheral.addAttribute(TVService);
  blePeripheral.addAttribute(TVChar);
  TVChar.setValue('x'); // #=Taste, C=TV zu, O=TV an, x=Initial

  blePeripheral.begin();
  Serial.println("Bluetooth aktiv, warte auf Verbindungen...");
}

void loop() {
  BLECentral central = blePeripheral.central();
  unsigned long currentMillis = millis();

  // --- Orientierungserkennung (aus Arduino Tutorial) ---
  int orientation = -1;
  String orientationString;
  int x = CurieIMU.readAccelerometer(X_AXIS);
  int y = CurieIMU.readAccelerometer(Y_AXIS);
  int z = CurieIMU.readAccelerometer(Z_AXIS);
  int absX = abs(x), absY = abs(y), absZ = abs(z);

  if ((absZ > absX) && (absZ > absY)) {
    if (z > 0) { orientationString = "up"; orientation = 0; }
    else { orientationString = "down"; orientation = 1; }
  } else if ((absY > absX) && (absY > absZ)) {
    if (y > 0) { orientationString = "digital pins up"; orientation = 2; }
    else { orientationString = "analog pins up"; orientation = 3; }
  } else {
    if (x < 0) { orientationString = "connector up"; orientation = 4; }
    else { orientationString = "connector down"; orientation = 5; }
  }
  // Orientierungen: 0=Timer, 1=TV, 2=Temp, 3=OFF, 4=Lights, 5=Sound

  // --- Face-Aktivierung nach 2 Sek. stabiler Orientierung ---
  if (orientation != lastOrientation) {
    lastOrientation = orientation;
    previousMillis = currentMillis;
    keep = false;
  } else if (currentMillis - previousMillis > interval && keep == false && lastFUNCTION != orientation) {
    Serial.println(orientationString);
    if (orientation == 1) { face1 = true; lastFUNCTION = orientation; Serial.println("TV true"); TVChar.setValue('O'); }
    if (orientation == 4) { face4 = true; lastFUNCTION = orientation; Serial.println("LIGHTS true"); }
    if (orientation == 3) { face3 = true; lastFUNCTION = orientation; Serial.println("OFF true"); }
    if (orientation == 5) { face5 = true; lastFUNCTION = orientation; Serial.println("SOUND true"); }
    if (orientation == 2) { face2 = true; lastFUNCTION = orientation; Serial.println("TEMPERATURE true"); }
    if (orientation == 0) { face0 = true; lastFUNCTION = orientation; Serial.println("TIMER true"); if (!KEEPtime) TIMERmillis = currentMillis; }
    keep = true;
  }

  // --- Schüttel-Erkennung & Deaktivierung ---
  if (CurieIMU.getInterruptStatus(CURIE_IMU_SHOCK) && currentMillis - SHAKEpreviousMillis > SHAKEinterval) {
    Serial.println("SHAKE");
    // TV aus
    if (lastFUNCTION == 1) { TVChar.setValue('C'); Serial.println("TV false - CLOSE"); face1 = false; }
    // LIGHTS aus
    if (lastFUNCTION == 4) { if (central.connected()) { lightsChar.setValue(0); digitalWrite(LEDlights, HIGH); } Serial.println("LIGHTS false - CLOSE"); face4 = false; }
    // OFF geschüttelt = ALLES AUS
    if (lastFUNCTION == 3) {
      digitalWrite(LEDOFF, HIGH);
      TVChar.setValue('C'); Serial.println("TV false - CLOSE"); face1 = false;
      Serial.println("LIGHTS false - CLOSE");
      if (central.connected()) { lightsChar.setValue(0); digitalWrite(LEDlights, LOW); } face4 = false;
      analogWrite(soundLED, LOW); Serial.println("SOUND false - CLOSE"); face5 = false;
      if (central.connected()) { digitalWrite(LEDhot, LOW); digitalWrite(LEDcold, LOW); termoChar.setValue(0); } Serial.println("TEMPERATURE false - CLOSE"); face2 = false;
      Serial.println("TIMER false - CLOSE"); lcd.setRGB(0,0,0); lcd.clear(); KEEPtime = false; face0 = false;
      Serial.println("OFF false - CLOSE"); face3 = false;
    }
    // SOUND aus
    if (lastFUNCTION == 5) { analogWrite(soundLED, LOW); Serial.println("SOUND false - CLOSE"); face5 = false; }
    // TEMP aus
    if (lastFUNCTION == 2) { if (central.connected()) { digitalWrite(LEDhot, LOW); digitalWrite(LEDcold, LOW); termoChar.setValue(0); } Serial.println("TEMPERATURE false - CLOSE"); face2 = false; }
    // TIMER aus
    if (lastFUNCTION == 0) {
      Serial.println("TIMER false - CLOSE"); face0 = false;
      lcd.setRGB(180, 40, 0); lcd.clear(); lcd.setCursor(0,0); lcd.print("STOP AT "); lcd.setCursor(8,0); lcd.print(SHOWminute); lcd.setCursor(9,0); lcd.print(":"); lcd.setCursor(10,0); lcd.print(SHOWseconds);
      tone(BUZZER,1000,1000); delay(2000); lcd.clear(); lcd.setRGB(0,0,0); KEEPtime = false;
    }
    SHAKEpreviousMillis = currentMillis;
  }

  // --- Face-Funktionen (laufen kontinuierlich bei true) ---
  if (face1 == true) { // TV
    digitalWrite(LEDOFF, LOW);
    if (central.connected()) {
      char key = keypad.getKey();
      if (key && orientation == 1) {
        TVChar.setValue(key); Serial.println(key);
      }
    }
  }

  if (face4 == true) { // LIGHTS
    digitalWrite(LEDOFF, LOW);
    if (central.connected()) { lightsChar.setValue(1); digitalWrite(LEDlights, LOW); }
  }

  if (face3 == true) { // OFF (neutral)
    digitalWrite(LEDOFF, LOW);
  }

  if (face5 == true) { // SOUND
    digitalWrite(LEDOFF, LOW);
    long sum = 0;
    for (int i=0; i<32; i++) sum += analogRead(soundSENSOR);
    sum >>= 5;
    brightness = (sum*255)/1024;
    analogWrite(soundLED, brightness);
    delay(50);
  }

  if (face2 == true) { // TEMPERATUR
    digitalWrite(LEDOFF, LOW);
    if (central.connected()) {
      int val = analogRead(pinTemp);
      resistance = (float)(1023-val)*10000/val;
      temperature = 1/(log(resistance/10000)/B + 1/298.15) - 273.15;
      if (temperature > tooHot) { digitalWrite(LEDhot, LOW); digitalWrite(LEDcold, HIGH); termoChar.setValue(1); }
      else if (temperature < tooCold) { digitalWrite(LEDhot, HIGH); digitalWrite(LEDcold, LOW); termoChar.setValue(2); }
      else { digitalWrite(LEDhot, LOW); digitalWrite(LEDcold, LOW); termoChar.setValue(0); }
    }
  }

  if (face0 == true) { // TIMER
    digitalWrite(LEDOFF, LOW);
    SHOWmillis = (CountdownInMillis - (currentMillis - TIMERmillis))/1000;
    SHOWminute = SHOWmillis/60;
    SHOWseconds = SHOWmillis%60;
    lcd.setRGB(50, 100, 70);
    if (prevSHOWsecond != SHOWseconds) {
      lcd.clear(); lcd.setCursor(0,0); lcd.print("TIMER "); lcd.setCursor(7,0); lcd.print(SETminute); lcd.setCursor(8,0); lcd.print(":"); lcd.setCursor(9,0); lcd.print(SETsecond);
      lcd.setCursor(0,1); lcd.print(SHOWminute); lcd.setCursor(1,1); lcd.print(":"); lcd.setCursor(2,1); lcd.print(SHOWseconds);
      KEEPtime = true; prevSHOWsecond = SHOWseconds;
    }
    if (SHOWminute == 0 && SHOWseconds == 0) {
      lcd.clear(); lcd.setCursor(4,0); lcd.setRGB(180,40,0); lcd.print("TIME OUT");
      tone(BUZZER,1000,500); delay(900); tone(BUZZER,1000,500); delay(900); tone(BUZZER,1000,1000); delay(1500);
      lcd.clear(); lcd.setRGB(0,0,0); face0 = false; KEEPtime = false;
    }
  }
}

Gehäuse-Dateien (Custom Parts)

DXF-Datei für Lasercutter: smart_cube_8sVCflFmhM.dxf – 3mm MDF, schwarze Linien schneiden, rote Linien gravieren. Bei anderer Materialstärke anpassen.

PDF-Version: Gleiche Datei als PDF.

Schaltpläne

Base Shield Verbindungen (Datei: _cI0IwUsPVZ.Base shield connections)