LCD-Wecker mit vielen Gesichtern

Notwendige Werkzeuge und Maschinen

3D-Drucker (generisch)

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

Eine neue Version mit 10 Zifferblättern ist verfügbar hier .

Auf der Suche nach etwas zum Bauen entschied ich mich für eine LCD 1602 Uhr. Nachdem ich das Web durchforstet und viele verschiedene Implementierungen gefunden hatte, entschied ich mich, warum nicht eine Uhr entwickeln, die alle enthält.

Uhrfunktionen

• Acht verschiedene Anzeigestile
• Uhrzeit, aktuelles Datum, Geburtsdatum und Wecker einstellen
• Quecksilberschalter zum Ausschalten des Alarms
• Steuerung der Hintergrundbeleuchtung
• DHT21 Temperatur- und Feuchtigkeitssensor

Breadboard-Version

Die eigentliche Elektronik ist ziemlich einfach.

Laden Sie die Skizze nach der Verkabelung in Ihre Arduino-IDE und laden Sie sie auf das Arduino UNO hoch. (Nicht abgebildet ist, dass das DHT21 an D9 angeschlossen ist.)

Verwenden der Uhr

Die Uhr hat drei Tasten - SETUP, INCREMENT, DECREMENT und einen TILT-Schalter.

Wenn die Hintergrundbeleuchtung ausgeschaltet ist, wird die Hintergrundbeleuchtung durch Drücken einer beliebigen Taste eingeschaltet. Wenn bei eingeschalteter Hintergrundbeleuchtung keine Tasten gedrückt werden, schaltet sie sich nach 5 Sekunden aus. Während die Hintergrundbeleuchtung eingeschaltet ist, führen die Tasten die folgenden Aufgaben aus:

EINRICHTUNG - Dadurch werden die SETUP-Bildschirme angezeigt. Die rechte spitze Klammer ist der Cursor. Durch Drücken der Tasten INCREMENT oder DECREMENT wird der Wert, auf dem sich der Cursor befindet, erhöht bzw. verringert. Durch erneutes Drücken der SETUP-Taste wechselt der Cursor zwischen Stunden, Minuten, Tag, Monat, Jahr, Geburtstag, Geburtsmonat, Geburtsjahr, Alarmstunden, Alarmminuten und zurück zum UHR-Modus.

INKREMENT - Außerhalb der SETUP-Bildschirme schaltet diese Taste zwischen den verschiedenen Uhrenstilen um.

DEKREMENT - Wenn Sie sich nicht in den SETUP-Bildschirmen befinden, schaltet diese Taste den Alarm ein oder aus.

NEIGUNGSSCHALTER - Wenn der Alarm ertönt, wird der Alarm durch Neigen der Uhr oder Drücken einer beliebigen Taste ausgeschaltet.

Eine fertige Uhr bauen

Um Ihren Build vom Steckbrett zu einer vollständig fertigen Uhr zu machen, sind eine Leiterplatte und einige zusätzliche Komponenten erforderlich. Die Eagle-Dateien sind beigefügt, wenn Sie die Platine kommerziell herstellen lassen oder wie ich es selbst machen möchten. Ich habe die Tonermethode verwendet.

HINWEIS:Da das LCD 1602-Display über eine rechtwinklige Stiftleiste mit der Hauptplatine verbunden ist, kann es sehr schwierig sein, die Platine und das Display in das Gehäuse einzuführen, wenn sie bereits zusammengelötet sind. Wenn Sie eine doppelseitige Platine mit Durchkontaktierung haben, können Sie das Display direkt an die Platine löten.

Unter Verwendung von Teilen, die ich in der Werkstatt hatte, wurde das Arduino UNO durch einen ATMega328 DIL-Chip, einen 16-MHz-Kristall und zwei 22pf-Keramikkondensatoren ersetzt. Der 5V-Regler ist ein 7805 TO-220-Typ und ein 100uF 16V-Kondensator zur Glättung. Die RTC ist eine DS1302 mit einem 32,768 KHz Uhrenquarz. Der Lautsprecher ist ein passiver Summer, der mit einem 10uF 16V Kondensator DC isoliert ist. Die 0,1uF- und 1uF-Kondensatoren sind monolithische Keramikkondensatoren (5mm Lochabstand). Widerstände sind 5% 1/8 Watt oder Sie können 1/4 Watt verwenden, wenn Sie es wünschen. Der Quecksilberschalter kann jede beliebige Größe haben. Meins hatte einen Durchmesser von 5 mm, aber ein kleinerer reicht aus. Die drei taktilen Tasten auf der Rückseite des Boards sind 6 mm x 6 mm groß und haben einen 13 mm Schaft.

Das Gehäuse ist 3D-gedruckt mit einer Schichthöhe von 0,2 mm und ohne Stützen. Bohren Sie die Löcher für die Leiterplattenmontage mit einem 2,5-mm-Bohrer aus und erstellen Sie ein Gewinde mit einem 3-mm-Gewindebohrer. Verwenden Sie M3 6-mm-Schrauben, um die Platine zu befestigen. Ich habe auch die vier Befestigungslöcher auf der Platine auf 4 mm gebohrt, um jede Einstellung zu ermöglichen, die erforderlich ist, um zu verhindern, dass die Tasten beim Befestigen der Platine am Gehäuse kleben.

Credits

Diese Uhr ist eine Mischung aus einer Reihe von Uhren, die verschiedene Hersteller im Laufe der Jahre hergestellt haben.

