Réveil LCD à plusieurs visages

Outils et machines nécessaires

Imprimante 3D (générique)

Applications et services en ligne

Arduino IDE

À propos de ce projet

Une nouvelle version avec 10 cadrans d'horloge peut être trouvée ici .

En cherchant quelque chose à construire, j'ai opté pour une horloge LCD 1602. Après avoir parcouru le Web et trouvé de nombreuses implémentations différentes, j'ai décidé pourquoi ne pas créer une horloge qui les intègre toutes.

Fonctionnalités de l'horloge

• Huit styles d'affichage différents
• Régler l'heure, la date actuelle, la date de naissance et l'alarme
• Interrupteur à mercure pour désactiver l'alarme
• Contrôle du rétroéclairage
• Capteur de température et d'humidité DHT21

Version planche à pain

L'électronique réelle est assez simple.

Une fois câblé, chargez le croquis dans votre IDE Arduino et téléchargez-le sur l'Arduino UNO. (Non illustré, le DHT21 est câblé à D9)

Utilisation de l'horloge

L'horloge a trois boutons - SETUP, INCREMENT, DECREMENT et un commutateur TILT.

Lorsque le rétroéclairage est éteint, appuyez sur n'importe quel bouton pour allumer le rétroéclairage. Si aucun bouton n'est enfoncé pendant que le rétroéclairage est allumé, il s'éteindra au bout de 5 secondes. Lorsque le rétroéclairage est allumé, les boutons effectueront les tâches suivantes :

CONFIGURATION - Cela fait apparaître les écrans SETUP. Le caractère crochet à angle droit est le curseur. Appuyer sur les boutons INCREMENT ou DECREMENT augmentera ou diminuera respectivement la valeur sur laquelle se trouve le curseur. Appuyez à nouveau sur le bouton SETUP pour faire défiler le curseur entre les heures, les minutes, le jour, le mois, l'année, le jour de naissance, le mois de naissance, l'année de naissance, les heures d'alarme, les minutes d'alarme et revenir au mode HORLOGE.

AUGMENTATION - Lorsqu'il n'est pas dans les écrans SETUP, ce bouton bascule entre les différents styles d'horloge.

DIMINUTION - Lorsqu'il n'est pas dans les écrans SETUP, ce bouton active ou désactive l'alarme.

INTERRUPTEUR D'INCLINAISON - Lorsque l'alarme sonne, incliner l'horloge ou appuyer sur n'importe quel bouton éteint l'alarme.

Construire une horloge entièrement terminée

Faire passer votre construction de la planche à pain à une horloge entièrement finie nécessitera une carte de circuit imprimé et des composants supplémentaires. Les fichiers Eagle sont joints si vous souhaitez faire fabriquer le PCB dans le commerce ou faire comme moi et le faire vous-même. J'ai utilisé la méthode Toner.

REMARQUE :Étant donné que l'écran LCD 1602 est connecté à la carte de circuit imprimé principale à l'aide d'un en-tête de broche à angle droit, il peut être très difficile d'insérer la carte et l'écran dans le boîtier lorsqu'ils sont déjà soudés ensemble. Le fait d'avoir une carte double face avec un placage traversant vous permettra de souder l'écran à la carte en place.

En utilisant des pièces que j'avais dans l'atelier, l'Arduino UNO a été remplacé par une puce ATMega328 DIL, un cristal de 16 MHz et deux condensateurs en céramique de 22pf. Le régulateur 5V est de type 7805 TO-220 et un condensateur 100uF 16V pour le lissage. Le RTC est un DS1302 avec un cristal de montre de 32,768 KHz. Le haut-parleur est un buzzer passif qui est isolé en courant continu avec un condensateur 10uF 16V. Les condensateurs 0,1 uF et 1 uF sont des condensateurs céramiques monolithiques (espacement des trous de 5 mm). Les résistances sont de 5% 1/8 watt ou vous pouvez utiliser 1/4 watt si vous le souhaitez. L'interrupteur à mercure peut être de n'importe quelle taille. Le mien avait un diamètre de 5 mm mais un plus petit suffira. Les trois boutons tactiles montés à l'arrière de la carte mesurent 6 mm x 6 mm avec un axe de 13 mm.

Le boîtier est imprimé en 3D en utilisant une hauteur de couche de 0,2 mm et aucun support. Percez les trous de montage du PCB avec une perceuse de 2,5 mm et créez un filetage à l'aide d'un taraud de 3 mm. Utilisez des vis M3 de 6 mm pour fixer la carte en place. J'ai également percé les quatre trous de montage sur le PCB à 4 mm pour permettre tout ajustement requis pour empêcher les boutons de coller sur le boîtier lors de la fixation de la carte.

Crédits

Cette horloge est un mélange d'un certain nombre d'horloges que divers fabricants ont fabriquées au fil des ans.

La base de cette horloge est l'horloge numérique Arduino avec fonction d'alarme (PCB personnalisé). J'ai modifié le boîtier pour qu'il soit imprimé en deux pièces et non en quatre.

• Design de paravent standard par Michalis Vasilakis
• Police Dual Thick par Arduino World
• Police Dual Beveled du forum Arduino
• Police Dual Trek par Carrie Sundra
• Police Dual Thin par Arduino World
• Concept Word par LAGSILVA
• Horloge biorythmique de John Bradnam
• Horloge météo par ARDUinoautoMOTIVE

Mises à jour

29/06/20

- Correction des fautes d'orthographe dans l'horloge WORD
- Ajout de #defines pour contrôler le rétroéclairage
- Augmentation du délai de rétroéclairage de 5 à 10 secondes 

23/11/20

- Ajout de la configuration de la date de naissance et du stockage EEPROM
- Ajout du cadran de l'horloge Biorhythm
- Nettoyage du codage de l'écran de configuration 

On émet l'hypothèse qu'en fonction de notre date de naissance, les biorythmes pourraient déterminer les hauts et les bas de notre vie. Les biorythmes comprennent trois cycles :un cycle physique de 23 jours, un cycle émotionnel de 28 jours et un cycle intellectuel de 33 jours. L'horloge biorythmique affiche chaque état sous forme de barre.

La barre indique que le biorythme est soit dans un cycle positif (barre supérieure) soit dans un cycle négatif (barre inférieure). La longueur de la barre indique à quel point elle est positive ou négative dans le cycle.

12/06/20

- Ajout de la prise en charge DHT21
- Ajout d'un cadran d'horloge de thermomètre et d'humidité 

Un nouveau cadran d'horloge météo a été ajouté. Il lit un capteur de température et d'humidité DHT21 ajouté à l'arrière du boîtier. Le PCB a été mis à jour pour inclure un connecteur à 3 broches vers le capteur DHT21.

Code

• DigitalClockAlarmV7.ino

DigitalClockAlarmV7.inoC/C++