Die Basis dieser Uhr ist eine Arduino-Digitaluhr mit Alarmfunktion (benutzerdefinierte Platine). Ich habe das Gehäuse so modifiziert, dass es als zwei Teile gedruckt wurde und nicht als vier.

• Standardbildschirmdesign von Michalis Vasilakis
• Dual Thick Font von Arduino World
• Dual Beveled Font vom Arduino Forum
• Dual Trek-Schriftart von Carrie Sundra
• Dual Thin Font von Arduino World
• Wortkonzept von LAGSILVA
• Biorhythmusuhr von John Bradnam
• Wetteruhr von ARDUinoautoMOTIVE

Aktualisierungen

29.06.20

- Rechtschreibfehler in der WORD-Uhr behoben
- #defines zur Steuerung der Hintergrundbeleuchtung hinzugefügt
- Zeitüberschreitung der Hintergrundbeleuchtung von 5 auf 10 Sekunden erhöht 

23.11.20

- Geburtsdatum-Setup und EEPROM-Speicher hinzugefügt
- Biorhythmus-Zifferblatt hinzugefügt
- Setup-Bildschirmcodierung aufgeräumt 

Es wird vermutet, dass Biorhythmen basierend auf unserem Geburtsdatum die Höhen und Tiefen unseres Lebens bestimmen könnten. Biorhythms umfasst drei Zyklen:einen 23-tägigen körperlichen Zyklus, einen 28-tägigen emotionalen Zyklus und einen 33-tägigen intellektuellen Zyklus. Die Biorhythmusuhr zeigt jeden Zustand als Balken an.

Der Balken zeigt an, dass sich der Biorhythmus entweder in einem positiven Zyklus (oberer Balken) oder in einem negativen Zyklus (unterer Balken) befindet. Die Länge des Balkens zeigt an, wie positiv oder negativ er im Zyklus ist.

12.06.20

- DHT21-Unterstützung hinzugefügt
- Thermometer und Luftfeuchtigkeits-Zifferblatt hinzugefügt 

Ein neues Wetterzifferblatt wurde hinzugefügt. Es liest einen DHT21 Temperatur- und Feuchtigkeitssensor, der auf der Rückseite des Gehäuses angebracht ist. Die Platine wurde aktualisiert und enthält jetzt einen 3-poligen Anschluss für den DHT21-Sensor.

Code

• DigitalClockAlarmV7.ino

DigitalClockAlarmV7.inoC/C++