/* 1602 Réveil LCD * par John Bradnam ([email protected]) * * Affichage 16x2 :Configuration :Configuration de l'alarme * +----------------+ +- ---------------+ +----------------+ * |HH:MM:SS | HH:MM| |>HH :>MM | | Définir l'alarme | * |JJ/MM/AA | ALARME| |>JJ />MM />AAAA | |>HH :>MM | * +----------------+ +----------------+ +------------ ----+ * * 25/06/2020 * - A pris l'horloge de Michalis Vasilakis comme base de code (https://www.instructables.com/id/Arduino-Digital-Clock-With-Alarm-Function-custom-P/ ) * - Modifié pour s'adapter au matériel - DS1302 RTC et rétroéclairage LCD * - Ajout de la prise en charge de différents styles d'affichage * - Conception d'écran standard par Michalis Vasilakis * - Police Dual Thick par Arduino World (https://www.hackster.io/thearduinoworld/ arduino-digital-clock-version-1-b1a328) * - Police Dual Bevelled par Arduino Forum (https://forum.arduino.cc/index.php/topic,8882.0.html) * - Police Dual Trek par Carrie Sundra ( https://www.alpenglowindustries.com/blog/the-big-numbers-go-marching-2x2) * - Police Dual Thin par Arduino World (https://www.hackster.io/thearduinoworld/arduino-digital-clock -version-2-5bab65) * - Concept Word par LAGSILVA (https://www.hackster.io/lagsilva/text-clock-bilingual-en-pt-with-arduino-881a6e) * 29/06/20 * - Correction des fautes d'orthographe dans l'horloge WORD * - Ajout de #defines à la suite rétro-éclairage rol * - Augmentation du délai de rétro-éclairage de 5 à 10 secondes * 22/11/20 * - Ajout de la configuration de la date de naissance et du stockage EEPROM * - Ajout du cadran de l'horloge Biorhythm * - Nettoyage du codage de l'écran de configuration * xx/xx/21 * - Ajout du DHT21 Support * - Ajout d'un cadran d'horloge de thermomètre et d'humidité *///Libraries#include #include #include #include #include # inclure //uncomment si vous voulez que la variante d'affichage double épais ou mince affiche le format 12 heures//#define DUAL_THICK_12HR//#define DUAL_THIN_12HR//uncomment pour contrôler le rétroéclairage//#define NO_BACKLIGHT//#define BACKLIGHT_ALWAYS_ON# define BACKLIGHT_TIMEOUT 10000//décommentez pour tester les graphiques de biorythme//#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# définir DHT 21 9 //PB1#define RTC_CE 10 //PB2#define RTC_IO 12 //PB4#define RTC_SCLK 13 //PB5//Connexions et constantes 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] ={"Dimanche","Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};const int monthDays[12] ={ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };long intervalle =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, AL_DAY, BIRTH_YEAR, CLOCK, BIRTH_YEAR};;bool backlightOn =false;long backlightTimeout =0;byte customChar[8];//--------------------- EEPROM --------- ----------------------------------#define EEPROM_AH 0 //Heures d'alarme#define EEPROM_AM 1 //Minutes d'alarme# définir EEPROM_AO 2 //Alarme On/Off#define EEPROM_CS 3 //Style actuel#define EEPROM_BY 4 //Année de naissance#define EEPROM_BM 6 //Mois de naissance#define EEPROM_BD 7 //Jour de naissance//--------- ------------ Horloge de mots ------------------------------------ --String units[] ={"CENT", "UN", "DEUX", "TROIS", "QUATRE", "CINQ", "SIX", "SEPT", "HUIT", "NEUF"};Chaîne ados[] ={"DIX", "Onze", "DOUZE", "TREIZE", "QUATORZE", "QUINZE", "SEIZE", "DIX-SEPT", "DIX-HUIT", "DIX-NEUF"};Dizaines de chaîne[] ={"", "", " VINGT ", " TRENTE ", " QUARANTE ", " CINQUANTE "} ; //---------------------- Sablier animation ----------------------------#define HOURGLASS_FRAMES 8#define HOURGLASS_CHAR 0#define FRAME_TIMEOUT 200;int nextFrame =0;long frameTimeout =0 ; octet const sablier [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 }};//---------------------- Réveil, horloge et caractères personnalisés DHT ------------------ ----------#define BELL_CHAR 1#define CLOCK_CHAR 2#define THERMOMETER_CHAR 3#define DROPLET_CHAR 4const octet bell[8] PROGMEM ={0x4, 0xe, 0xe, 0xe, 0x1f, 0x0, 0x4};const horloge à octet[8] PROGMEM ={0x0, 0xe, 0x15, 0x17, 0x11, 0xe, 0x0};const octet thermomètre[8] PROGMEM ={0x4, 0xa, 0xa, 0xe, 0xe, 0x1f, 0x1f, 0xe};const octet droplet[8] PROGMEM ={0x4, 0x4, 0xa, 0xa, 0x11, 0x11, 0x11, 0xe};#define DHT_UPDATE_INTERVAL 6000//------------------- --- BioRhythm Clock ----------------------------//Constantes de caractères personnalisées (M est MSB ou caractère de la barre supérieure r, L est LSB ou le caractère de la barre inférieure#define PHYSICAL_M 3#define PHYSICAL_L 4#define EMOTIONAL_M 5#define EMOTIONAL_L 6#define INTELLECTUAL_M 7#define INTELLECTUAL_L 8//--------------- ------- Police carrée épaisse ----------------------------#define C0 3#define C1 4#define C2 5 #define C3 6octet const C_0[8] PROGMEM ={0x1F,0x1F,0x1F,0x00,0x00,0x00,0x00,0x00};octet const C_1[8] PROGMEM ={0x1F,0x1F,0x1F,0x00,0x00,0x1F, 0x1F,0x1F};octet de constante C_2[8] PROGMEM ={0x00,0x00,0x00,0x00,0x00,0x1F,0x1F,0x1F};octet de constante C_3[8] PROGMEM ={0x00,0x00,0x0E,0x0A,0x0A, 0x0E,0x00,0x00};octet const 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}}, //Blank};//---------------------- Police de biseau épais -------------- --------------#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};octet const _UB[8] PROGMEM ={ B11111, B11111, B11111, B00000, B00000, B00000, B00000, B00000};octet const _RT [8] PROGMEM ={ B11100, B11110, B11111, B11111, B11111, B11111, B11111, B11111};octet const _LL[8] PROGMEM ={ B11111, B11111, B11111, B11111, B11111, B11111, B01111, B00111};const octet _LB[8] PROGMEM ={ B00000, B00000, B00000, B00000, B00000, B11111, B11111, B11111};octet const _LR[8] PROGMEM ={ B11111, B11111, B11111, B11111, B11111, B11111, B11110, B11100};octet const _UMB[8] PROGMEM ={ B11111, B11111, B11111, B00000, B00000, B00000, B11111, B11111};octet const _LMB[8] PROGMEM ={ B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111};octet const 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}} //Vierge} ; //---------------------- Police Trek -------- --------------------#define K0 0#define K1 1#define K2 2#define K3 3#define K4 4#define K5 5#define K6 6#define K7 7octet const K_0[8] PROGMEM ={0x1F,0x1F,0x00,0x00,0x00,0x00,0x00,0x00};octet const K_1[8] PROGMEM ={0x18,0x18,0x18,0x18,0x18,0x18,0x18, 0x18};octet de constante K_2[8] PROGMEM ={0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x1F};octet de constante K_3[8] PROGMEM ={0x1F,0x1F,0x03,0x03,0x03,0x03, 0x1F,0x1F};octet de constante K_4[8] PROGMEM ={0x1F,0x1F,0x18,0x18,0x18,0x18,0x1F,0x1F};octet de constante K_5[8] PROGMEM ={0x1F,0x1F,0x18,0x18,0x18, 0x18,0x18,0x18};octet de const K_6[8] PROGMEM ={0x03,0x03,0x03,0x03, 0x03,0x03,0x1F,0x1F};octet de constante K_7[8] PROGMEM ={0x1F,0x1F,0x03,0x03,0x03,0x03,0x03,0x03};octet de constante 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}}, //Vierge} ; //---------- ------------ Police fine ----------------------------#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 octet T_1[8] PROGMEM ={0x0E,0x02,0x02,0x02,0x02,0x02,0x02,0x0E} ; octet const T_2[8] PROGMEM ={0x0E,0x08,0x08,0x08,0x08,0x08,0x08,0x0E};octet const T_3[8] PROGMEM ={0x0E,0x0A,0x0A,0x0A,0x0A,0x0A,0x0A,0x0E};octet const T_5[8] PROGMEM ={0x0A,0x0A,0x0A,0x0A,0x0A,0x0,A 0x0E} ;octet const T_4[8] PROGMEM ={0x0E,0x0A,0x0A,0x0A,0x0 A,0x0A,0x0A,0x0A};octet de constante T_6[8] PROGMEM ={0x0E,0x02,0x02,0x02,0x02,0x02,0x02,0x02};octet de constante T_7[8] PROGMEM ={0x18,0x18,0x18, 0x18,0x18,0x1E,0x1F,0x1F} ;//lcd dessiner des fonctions de caractèresconst 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} //vide} ; //---------------------- Initialisation générale ------------------------- ----void setup() { Serial.begin(115200); //Définir les sorties/entrées pinMode(BTN_SET,INPUT); pinMode(BTN_ADJUST,INPUT); pinMode(BTN_ALARM, INPUT); pinMode(BTN_TILT, INPUT); pinMode(HAUT-PARLEUR, SORTIE); pinMode(LIGHT, OUTPUT); //Vérifiez si RTC a une heure/date valide, sinon définissez-la sur 00:00:00 01/01/2018. // Cela ne fonctionnera qu'à la première fois ou si la pile bouton est faible. //setSyncProvider() provoque la synchronisation de la bibliothèque Time avec le // RTC externe en appelant RTC.get() toutes les cinq minutes par défaut. setSyncProvider(rtc.get); if (timeStatus() !=timeSet) { Serial.println("Définition de l'heure par défaut"); //Définir RTC tmElements_t tm; tm.Année =CalendarYrToTm(2020); tm.Mois =06; tm.Jour =26 ; tm.Heure =7 ; tm.Minute =52 ; tm.Seconde =0 ; time_t t =makeTime(tm); //utiliser la valeur time_t pour s'assurer que le jour de la semaine correct est défini if ​​(rtc.set(t) ==0) { // Success setTime(t); } else { Serial.println("L'ensemble RTC a échoué !"); } } délai (100); //Lire l'heure de l'alarme à partir de la mémoire EEPROM AH =EEPROM.read(EEPROM_AH); AM =EEPROM.read(EEPROM_AM); octet ao =EEPROM.read(EEPROM_AO); alarmeON =(ao !=0); octet cs =EEPROM.read(EEPROM_CS); //Vérifiez si les nombres que vous lisez sont valides. (Heures :0-23 et Minutes :0-59) si (AH> 23) { AH =0; } si (AM> 59){ AM =0 ; } //Lire la date de naissance de l'EEPROM BY =(EEPROM.read(EEPROM_BY + 0) <<8) | EEPROM.read(EEPROM_BY + 1); si (PAR <1900 || PAR> 2099) { PAR =2000 ; } BM =EEPROM.read(EEPROM_BM); si (BM <0 || BM> 12) { BM =1; } BD =EEPROM.read(EEPROM_BD); si (BD <0 || BD> 31) { BD =1; } //Configurer le style actuel lcd.begin(16,2) ; currentStyle =(cs> (uint8_t)THERMO) ? NORME :(STYLE)cs ; switch (currentStyle) { case STANDARD:lcdStandardSetup(); Pause; cas DUAL_THICK :lcdDualThickSetup(); Pause; cas DUAL_BEVEL :lcdDualBevelSetup(); Pause; cas DUAL_TREK :lcdDualTrekSetup(); Pause; cas DUAL_THIN :lcdDualThinSetup(); Pause; case MOT :lcdWordSetup(); Pause; cas BIO :lcdBioRhythmSetup(); Pause; cas THERMO :lcdThermometerSetup(); Pause; } #ifdef BACKLIGHT_ALWAYS_ON switchBacklight(true);#endif}//---------------------- Boucle du programme principal ----------- -----------------boucle vide() { readBtns(); //Lire les boutons getTimeDate(); //Lire l'heure et la date depuis RTC getTempHum(); //Lire la température et l'humidité if (!setupScreen) { lcdPrint(); //Imprime normalement l'heure/la date/l'alarme actuelles sur l'écran LCD if (alarmON) { callAlarm(); // et vérifie l'alarme si elle est activée 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(); //Si le bouton set est enfoncé, appelez la fonction de configuration de l'heure switchBacklight(true); }}//---------------------------------------------- ----//Lire les boutons statevoid readBtns(){ set_state =digitalRead(BTN_SET); ajuster_état =digitalRead(BTN_ADJUST); alarm_state =digitalRead(BTN_ALARM); if (!backlightOn &&!setupScreen) { if (set_state ==LOW || Adjust_state ==LOW || alarm_state ==LOW) { //Activer le rétroéclairage Backlight(true); //besoin de maintenir le bouton enfoncé pendant au moins 1/2 seconde de délai (500); } } else { if(!setupScreen) { if (alarm_state ==LOW) { alarmON =!alarmON; EEPROM.write(EEPROM_AO, (alarmeON) ? 1 :0); retard (500); switchBacklight(true); } else if (adjust_state ==LOW) { currentStyle =(currentStyle ==THERMO) ? STANDARD :(STYLE)((int)currentStyle + 1); EEPROM.write(EEPROM_CS, (octet)currentStyle); switch (currentStyle) { case STANDARD:lcdStandardSetup(); Pause; cas DUAL_THICK :lcdDualThickSetup(); Pause; cas DUAL_BEVEL :lcdDualBevelSetup(); Pause; cas DUAL_TREK :lcdDualTrekSetup(); Pause; cas DUAL_THIN :lcdDualThinSetup(); Pause; case MOT :lcdWordSetup(); Pause; cas BIO :lcdBioRhythmSetup(); Pause; cas THERMO :lcdThermometerSetup(); Pause; } lcd.clear(); lcdPrint(); retard (500); switchBacklight(true); } } if (set_state ==LOW) { setupMode =(setupMode ==ALARM_MIN) ? HORLOGE :(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("-HEURE et DATE-"); retard (2000); lcd.clear(); } } else { lcd.clear(); //Définir RTC tmElements_t tm; tm.Année =CalendarYrToTm(YY); tm.Mois =MM; tm.Jour =JJ ; tm.Heure =H; tm.Minute =M; tm.Seconde =0 ; time_t t =makeTime(tm); //utiliser la valeur time_t pour s'assurer que le jour de la semaine correct est défini if ​​(rtc.set(t) ==0) { // Success setTime(t); } else { Serial.println("L'ensemble RTC a échoué !"); } //rtc.adjust(DateTime(AA, MM, JJ, H, M, 0)); //Enregistrer l'heure et la date dans RTC IC EEPROM.write (EEPROM_AH, AH); //Enregistrer les heures d'alarme dans EEPROM EEPROM.write(EEPROM_AM, AM); //Enregistrer l'alarme minutée dans EEPROM EEPROM.write(EEPROM_BY + 0, BY>> 8); //Enregistrer l'année de naissance dans EEPROM EEPROM.write(EEPROM_BY + 1, BY &0xFF); //Enregistrer l'année de naissance dans EEPROM EEPROM.write(EEPROM_BM, BM); //Enregistrer le mois de naissance dans EEPROM EEPROM.write(EEPROM_BD, BD); //Enregistrer le jour de naissance dans l'EEPROM lcd.print("Saving...."); retard (2000); lcd.clear(); setupScreen =false; setupMode =HORLOGE ; switchBacklight(true); } délai (500); } }}//---------------------------------------------- -----//Lire l'heure et la date à partir de rtc icvoid getTimeDate(){ if (!setupScreen) { //DateTime now =rtc.now(); time_t t =maintenant(); JJ =jour(t); MM =mois(t); AA =année(t); H =heure(t); M =minute(t); S =seconde(t); } //Apporter quelques corrections... sDD =((DD <10) ? "0" :"") + String(DD); sMM =((MM <10) ? "0" :"") + Chaîne(MM); sYY =Chaîne(AA-2000); sH =((H <10) ? "0" :"") + Chaîne(H); sM =((M <10) ? "0" :"") + Chaîne(M); sS =((S <10) ? "0" :"") + Chaîne(S); sBD =((BD <10) ? "0" :"") + Chaîne(BD); sBM =((BM <10) ? "0" :"") + Chaîne(BM); sBY =Chaîne(BY); aH =((AH <10) ? "0" :"") + Chaîne(AH); aM =((AM <10) ? "0" :"") + Chaîne(AM);}//------------------------- -------------------------//Lire la température et l'humidité toutes les 6 secondes à partir du capteur DHT void getTempHum () { long currentMillis non signé =millis (); if (currentMillis - prevDhtMillis>=DHT_UPDATE_INTERVAL) { int chk =DHT.read21(DHT21); prevDhtMillis =currentMillis; hum =min(rond(DHT.humidité),99); temp =min(round(DHT.temperature),99); sTMP =((temp>
 9) ? "" :" ") + String(temp); sHUM =((hum> 9) ? "" :" ") + String(hum); }}//---------------------------------------------- ----//Activer ou désactiver le rétroéclairagevoid switchBacklight(bool on){ #ifdef NO_BACKLIGHT digitalWrite(LIGHT, LOW); rétroéclairage activé =vrai ; // Tromper le logiciel en pensant qu'il est activé même si ce n'est pas le cas #else #ifdef BACKLIGHT_ALWAYS_ON digitalWrite(LIGHT, HIGH); rétroéclairage activé =vrai ; #else digitalWrite(LIGHT, (on) ? HIGH :LOW); rétroéclairage activé =activé ; backlightTimeout =millis() + BACKLIGHT_TIMEOUT ; #endif #endif}//-------------------------------------------- -------//Imprime les valeurs dans le displayvoid lcdPrint(){ switch (currentStyle) { case STANDARD:lcdStandardLayout(); Pause; cas DUAL_THICK :lcdDualThickLayout(); Pause; cas DUAL_BEVEL :lcdDualBevelLayout(); Pause; cas DUAL_TREK :lcdDualTrekLayout(); Pause; cas DUAL_THIN :lcdDualThinLayout(); Pause; case MOT :lcdWordLayout(); Pause; cas BIO :lcdBioRhythmLayout(); Pause; cas THERMO : lcdThermometerLayout(); Pause; }}//---------------------------------------------- -- Disposition standard ---------------------------------------------- -----------------------void lcdStandardSetup(){}void lcdStandardLayout(){ String line1 =sH+":"+sM+":"+sS+" | "+aH+":"+aM ; String line2 =sDD+"/"+sMM+"/"+sYY +" | " + ((alarmON &&(S &0x01)) ? "ALARM" :" "); lcd.setCursor(0,0); //Première ligne lcd.print(line1) ; lcd.setCursor(0,1) ; //Deuxième ligne lcd.print(line2); }//Créer un caractère personnalisé à partir du programme memoryvoid createCharP(byte slot, byte* p){ for (int i =0; i <8; i++) { customChar[i] =pgm_read_byte(p++); } lcd.createChar(slot, customChar);}//------------------------------------- ----------- Disposition double épaisseur ------------------------------------ ---------------------------------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 ; si (h ==0) {h =12; } lcdDualThickPrintNumber(8, M, vrai); lcdDualThickPrintNumber (0, h, faux); lcd.setCursor(15,0); lcd.print((H>=12) ? "p" :"a"); lcd.setCursor(15,1) ; lcd.print("m"); #else lcdDualThickPrintNumber(8, M, vrai); lcdDualThickPrintNumber (0, H, vrai); alarme bool =(S &0x01); lcdWordShowBell (15, 0, alarme, BELL_CHAR); //en bas à droite lcdWordShowBell(15, 1, !alarm, BELL_CHAR); //en bas à droite #endif octet c =(S &1) ? C3 :32 ; lcd.setCursor(7,0) ; lcd.écrire(c); lcd.setCursor(7,1) ; lcd.write(c);}//Dessiner un numéro de 2 lignes// pos - position x pour dessiner le numéro// nombre - valeur à dessiner// leaderZero - si les zéros non significatifs doivent être affichésvoid lcdDualThickPrintNumber(int pos, int number, int menantZero){ int t =nombre / 10; int u =nombre % 10 ; if (t ==0 &&!leaderZero) { t =11; } lcdDualThickPrintDigit(pos, t); lcdDualThickPrintDigit(pos + 4, u);}//Dessiner un chiffre sur 2 lignes// pos - position x pour dessiner le numéro// nombre - valeur à dessiner 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[number][y][x]); } }}//---------------------------------------------- --- Disposition à double biseau -------------------------------------------- ----------------------------------------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 ; si (h ==0) {h =12; } lcdDualBevelPrintNumber(8, M, vrai); lcdDualBevelPrintNumber (0, h, faux); 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, vrai); alarme bool =(S &0x01); lcdWordShowBell (15, 0, alarme, 65); //en bas à droite lcdWordShowBell(15, 1, !alarm, 65); //en bas à droite #endif octet c =(S &1) ? 58 : 32 ; lcd.setCursor(7,0) ; lcd.écrire(c); lcd.setCursor(7,1) ; lcd.write(c);}//Dessiner un numéro de 2 lignes// pos - position x pour dessiner le numéro// nombre - valeur à dessiner// leaderZero - si les zéros non significatifs doivent être affichésvoid lcdDualBevelPrintNumber(int pos, int number, int menantZero){ int t =nombre / 10; int u =nombre % 10 ; if (t ==0 &&!leaderZero) { t =11; } lcdDualBevelPrintDigit(pos, t); lcdDualBevelPrintDigit(pos + 4, u);}//Dessiner un chiffre sur 2 lignes// pos - position x pour dessiner le numéro// nombre - valeur à dessiner 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[number][y][x]); } }}//---------------------------------------------- --- Disposition Dual Trek -------------------------------------------- -------------------------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.

Pièces et boîtiers personnalisés

Schémas