/* 1602 LCD-Wecker * von John Bradnam ([email protected]) * * Display 16x2:Setup:Setup Alarm * +----------------+ +- ---------------+ +----------------+ * |HH:MM:SS | HH:MM| |>HH :>MM | | Wecker stellen | * |TT/MM/JJ | ALARM| |>TT />MM />JJJJ | |>HH :>MM | * +----------------+ +----------------+ +------------ ----+ * * 25.06.2020 * - Nahm Michalis Vasilakis 'Uhr als Codebasis (https://www.instructables.com/id/Arduino-Digital-Clock-With-Alarm-Function-custom-P/ ) * - An die Hardware angepasst - DS1302 RTC und LCD-Hintergrundbeleuchtung * - Zusätzliche Unterstützung für verschiedene Anzeigestile * - Standardbildschirmdesign von Michalis Vasilakis * - Dual Thick Font von Arduino World (https://www.hackster.io/thearduinoworld/ arduino-digital-clock-version-1-b1a328) * - Dual Bevelled Schriftart von Arduino Forum (https://forum.arduino.cc/index.php/topic,8882.0.html) * - Dual Trek Schriftart von Carrie Sundra ( https://www.alpenglowindustries.com/blog/the-big-numbers-go-marching-2x2) * - Dual Thin Font von Arduino World (https://www.hackster.io/thearduinoworld/arduino-digital-clock -version-2-5bab65) * - Wortkonzept von LAGSILVA (https://www.hackster.io/lagsilva/text-clock-bilingual-en-pt-with-arduino-881a6e) * 29.06.20 * - Rechtschreibfehler in der WORD-Uhr behoben * - #defines zur Fortsetzung hinzugefügt rol-Hintergrundbeleuchtung * - Zeitüberschreitung der Hintergrundbeleuchtung von 5 auf 10 Sekunden erhöht * 22.11.20 * - Geburtsdatum-Setup und EEPROM-Speicher hinzugefügt * - Biorhythmus-Zifferblatt hinzugefügt * - Setup-Bildschirmcodierung aufgeräumt * xx/xx/21 * - DHT21 hinzugefügt Unterstützung * - Zifferblatt für Thermometer und Feuchtigkeit hinzugefügt *///Libraries#include #include #include #include #include # fügen Sie //Kommentar ein, wenn die Dual-Dick- oder Thin-Display-Variante das 12-Stunden-Format anzeigen soll//#define DUAL_THICK_12HR//#define DUAL_THIN_12HR//uncomment to control backlight//#define NO_BACKLIGHT//#define BACKLIGHT_ALWAYS_ON# definiere BACKLIGHT_TIMEOUT 10000//Kommentar entfernen um Biorhythmus-Graphen zu testen//#define TEST_BIO_GRAPHS#define LIGHT 2 //PD2#define LCD_D7 3 //PD3#define LCD_D6 4 //PD4#define LCD_D5 5 //PD5#define LCD_D4 6 //PD6 #define LCD_E 7 //PD7#define LCD_RS 8 //PB0#define BTN_SET A0 //PC0#define BTN_ADJUST A1 //PC1#define BTN_ALARM A2 //PC2#define BTN_TILT A3 //PC3#define SPEAKER 11 //PB3# Definiere DHT 21 9 //PB1#define RTC_CE 10 //PB2#define RTC_IO 12 //PB4#define RTC_SCLK 13 //PB5//Verbindungen und Konstanten LiquidCrystal lcd(LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7);DS1302RTC rtc( RTC_CE, RTC_IO, RTC_SCLK);dht DHT;char daysOfTheWeek[7][12] ={"Sunday","Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};const int monthDays[12] ={ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };langes Intervall =300; int melody[] ={ 600, 800, 1000,1200 }; //Variablesint DD, MM, YY, H, M, S, temp, hum, set_state, adjust_state, alarm_state, AH, AM, shake_state, BY, BM, BD;int shakeTimes =0;int i =0;String sDD;String sMM;String sYY;String sH;String sM;String sS;String sBD;String sBM;String sBY;String aH="12";String aM=" 00";String sTMP;String sHUM;//String alarm =" ";long prevAlarmMillis =0;long prevDhtMillis =0;//Boolean flagsboolean setupScreen =false;boolean alarmON=false;boolean turnItOn =false;enum STYLE { STANDARD, DUAL_THICK, DUAL_BEVEL, DUAL_TREK, DUAL_THIN, WORD, BIO, THERMO };STYLE currentStyle =STANDARD;enum SETUP { CLOCK, TIME_HOUR, TIME_MIN, TIME_DAY, TIME_MONTH, TIME_YEAR, GEBURTSTAG, GEBURTSTAG_MONAT, ZEITALTER, GEBURTSTAG, GEBURT_MONAT, BIRTH_MONTH, BIRTH_MONTH, BIRTH_MONTH, GEB;bool backlightOn =false;long backlightTimeout =0;byte customChar[8];//------------ EEPROM ---------- ---------------------------------#define EEPROM_AH 0 //Alarmstunden#define EEPROM_AM 1 //Alarmminuten# EEPROM_AO definieren 2 //Alarm Ein/Aus#define EEPROM_CS 3 //Aktueller Stil#define EEPROM_BY 4 //Geburtsjahr#define EEPROM_BM 6 //Geburtsmonat#define EEPROM_BD 7 //Geburtstag//--------- ------------ Wordclock ------------------------------------ --String-Einheiten[] ={"HUNDRED", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE"};String teens[] ={"TEN", "ELEVEN", "TWELVE", "THIRTEEN", "FOURTEEN", "FIFTEEN", "SIXTEEN", "SEVENTEEN", "EIGHTEEN", "NINETEEN"};Zehner-Zehner[] ={"", "", "TWENTY", "THIRTY", "FORTY", "FIFTY"};//--------------------- Sanduhr Animation ----------------------------#define HOURGLASS_FRAMES 8#define HOURGLASS_CHAR 0#define FRAME_TIMEOUT 200;int nextFrame =0;long frameTimeout =0;konstantes Byte Sanduhr[HOURGLASS_FRAMES][8] PROGMEM ={ { B11111, B11111, B01010, B01010, B01010, B01010, B10001, B11111 }, { B11111, B11011, B01110, B01010, B01010, B01010, B10001, B11111 }, { B11111, B10001, B01110, B01110, B01010, B01010, B10001, B11111 }, { B11111, B10001, B01010, B01110, B01110 , B01010, B10001, B11111 }, { B11111, B10001, B01010, B01010, B01110, B01110, B10001, B11111 }, { B11111, B10001, B01010, B01010, B01010, B01110, B10101, B11111 }, { B11111, B10001, B01010 , B01010, B01010, B01110, B11011, B11111 }, { B11111, B10001, B01010, B01010, B01010, B01010, B11111, B11111 }, //{ B11111, B10001, B01010, B01010, B01010, B01010, B10001, B11111 }};//---------------------- Wecker, Uhr und benutzerdefinierte DHT-Zeichen ------------------ ----------#define BELL_CHAR 1#define CLOCK_CHAR 2#define THERMOMETER_CHAR 3#define DROPLET_CHAR 4const byte bell[8] PROGMEM ={0x4, 0xe, 0xe, 0xe, 0x1f, 0x0, 0x4};const byte clock[8] PROGMEM ={0x0, 0xe, 0x15, 0x17, 0x11, 0xe, 0x0};const byte thermometer[8] PROGMEM ={0x4, 0xa, 0xa, 0xe, 0xe, 0x1f, 0x1f, 0xe};const byte droplet[8] PROGMEM ={0x4, 0x4, 0xa, 0xa, 0x11, 0x11, 0x11, 0xe};#define DHT_UPDATE_INTERVAL 6000//------------------ --- BioRhythm Clock -------------------------------------- // Benutzerdefinierte Zeichenkonstanten (M ist MSB oder oberes Balkenzeichen) r, L ist LSB oder unterer Strichzeichen#define PHYSICAL_M 3#define PHYSICAL_L 4#define EMOTIONAL_M 5#define EMOTIONAL_L 6#define INTELLECTUAL_M 7#define INTELLECTUAL_L 8//--------------- ---------- Dicke quadratische Schriftart --------------------------#define C0 3#define C1 4#define C2 5 #define C3 6const byte C_0[8] PROGMEM ={0x1F,0x1F,0x1F,0x00,0x00,0x00,0x00,0x00};const byte C_1[8] PROGMEM ={0x1F,0x1F,0x1F,0x00,0x00,0x1F, 0x1F,0x1F};konstantes Byte C_2[8] PROGMEM ={0x00,0x00,0x00,0x00,0x00,0x1F,0x1F,0x1F};konstantes Byte C_3[8] PROGMEM ={0x00,0x00,0x0E,0x0A,0x0A, 0x0E,0x00,0x00};const byte blockChar[11][2][3] ={ {{ 255, C0, 255}, {255, C2, 255}}, //0 {{ C0, 255, 32} , {C2, 255, C2}}, //1 {{ C0, C0, 255}, {255, C1, C2}}, //2 {{ C1, C1, 255}, {C1, C1, 255} }, //3 {{ 255, C2, 255}, {32, 32, 255}}, //4 {{ 255, C1, C1}, {C2, C2, 255}}, //5 {{ 255 , C0, C0}, {255, C1, 255}}, //6 {{ C0, C1, 255}, {32, C0, 255}}, //7 {{ 255, C1, 255}, {255 , C1, 255}}, //8 {{ 255, C1, 255}, {C2, C2, 255}}, //9 {{ 32, 32, 32}, {32, 32, 32}}, //Leer};//------------ Dicke abgeschrägte Schriftart -------------- --------------#define LT 0#define UB 1#define RT 2#define LL 3#define LB 4#define LR 5#define UMB 6#define LMB 7const byte _LT[8 ] PROGMEM ={ B00111, B01111, B11111, B11111, B11111, B11111, B11111, B11111};const byte _UB[8] PROGMEM ={ B11111, B11111, B11111, B00000, B00000, B00000, B00000, B00000};const byte _RT [8] PROGMEM ={ B11100, B11110, B11111, B11111, B11111, B11111, B11111, B11111};const byte _LL[8] PROGMEM ={ B11111, B11111, B11111, B11111, B11111, B11111, B01111, B00111};const byte _LB[8] PROGMEM ={ B00000, B00000, B00000, B00000, B00000, B11111, B11111, B11111};const byte _LR[8] PROGMEM ={ B11111, B11111, B11111, B11111, B11111, B11111, B11110, B11100};const byte _UMB[8] PROGMEM ={ B11111, B11111, B11111, B00000, B00000, B00000, B11111, B11111};const byte _LMB[8] PROGMEM ={ B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111};const byte bevelChar[11][2][3] ={ {{LT, UB, RT}, {LL, LB, LR} }, //0 {{UB, RT, 32}, {LB, LMB, LB}}, //1 {{UMB, UMB, RT}, {LL, LB, LB}}, //2 {{UMB , UMB, RT}, {LB, LB, LR}}, //3 {{LL, LB, LMB}, {32, 32, LMB}}, //4 {{LT, UMB, UMB}, {LB , LB, LR}}, //5 {{LT, UMB, UMB}, {LL, LB, LR}}, //6 {{UB, UB, RT}, {32, 32, LT}}, / /7 {{LT, UMB, RT}, {LL, LB, LR}}, //8 {{LT, UMB, RT}, {32, 32, LR}}, //9 {{ 32, 32, 32}, {32, 32, 32}} //Leer};//------------ Schriftart Trek -------- --------------------#K0 definieren 0#K1 definieren 1#K2 definieren 2#K3 definieren 3#K4 definieren 4#K5 definieren 5#K6 definieren 6#K6 definieren K7 7const byte K_0[8] PROGMEM ={0x1F,0x1F,0x00,0x00,0x00,0x00,0x00,0x00};const byte K_1[8] PROGMEM ={0x18,0x18,0x18,0x18,0x18,0x18,0x18, 0x18};konstantes Byte K_2[8] PROGMEM ={0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x1F};konstantes Byte K_3[8] PROGMEM ={0x1F,0x1F,0x03,0x03,0x03,0x03, 0x1F,0x1F};konstantes Byte K_4[8] PROGMEM ={0x1F,0x1F,0x18,0x18,0x18,0x18,0x1F,0x1F};konstantes Byte K_5[8] PROGMEM ={0x1F,0x1F,0x18,0x18,0x18, 0x18,0x18,0x18};konstantes Byte K_6[8] PROGMEM ={0x03,0x03,0x03,0x03, 0x03,0x03,0x1F,0x1F};konstantes Byte K_7[8] PROGMEM ={0x1F,0x1F,0x03,0x03,0x03,0x03,0x03,0x03};konstantes Byte trekChar[11][2][2] ={ { { K5, K7}, {255, K6}}, //0 {{ K0, K1}, {K2, 255}}, //1 {{ K0, K3}, {255, K2}}, //2 {{ K0, K3}, {K2, 255}}, //3 {{ K1, 255}, {K0, K1}}, //4 {{K4, K0}, {K2, 255}}, // 5 {{ K5, K0}, {K4, 255}}, //6 {{ K0, 255}, {32, K1}}, //7 {{ 255, K3}, {K4, 255}}, / /8 {{ 255, K3}, {K2, K6}}, //9 {{ 32, 32}, {32, 32}}, //Leer};//--------- ------------ Thin Font ----------------#define T0 0#define T1 1 #define T2 2#define T3 3#define T4 4#define T5 5#define T6 6#define T7 7const byte T_0[8] PROGMEM ={0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02};const Byte T_1[8] PROGMEM ={0x0E,0x02,0x02,0x02,0x02,0x02,0x02,0x0E};konstantes Byte T_2[8] PROGMEM ={0x0E,0x08,0x08,0x08,0x08,0x08,0x08,0x0E};konstantes Byte T_3[8] PROGMEM ={0x0E,0x0A,0x0A,0x0A,0x0A,0x0A,0x0A,0x0E};konstantes Byte T_5[8] PROGMEM ={0x0A,0x0A,0x0A,0x0A,0x0A,0 0x0E};konstantes Byte T_4[8] PROGMEM ={0x0E,0x0A,0x0A,0x0A,0x0 A,0x0A,0x0A,0x0A};konstantes Byte T_6[8] PROGMEM ={0x0E,0x02,0x02,0x02,0x02,0x02,0x02,0x02};konstantes Byte T_7[8] PROGMEM ={0x18,0x18,0x18, 0x18,0x18,0x1E,0x1F,0x1F};//lcd Zeichenfunktionen zeichnenconst byte thinChar[11][2] ={ {T4, T5}, //0 {T0, T0}, ///1 {T1, T2} , //2 {T1, T1}, //3 {T5, T6}, //4 {T2, T1}, //5 {T2, T3}, //6 {T6, T0}, //7 { T3, T3}, //8 {T3, T1}, //9 {32, 32} //leer}; //---------------------- Allgemeine Initialisierung ------------------------ ----void setup () { Serial.begin (115200); // Ausgänge/Eingänge einstellen PinMode (BTN_SET, INPUT); pinMode (BTN_ADJUST, EINGANG); pinMode (BTN_ALARM, INPUT); pinMode (BTN_TILT, INPUT); pinMode (LAUTSPRECHER, AUSGANG); pinMode (LICHT, AUSGANG); //Überprüfen Sie, ob RTC eine gültige Uhrzeit/ein gültiges Datum hat, wenn nicht, setzen Sie es auf 00:00:00 01.01.2018. // Dies wird nur beim ersten Mal ausgeführt oder wenn die Münzbatterie schwach ist. //setSyncProvider() veranlasst die Time-Bibliothek, sich mit der //externen RTC zu synchronisieren, indem standardmäßig alle fünf Minuten RTC.get() aufgerufen wird. setSyncProvider(rtc.get); if (timeStatus () ! =timeSet) { Serial.println ( "Standardzeit einstellen"); //Setze RTC tmElements_t tm; tm.Jahr =KalenderYrToTm(2020); tm.Monat =06; tm.Tag =26; tm.Stunde =7; tm.Minute =52; tm.Sekunde =0; time_t t =makeTime(tm); // Verwenden Sie den time_t-Wert, um sicherzustellen, dass der richtige Wochentag eingestellt ist if (rtc.set (t) ==0) { // Erfolg setTime (t); } else { Serial.println ( "RTC-Set fehlgeschlagen!"); } } Verzögerung (100); // Alarmzeit aus dem EEPROM-Speicher lesen AH =EEPROM.read (EEPROM_AH); AM =EEPROM.read(EEPROM_AM); Byte ao =EEPROM.read(EEPROM_AO); alarmON =(ao !=0); Byte cs =EEPROM.read(EEPROM_CS); //Überprüfen Sie, ob die gelesenen Zahlen gültig sind. (Stunden:0-23 und Minuten:0-59) if (AH> 23) { AH =0; } wenn (AM> 59) { AM =0; } //Geburtsdatum aus EEPROM lesen BY =(EEPROM.read(EEPROM_BY + 0) <<8) | EEPROM.read (EEPROM_BY + 1); if (BY <1900 || BY> 2099) { BY =2000; } BM =EEPROM.read (EEPROM_BM); if (BM <0 || BM> 12) { BM =1; } BD =EEPROM.read (EEPROM_BD); wenn (BD <0 || BD> 31) { BD =1; } //Aktuellen Stil einrichten lcd.begin (16,2); currentStyle =(cs> (uint8_t)THERMO) ? STANDARD :(STIL)cs; switch (currentStyle) { case STANDARD:lcdStandardSetup(); brechen; Fall DUAL_THICK:lcdDualThickSetup(); brechen; Fall DUAL_BEVEL:lcdDualBevelSetup(); brechen; Fall DUAL_TREK:lcdDualTrekSetup(); brechen; Fall DUAL_THIN:lcdDualThinSetup(); brechen; case WORD:lcdWordSetup(); brechen; Fall-BIO:lcdBioRhythmSetup(); brechen; Fall THERMO:lcdThermometerSetup(); brechen; } #ifdef BACKLIGHT_ALWAYS_ON switchBacklight(true);#endif}//------------ Hauptprogrammschleife -------------- ------------------void loop () {readBtns (); // Schaltflächen lesen getTimeDate(); // Uhrzeit und Datum von RTC lesen getTempHum(); // Temperatur und Luftfeuchtigkeit lesen if (!setupScreen) {lcdPrint(); // Normalerweise drucken Sie die aktuelle Uhrzeit / das Datum / den Alarm auf dem LCD aus, wenn (alarmON) {callAlarm (); // und den Alarm überprüfen, wenn er eingeschaltet ist if (turnItOn) { switchBacklight (true); } } //Serial.println("backlightTimeout=" + String(backlightTimeout) +", millis()=" + String(millis()) +", backlightOn=" + String(backlightOn));#ifdef BACKLIGHT_TIMEOUT if ( backlightOn &&(millis()> backlightTimeout)) { switchBacklight (false); } #endif } else { timeSetup(); // Wenn der Tastensatz gedrückt wird, rufen Sie die Zeiteinrichtungsfunktion auf switchBacklight (true); }}//---------------------------------------------------------- ---- // Schaltflächen lesen statevoid readBtns () { set_state =digitalRead (BTN_SET); adjust_state =digitalRead (BTN_ADJUST); alarm_state =digitalRead (BTN_ALARM); if (!backlightOn &&!setupScreen) { if (set_state ==LOW || adjust_state ==LOW || alarm_state ==LOW) {//Hintergrundbeleuchtung einschaltenBacklight (true); // muss die Taste mindestens 1/2 Sekunde lang gedrückt halten (500); } } else { if(!setupScreen) { if (alarm_state ==LOW) { alarmON =!alarmON; EEPROM.write (EEPROM_AO, (alarmON) ? 1 :0); Verzögerung (500); switchBacklight (wahr); aufrechtzuerhalten. Sonst if (adjust_state ==LOW) { currentStyle =(currentStyle ==THERMO)? STANDARD :(STYLE)((int)currentStyle + 1); EEPROM.write(EEPROM_CS, (Byte)currentStyle); switch (currentStyle) { case STANDARD:lcdStandardSetup(); brechen; Fall DUAL_THICK:lcdDualThickSetup(); brechen; Fall DUAL_BEVEL:lcdDualBevelSetup(); brechen; Fall DUAL_TREK:lcdDualTrekSetup(); brechen; Fall DUAL_THIN:lcdDualThinSetup(); brechen; case WORD:lcdWordSetup(); brechen; Fall-BIO:lcdBioRhythmSetup(); brechen; Fall THERMO:lcdThermometerSetup(); brechen; } lcd.clear(); lcdPrint(); Verzögerung (500); switchBacklight (wahr); } } if (set_state ==LOW) { setupMode =(setupMode ==ALARM_MIN) ? UHR :(SETUP)((int)setupMode + 1); if( setupMode !=CLOCK ) { setupScreen =true; if (setupMode ==TIME_HOUR) {lcd.clear(); lcd.setCursor(0,0); lcd.print("------SET------"); lcd.setCursor(0,1); lcd.print("-ZEIT und DATUM-"); Verzögerung (2000); lcd.clear(); }} sonst {lcd.clear(); //Setze RTC tmElements_t tm; tm.Jahr =KalenderYrToTm(YY); tm.Monat =MM; tm.Tag =TT; tm.Stunde =H; tm.Minute =M; tm.Sekunde =0; time_t t =makeTime(tm); // Verwenden Sie den time_t-Wert, um sicherzustellen, dass der richtige Wochentag eingestellt ist if (rtc.set (t) ==0) { // Erfolg setTime (t); } else { Serial.println ( "RTC-Set fehlgeschlagen!"); } //rtc.adjust (DateTime (YY, MM, DD, H, M, 0)); // Zeit und Datum in RTC IC speichern EEPROM.write (EEPROM_AH, AH); // Speichern Sie die Alarmstunden im EEPROM EEPROM.write (EEPROM_AM, AM); // Speichern Sie den protokollierten Alarm im EEPROM EEPROM.write (EEPROM_BY + 0, BY>> 8); //Geburtsjahr im EEPROM speichern EEPROM.write (EEPROM_BY + 1, BY &0xFF); //Geburtsjahr im EEPROM speichern EEPROM.write (EEPROM_BM, BM); // Geburtsmonat im EEPROM speichern EEPROM.write (EEPROM_BD, BD); //Geburtstag im EEPROM speichern lcd.print("Saving...."); Verzögerung (2000); lcd.clear(); setupScreen =false; setupMode =UHR; switchBacklight (wahr); } Verzögerung (500); } }} //--------------------------------------------------------- -----//Zeit und Datum von rtc lesen icvoid getTimeDate () { if (!setupScreen) { // DateTime now =rtc.now (); time_t t =now(); DD =Tag(t); MM =Monat(t); YY =Jahr(t); H =Stunde(t); M =Minute(t); S =Sekunde(t); } //Einige Korrekturen vornehmen... sDD =((DD <10) ? "0" :"") + String(DD); sMM =((MM <10) ? "0" :"") + String(MM); sYY =Zeichenfolge(YY-2000); sH =((H <10) ? "0" :"") + String(H); sM =((M <10) ? "0" :"") + String(M); sS =((S <10) ? "0" :"") + String(S); sBD =((BD <10) ? "0" :"") + String(BD); sBM =((BM <10) ? "0" :"") + String(BM); sBY =String(BY); aH =((AH <10) ? "0" :"") + String(AH); aM =((AM <10) ? "0" :"") + String(AM);}//------------------------ -------------------------- // Lesen Sie Temperatur und Luftfeuchtigkeit alle 6 Sekunden vom DHT-Sensorvoid getTempHum () { unsigned long currentMillis =millis (); if (currentMillis - prevDhtMillis>=DHT_UPDATE_INTERVAL) {int chk =DHT.read21(DHT21); prevDhtMillis =currentMillis; summen =min (rund (DHT.humidity), 99); temp =min (rund (DHT.temperature), 99); sTMP =((temp>
 9) ? "" :" ") + String(temp); sHUM =((brum> 9) ? "" :" ") + String(brumm); }}//---------------------------------------------------------- ---- // Hintergrundbeleuchtung ein- oder ausschaltenVoid switchBacklight (bool on) { #ifdef NO_BACKLIGHT digitalWrite (LIGHT, LOW); HintergrundbeleuchtungEin =wahr; // Software dazu bringen, zu denken, dass es eingeschaltet ist, obwohl es nicht #else #ifdef BACKLIGHT_ALWAYS_ON digitalWrite(LIGHT, HIGH); HintergrundbeleuchtungEin =wahr; #else digitalWrite (LIGHT, (on) ? HIGH :LOW); HintergrundbeleuchtungEin =an; backlightTimeout =millis() + BACKLIGHT_TIMEOUT; #endif #endif} //------------------------------------------------------- -------//Werte in das Displayvoid ausgeben lcdPrint(){ switch (currentStyle) { case STANDARD:lcdStandardLayout(); brechen; Fall DUAL_THICK:lcdDualThickLayout(); brechen; Fall DUAL_BEVEL:lcdDualBevelLayout(); brechen; Fall DUAL_TREK:lcdDualTrekLayout(); brechen; Fall DUAL_THIN:lcdDualThinLayout(); brechen; case WORD:lcdWordLayout(); brechen; Fall-BIO:lcdBioRhythmLayout(); brechen; Gehäuse THERMO:lcdThermometerLayout(); brechen; }}//---------------------------------------------------------- -- Standardlayout ---------------------------------------------- -----------------------void lcdStandardSetup(){}void lcdStandardLayout(){ String line1 =sH+":"+sM+":"+sS+" | "+aH+":"+aM; String line2 =sDD+"/"+sMM+"/"+sYY +" | " + ((alarmON &&(S &0x01)) ? "ALARM" :" "); lcd.setCursor(0,0); //Erste Zeile lcd.print (line1); lcd.setCursor(0,1); //Zweite Zeile lcd.print (line2); } // Erstellen Sie ein benutzerdefiniertes Zeichen aus dem Programmspeichervoid createCharP(byte slot, byte* p){ for (int i =0; i <8; i++) { customChar[i] =pgm_read_byte(p++); } lcd.createChar(slot, customChar);}//------------------------------------------------- -------------- Dual Dickes Layout ---------------------------------- ---------------------------------void lcdDualThickSetup () { createCharP (C0, C_0); createCharP(C1, C_1); createCharP(C2, C_2); createCharP(C3, C_3); createCharP(BELL_CHAR, bell);}void lcdDualThickLayout(){#ifdef DUAL_THICK_12HR int h =(H>=12) ? H-12:H; wenn (h ==0) {h =12; } lcdDualThickPrintNumber(8, M, wahr); lcdDualThickPrintNumber(0, h, false); lcd.setCursor(15,0); lcd.print((H>=12) ? "p" :"a"); lcd.setCursor(15,1); lcd.print("m"); #else lcdDualThickPrintNumber(8, M, true); lcdDualThickPrintNumber(0, H, wahr); bool-Alarm =(S &0x01); lcdWordShowBell(15, 0, Alarm, BELL_CHAR); // untere rechte Ecke lcdWordShowBell(15, 1, !alarm, BELL_CHAR); //untere rechte Ecke #endif byte c =(S &1) ? C3:32; lcd.setCursor(7,0); lcd.write(c); lcd.setCursor(7,1); lcd.write(c);}//Zeichne eine zweizeilige Zahl // pos - x Position zum Zeichnen der Zahl // Zahl - Wert zum Zeichnen // führende Null - ob führende Nullen angezeigt werden sollenvoid lcdDualThickPrintNumber(int pos, int number, int führendeNull){int t =Zahl / 10; int u =Zahl % 10; if (t ==0 &&!führende Null) { t =11; } lcdDualThickPrintDigit(pos, t); lcdDualThickPrintDigit(pos + 4, u);} // Zeichne eine zweizeilige Ziffer // pos - x-Position zum Zeichnen der Zahl // Zahl - Wert zum Zeichnen von Leerzeichen lcdDualThickPrintDigit(int pos, int number) { for (int y =0; y <2; y++) {lcd.setCursor(pos, y); for (int x =0; x <3; x++) {lcd.write(blockChar[Nummer][y][x]); } }} //--------------------------------------------------------- --- Dual Bevel-Layout ------------------------------------------ -----------------------void lcdDualBevelSetup(){ createCharP(LT, _LT); createCharP(UB, _UB); createCharP(RT, _RT); createCharP(LL, _LL); createCharP(LB, _LB); createCharP(LR, _LR); createCharP(UMB, _UMB); createCharP(LMB, _LMB);}void lcdDualBevelLayout(){#ifdef DUAL_THICK_12HR int h =(H>=12) ? H-12:H; wenn (h ==0) {h =12; } lcdDualBevelPrintNumber(8, M, wahr); lcdDualBevelPrintNumber(0, h, false); lcd.setCursor(15,0); lcd.print((H>=12) ? "p" :"a"); lcd.setCursor(15,1); lcd.print("m"); #else lcdDualBevelPrintNumber(8, M, true); lcdDualBevelPrintNumber(0, H, wahr); bool-Alarm =(S &0x01); lcdWordShowBell(15, 0, Alarm, 65); // untere rechte Ecke lcdWordShowBell (15, 1, !alarm, 65); //untere rechte Ecke #endif byte c =(S &1) ? 58 :32; lcd.setCursor(7,0); lcd.write(c); lcd.setCursor(7,1); lcd.write(c);}//Zeichne eine zweizeilige Zahl // pos - x Position zum Zeichnen der Zahl // Zahl - Wert zum Zeichnen // LeadingZero - ob führende Nullen angezeigt werden sollenvoid lcdDualBevelPrintNumber(int pos, int number, int führendeNull){int t =Zahl / 10; int u =Zahl % 10; if (t ==0 &&!führende Null) { t =11; } lcdDualBevelPrintDigit(pos, t); lcdDualBevelPrintDigit(pos + 4, u);} // Zeichne eine zweizeilige Ziffer // pos - x-Position zum Zeichnen der Zahl // Zahl - Wert zum Zeichnen von Void lcdDualBevelPrintDigit(int pos, int number) { for (int y =0; y <2; y++) {lcd.setCursor(pos, y); for (int x =0; x <3; x++) {lcd.write(bevelChar[Nummer][y][x]); } }} //--------------------------------------------------------- --- Dual-Trek-Layout ------------------------------------------ ----------------------------------void lcdDualTrekSetup () { createCharP (K0, K_0); createCharP(K1, K_1); createCharP(K2, K_2); createCharP(K3, K_3); createCharP(K4, K_4); createCharP(K5, K_5); createCharP(K6, K_6); createCharP(K7, K_7);}void lcdDualTrekLayout(){ lcdDualTrekPrintNumber(10, S, true); lcdDualTrekPrintNumber(5, M, true); lcdDualTrekPrintNumber(0, H, true); byte c =(S &1) ? 165 :32; lcd.setCursor(4,0); lcd.write(c); lcd.setCursor(4,1); lcd.write(c); lcd.setCursor(9,0); lcd.write(c); lcd.setCursor(9,1); lcd.write(c); bool alarm =(S &0x01); lcdWordShowBell(15, 0, alarm, 65); //bottonm right corner lcdWordShowBell(15, 1, !alarm, 65); //bottonm right corner}//Draw a 2 line number// pos - x position to draw number// number - value to draw// leadingZero - whether leading zeros should be displayedvoid lcdDualTrekPrintNumber(int pos, int number, int leadingZero){ int t =number / 10; int u =number % 10; if (t ==0 &&!leadingZero) { t =11; } lcdDualTrekPrintDigit(pos, t); lcdDualTrekPrintDigit(pos + 2, u);}//Draw a 2 line digit// pos - x position to draw number// number - value to drawvoid lcdDualTrekPrintDigit(int pos, int number){ for (int y =0; y <2; y++) { lcd.setCursor(pos, y); for (int x =0; x <2; x++) { lcd.write(trekChar[number][y][x]); } }}//------------------------------------------------ Dual Thin layout ---------------------------------------------------------------------void lcdDualThinSetup(){ createCharP(T0, T_0); createCharP(T1, T_1); createCharP(T2, T_2); createCharP(T3, T_3); createCharP(T4, T_4); createCharP(T5, T_5); createCharP(T6, T_6); createCharP(T7, T_7);}void lcdDualThinLayout(){ #ifdef DUAL_THIN_12HR int h =(H>=12) ? H - 12 :H; if (h ==0) { h =12; } lcdDualThinPrintNumber(6, S, true); lcdDualThinPrintNumber(3, M, true); lcdDualThinPrintNumber(0, h, false); lcd.setCursor(9,0); lcd.print((H>=12) ? "p" :"a"); lcd.setCursor(9,1); lcd.print("m"); #else lcdDualThinPrintNumber(6, S, true); lcdDualThinPrintNumber(3, M, true); lcdDualThinPrintNumber(0, H, true);#endif byte c =(S &1) ? 165 :32; lcd.setCursor(2,0); lcd.write(c); lcd.setCursor(2,1); lcd.write(c); lcd.setCursor(5,0); lcd.write(c); lcd.setCursor(5,1); lcd.write(c); String line1 =aH+":"+aM; String line2 =(alarmON &&(S &0x01)) ? "ALARM" :" "; lcd.setCursor(11,0); //First row lcd.print(line1); lcd.setCursor(11,1); //Second row lcd.print(line2); }//Draw a 2 line number// pos - x position to draw number// number - value to draw// leadingZero - whether leading zeros should be displayedvoid lcdDualThinPrintNumber(int pos, int number, int leadingZero){ int t =number / 10; int u =number % 10; if (t ==0 &&!leadingZero) { t =11; } lcdDualThinPrintDigit(pos, t); lcdDualThinPrintDigit(pos + 1, u);}//Draw a 2 line digit// pos - x position to draw number// number - value to drawvoid lcdDualThinPrintDigit(int pos, int number){ for (int y =0; y <2; y++) { lcd.setCursor(pos, y); lcd.write(thinChar[number][y]); }}//------------------------------------------------ Word layout ---------------------------------------------------------------------void lcdWordSetup(){ createCharP(BELL_CHAR, &bell[0]);}void lcdWordLayout(){ String line1 =numberToWord(H, false); String line2 =numberToWord(M, true); lcd.setCursor(0,0); //First row printClear(line1, 13); lcd.setCursor(0,1); //Second row printClear(line2, 14); if (millis()> frameTimeout) { frameTimeout =millis() + FRAME_TIMEOUT; //lcd.createChar(HOURGLASS_CHAR, &hourglass[nextFrame][0]); createCharP(HOURGLASS_CHAR, &hourglass[nextFrame][0]); nextFrame =(nextFrame + 1) % HOURGLASS_FRAMES; lcd.setCursor(13,0); //First row lcd.write((int)HOURGLASS_CHAR); lcd.print(sS); } bool alarm =(S &0x01); lcdWordShowBell(14, 1, alarm, BELL_CHAR); //Second row lcdWordShowBell(15, 1, !alarm, BELL_CHAR); //Second row}//Display the bell symbol if alarm is on// x - x position (0..15)// y - y position (0..1)// show - true to showvoid lcdWordShowBell(int x, int y, bool show, byte chr) { lcd.setCursor(x,y); lcd.print(" "); if (alarmON &&show) { lcd.setCursor(x,y); lcd.write(chr); }}//Print character string and clear to right// s - String to print...This file has been truncated, please download it to see its full contents.

Kundenspezifische Teile und Gehäuse

Schaltpläne