Despertador LCD com muitos rostos

Ferramentas e máquinas necessárias

Impressora 3D (genérica)

Aplicativos e serviços online

Arduino IDE

Sobre este projeto

Recursos do relógio

• Oito estilos de exibição diferentes
• Definir hora, data atual, data de nascimento e alarme
• Interruptor Mercury para desligar o alarme
• Controle de luz de fundo
• Sensor DHT21 de Temperatura e Umidade

Versão breadboard

Usando o relógio

Construindo um relógio totalmente acabado

Créditos

• Design de tela padrão por Michalis Vasilakis
• Fonte Dual Thick da Arduino World
• Fonte Dual Beveled do Arduino Forum
• Fonte Dual Trek de Carrie Sundra
• Fonte Dual Thin da Arduino World
• Conceito do Word por LAGSILVA
• Relógio biorritmo de John Bradnam
• Relógio meteorológico por ARDUinoautoMOTIVE

Atualizações

  - Corrigidos erros de grafia no relógio do WORD 
 - Adicionado # define para controlar a luz de fundo 
 - Aumento do tempo limite da luz de fundo de 5 para 10 segundos  

  - Adicionada configuração da data de nascimento e armazenamento EEPROM 
 - Adicionado relógio Biorhythm 
 - Codificação da tela de configuração limpa  

  - Adicionado suporte DHT21 
 - Adicionado termômetro e relógio de umidade  

Código

• DigitalClockAlarmV7.ino

DigitalClockAlarmV7.ino C / C ++

 / * 1602 LCD despertador * por John Bradnam ([email protected]) * * Visor 16x2:Configuração:Configuração de alarme * + ---------------- + + - --------------- + + ---------------- + * | HH:MM:SS | HH:MM | |> HH:> MM | | Definir alarme | * | DD / MM / AA | ALARME | |> DD /> MM /> AAAA | |> HH:> MM | * + ---------------- + + ---------------- + + ------------ ---- + * * 25/06/2020 * - Utilizou o relógio de Michalis Vasilakis como base de código (https://www.instructables.com/id/Arduino-Digital-Clock-With-Alarm-Function-custom-P/ ) * - Modificado para se adequar ao hardware - DS1302 RTC e luz de fundo LCD * - Suporte adicionado para diferentes estilos de exibição * - Design de tela padrão por Michalis Vasilakis * - Fonte Dual Thick por Arduino World (https://www.hackster.io/thearduinoworld/ arduino-digital-clock-version-1-b1a328) * - Fonte Dual Bevelled do Arduino Forum (https://forum.arduino.cc/index.php/topic,8882.0.html) * - Fonte Dual Trek de Carrie Sundra ( https://www.alpenglowindustries.com/blog/the-big-numbers-go-marching-2x2) * - Fonte Dual Thin da Arduino World (https://www.hackster.io/thearduinoworld/arduino-digital-clock -version-2-5bab65) * - Word concept por LAGSILVA (https://www.hackster.io/lagsilva/text-clock-bilingual-en-pt-with-arduino-881a6e) * 29/06/20 * - Corrigidos erros de grafia no relógio WORD * - Adicionado # define para cont retroiluminação rol * - Tempo limite de retroiluminação aumentado de 5 para 10 segundos * 22/11/20 * - Adicionado configuração de data de nascimento e armazenamento EEPROM * - Adicionado mostrador de relógio biorritmo * - Codificação de tela de configuração limpa * xx / xx / 21 * - Adicionado DHT21 Suporte * - Termômetro e relógio de umidade adicionados * /// Bibliotecas # include  #include  #include  #include  #include  # inclua  // descomente se desejar que a variante de exibição dupla espessa ou fina mostre o formato de 12h // # define DUAL_THICK_12HR // # define DUAL_THIN_12HR // descomente para controlar a luz de fundo // # define NO_BACKLIGHT // # define BACKLIGHT_ALWAYS_ON # define BACKLIGHT_TIMEOUT 10000 // descomente para testar gráficos de biorritmo // # 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 # definir DHT 21 9 // PB1 # define RTC_CE 10 // PB2 # define RTC_IO 12 // PB4 # define RTC_SCLK 13 // PB5 // Conexões e 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] ={"Domingo", "Segunda", "Terça", "Quarta", "Quinta", "Sexta", "Sábado"}; const int monthDays [12] ={31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; intervalo longo =300; int melody [] ={600, 800, 1000,1200}; // Variablesint DD, MM, YY, H, M, S, temp, hum, set_state, ajuste_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, BIRTH_DAY, BIRTH_DAY, BIRTH_DAY, BIRTH_DAY, BIRTH_DAY, BIRTH_DAY, BIRTH_DAY, BIRTH_DAY, ALARME_DIA, configuração ALARME_ALHO};; bool backlightOn =false; long backlightTimeout =0; byte customChar [8]; // --------------------- EEPROM --------- --------------------------------- # define EEPROM_AH 0 // Horas de alarme # define EEPROM_AM 1 // Minutos de alarme # definir EEPROM_AO 2 // Alarme ligado / desligado # define EEPROM_CS 3 // Estilo atual # define EEPROM_BY 4 // Ano de nascimento # define EEPROM_BM 6 // Mês de nascimento # define EEPROM_BD 7 // Dia de nascimento // --------- ------------ Word clock ------------------------------------ --Unidades de string [] ={"CEM", "UM", "DOIS", "TRÊS", "QUATRO", "CINCO", "SEIS", "SETE", "OITO", "NOVE"}; String adolescentes [] ={"DEZ", "ONZE", "DOZE", "TREZE", "QUATORZE", "QUINZE", "DEZESSEIS", "DEZESSETE", "DEZOITO", "DEZENOVE"}; Cordas dezenas [] ={"", "", "VINTE", "TRINTA", "QUARENTA", "CINQUENTA"}; // ---------------------- Ampulheta animação ---------------------------- # define HOURGLASS_FRAMES 8 # define HOURGLASS_CHAR 0 # define FRAME_TIMEOUT 200; int nextFrame =0; long frameTimeout =0; ampulheta de byte const [HOURGLASS_FRAMES] [8] PROGMEM ={{B11111, B11111, B01010, B01010, B01010, B01010, B10001, B11111}, {B11111, B11011, B01110, B01010, B01010, B0101} {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, B0101}; // ---------------------- Alarme, relógio e caracteres personalizados DHT ------------------ ---------- # 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 relógio de byte [8] PROGMEM ={0x0, 0xe, 0x15, 0x17, 0x11, 0xe, 0x0}; termômetro de byte const [8] PROGMEM ={0x4, 0xa, 0xa, 0xe, 0xe, 0x1f, 0x1f, 0xe}; const gota de byte [8] PROGMEM ={0x4, 0x4, 0xa, 0xa, 0x11, 0x11, 0x11, 0xe}; # define DHT_UPDATE_INTERVAL 6000 // ------------------- --- BioRhythm Clock ---------------------------- // Constantes de caracteres personalizados (M é MSB ou caractere de barra superior r, L é LSB ou caractere de barra inferior # define PHYSICAL_M 3 # define PHYSICAL_L 4 # define EMOTIONAL_M 5 # define EMOTIONAL_L 6 # define INTELLECTUAL_M 7 # define INTELLECTUAL_L 8 // --------------- ------- Fonte Thick Square ---------------------------- # 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}; const byte C_2 [8] PROGMEM ={0x00,0x00,0x00,0x00,0x00,0x1F, 0x1F, 0x1F}; const 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}}, // em branco}; // ---------------------- Fonte chanfrada espessa -------------- -------------- # 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 _RT000, B00000, B00000; [8] PROGMEM ={B11100, B11110, B11111, B11111, B11111, B11111, B11111, B11111}; const byte _LL [8] PROGMEM ={B11111, B11111, B11111, B11111, B11111, B11111} B11111, const byte _LB [8] PROGMEM ={B00000, B00000, B00000, B00000, B00000, B11111, B11111, B11111}; const byte _LR [8] PROGMEM ={B11111, B11111, B11111, B11111, B11111, B10011} B11111, B11111, B11111, B11111; const byte _UMB [8] PROGMEM ={B11111, B11111, B11111, B00000, B00000, B00000, B11111, B11111}; const byte _LMB [8] PROGMEM ={B11111, B11111, B11111, B11111, B111, B111, B111, B111, 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}} // em branco}; // ---------------------- Fonte do Trek -------- -------------------- # define K0 0 # define K1 1 # define K2 2 # define K3 3 # define K4 4 # define K5 5 # define K6 6 # define 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}; const byte K_2 [8] PROGMEM ={0x00,0x00,0x00,0x00,0x00,0x00,0x1F, 0x1F}; const byte K_3 [8] PROGMEM ={0x1F, 0x1F, 0x03,0x03,0x03,0x03, 0x1F, 0x1F}; const byte K_4 [8] PROGMEM ={0x1F, 0x1F, 0x18,0x18,0x18,0x18,0x1F, 0x1F}; const byte K_5 [8] PROGMEM ={0x1F, 0x1F, 0x18,0x18,0x18, 0x18,0x18,0x18}; const byte K_6 [8] PROGMEM ={0x03,0x03,0x03,0x03, 0x03,0x03,0x1F, 0x1F}; const byte K_7 [8] PROGMEM ={0x1F, 0x1F, 0x03,0x03,0x03,0x03,0x03,0x03}; const 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}}, // em branco}; // ---------- ------------ Fonte fina ---------------------------- # 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}; const byte T_2 [8] PROGMEM ={0x0E, 0x08,0x08,0x08,0x08,0x08,0x08,0x0E}; const byte T_3 [8] PROGMEM ={0x0E, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0E}; const byte T_5 [8] PROGMEM ={0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0E}; const byte T_4 [8] PROGMEM ={0x0E, 0x0A, 0x0A, 0x0A, 0x0 A, 0x0A, 0x0A, 0x0A}; const byte T_6 [8] PROGMEM ={0x0E, 0x02,0x02,0x02,0x02,0x02,0x02,0x02}; const byte T_7 [8] PROGMEM ={0x18,0x18,0x18, 0x18,0x18,0x1E, 0x1F, 0x1F}; // lcd desenhar funções de caracteresconst 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} // em branco}; // ---------------------- Inicialização geral ------------------------ ---- configuração vazia () {Serial.begin (115200); // Definir saídas / entradas pinMode (BTN_SET, INPUT); pinMode (BTN_ADJUST, INPUT); pinMode (BTN_ALARM, INPUT); pinMode (BTN_TILT, INPUT); pinMode (SPEAKER, OUTPUT); pinMode (LUZ, SAÍDA); // Verifique se o RTC tem uma data / hora válida, caso não defina para 00:00:00 01/01/2018. // Isso funcionará apenas na primeira vez ou se a bateria da moeda estiver fraca. // setSyncProvider () faz com que a biblioteca Time sincronize com // o RTC externo chamando RTC.get () a cada cinco minutos por padrão. setSyncProvider (rtc.get); if (timeStatus ()! =timeSet) {Serial.println ("Configurando a hora padrão"); // Definir RTC tmElements_t tm; tm.Year =CalendarYrToTm (2020); tm.Mês =06; tm.Day =26; tm.Hour =7; tm.Minuto =52; tm.Segundo =0; time_t t =makeTime (tm); // use o valor time_t para garantir que o dia da semana correto seja definido if (rtc.set (t) ==0) {// Success setTime (t); } else {Serial.println ("RTC set failed!"); }} atraso (100); // Lê a hora do alarme da memória EEPROM 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); // Verifique se os números que você lê são válidos. (Horas:0-23 e Minutos:0-59) if (AH> 23) {AH =0; } se (AM> 59) {AM =0; } // Ler data de nascimento de EEPROM BY =(EEPROM.read (EEPROM_BY + 0) <<8) | EEPROM.read (EEPROM_BY + 1); if (BY <1900 || BY> 2099) {BY =2000; } BM =EEPROM.read (EEPROM_BM); se (BM <0 || BM> 12) {BM =1; } BD =EEPROM.read (EEPROM_BD); se (BD <0 || BD> 31) {BD =1; } // Configura o estilo atual lcd.begin (16,2); currentStyle =(cs> (uint8_t) THERMO)? PADRÃO:(ESTILO) cs; switch (currentStyle) {case STANDARD:lcdStandardSetup (); pausa; case DUAL_THICK:lcdDualThickSetup (); pausa; case DUAL_BEVEL:lcdDualBevelSetup (); pausa; case DUAL_TREK:lcdDualTrekSetup (); pausa; case DUAL_THIN:lcdDualThinSetup (); pausa; case WORD:lcdWordSetup (); pausa; caso BIO:lcdBioRhythmSetup (); pausa; case THERMO:lcdThermometerSetup (); pausa; } #ifdef BACKLIGHT_ALWAYS_ON switchBacklight (true); # endif} // ---------------------- Loop do programa principal ----------- ----------------- void loop () {readBtns (); // Botões de leitura getTimeDate (); // Hora e data de leitura do RTC getTempHum (); // Lê temperatura e umidade if (! SetupScreen) {lcdPrint (); // Normalmente imprime a hora / data / alarme atual no LCD if (alarmON) {callAlarm (); // e verifique se o alarme está ativado 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 (); // Se o conjunto de botões for pressionado, chame a função de configuração de tempo switchBacklight (true); }} // ---------------------------------------------- ---- // Botões de leitura statevoid readBtns () {set_state =digitalRead (BTN_SET); ajustar_estado =digitalRead (BTN_ADJUST); alarm_state =digitalRead (BTN_ALARM); if (! backlightOn &&! setupScreen) {if (set_state ==LOW || Adjust_state ==LOW || alarm_state ==LOW) {// Liga a retroiluminação switchBacklight (true); // precisa manter o botão pressionado por pelo menos 1/2 segundo de atraso (500); }} else {if (! setupScreen) {if (alarm_state ==LOW) {alarmON =! alarmON; EEPROM.write (EEPROM_AO, (alarmON)? 1:0); atraso (500); switchBacklight (true); } else if (Adjust_state ==LOW) {currentStyle =(currentStyle ==THERMO)? STANDARD:(STYLE) ((int) currentStyle + 1); EEPROM.write (EEPROM_CS, (byte) currentStyle); switch (currentStyle) {case STANDARD:lcdStandardSetup (); pausa; case DUAL_THICK:lcdDualThickSetup (); pausa; case DUAL_BEVEL:lcdDualBevelSetup (); pausa; case DUAL_TREK:lcdDualTrekSetup (); pausa; case DUAL_THIN:lcdDualThinSetup (); pausa; case WORD:lcdWordSetup (); pausa; caso BIO:lcdBioRhythmSetup (); pausa; case THERMO:lcdThermometerSetup (); pausa; } lcd.clear (); lcdPrint (); atraso (500); switchBacklight (true); }} if (set_state ==LOW) {setupMode =(setupMode ==ALARM_MIN)? CLOCK:(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 ("- HORA e DATA-"); atraso (2000); lcd.clear (); }} else {lcd.clear (); // Definir RTC tmElements_t tm; tm.Year =CalendarYrToTm (YY); tm.Month =MM; tm.Day =DD; tm.Hour =H; tm.Minuto =M; tm.Segundo =0; time_t t =makeTime (tm); // use o valor time_t para garantir que o dia da semana correto seja definido if (rtc.set (t) ==0) {// Success setTime (t); } else {Serial.println ("RTC set failed!"); } //rtc.adjust(DateTime(YY, MM, DD, H, M, 0)); // Salvar hora e data no RTC IC EEPROM.write (EEPROM_AH, AH); // Salve as horas de alarme em EEPROM EEPROM.write (EEPROM_AM, AM); // Salve o alarme em minuto em EEPROM EEPROM.write (EEPROM_BY + 0, BY>> 8); // Salve o ano de nascimento em EEPROM EEPROM.write (EEPROM_BY + 1, BY &0xFF); // Salve o ano de nascimento na EEPROM EEPROM.write (EEPROM_BM, BM); // Salve o mês de nascimento na EEPROM EEPROM.write (EEPROM_BD, BD); // Salve o dia do nascimento na EEPROM lcd.print ("Saving ...."); atraso (2000); lcd.clear (); setupScreen =false; setupMode =CLOCK; switchBacklight (true); } atraso (500); }}} // --------------------------------------------- ----- // Hora e data de leitura de rtc icvoid getTimeDate () {if (! SetupScreen) {// DateTime now =rtc.now (); time_t t =now (); DD =dia (t); MM =mês (t); YY =ano (t); H =hora (t); M =minuto (t); S =segundo (t); } // Faça algumas correções ... sDD =((DD <10)? "0":"") + String (DD); sMM =((MM <10)? "0":"") + String (MM); sYY =String (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);} // ------------------------- ------------------------- // Lê a temperatura e a umidade a cada 6 segundos do DHT sensorvoid getTempHum () {unsigned long currentMillis =millis (); if (currentMillis - prevDhtMillis> =DHT_UPDATE_INTERVAL) {int chk =DHT.read21 (DHT21); prevDhtMillis =currentMillis; hum =min (redondo (DHT.umidade), 99); temp =min (redondo (temperatura DHT), 99); sTMP =((temp>
 9)? "":"") + String (temp); sHUM =((hum> 9)? "":"") + Corda (hum); }} // ---------------------------------------------- ---- // Liga ou desliga a retroiluminação para evitar o switchBacklight (bool on) {#ifdef NO_BACKLIGHT digitalWrite (LIGHT, LOW); backlightOn =true; // Engane o software, fazendo-o pensar que está ativado, embora não seja #else #ifdef BACKLIGHT_ALWAYS_ON digitalWrite (LIGHT, HIGH); backlightOn =true; #else digitalWrite (LIGHT, (on)? HIGH:LOW); backlightOn =on; backlightTimeout =millis () + BACKLIGHT_TIMEOUT; #endif #endif} // ------------------------------------------- ------- // Imprimir valores no displayvoid lcdPrint () {switch (currentStyle) {case STANDARD:lcdStandardLayout (); pausa; case DUAL_THICK:lcdDualThickLayout (); pausa; case DUAL_BEVEL:lcdDualBevelLayout (); pausa; case DUAL_TREK:lcdDualTrekLayout (); pausa; case DUAL_THIN:lcdDualThinLayout (); pausa; case WORD:lcdWordLayout (); pausa; caso BIO:lcdBioRhythmLayout (); pausa; case THERMO:lcdThermometerLayout (); pausa; }} // ---------------------------------------------- -- Layout padrão ---------------------------------------------- ----------------------- void lcdStandardSetup () {} void lcdStandardLayout () {String line1 =sH + ":" + sM + ":" + sS + "| "+ aH +":"+ aM; String line2 =sDD + "/" + sMM + "/" + sYY + "|" + ((alarmON &&(S &0x01))? "ALARM":""); lcd.setCursor (0,0); // Primeira linha lcd.print (linha1); lcd.setCursor (0,1); // Segunda linha lcd.print (linha2); } // Cria um caractere personalizado do programa memoryvoid createCharP (slot de byte, byte * p) {for (int i =0; i <8; i ++) {customChar [i] =pgm_read_byte (p ++); } lcd.createChar (slot, customChar);} // ------------------------------------- ----------- Layout Dual Thick ------------------------------------ --------------------------------- 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; se (h ==0) {h =12; } lcdDualThickPrintNumber (8, M, verdadeiro); lcdDualThickPrintNumber (0, h, falso); 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, verdadeiro); alarme bool =(S &0x01); lcdWordShowBell (15, 0, alarme, BELL_CHAR); // canto inferior direito lcdWordShowBell (15, 1,! alarm, BELL_CHAR); // canto inferior direito #endif byte c =(S &1)? C3:32; lcd.setCursor (7,0); lcd.write (c); lcd.setCursor (7,1); lcd.write (c);} // Desenhe um número de 2 linhas // pos - posição x para desenhar o número // número - valor para desenhar // LeadZero - se os zeros à esquerda devem ser exibidos evite lcdDualThickPrintNumber (int pos, int number, int leadZero) {int t =número / 10; int u =número% 10; if (t ==0 &&! leaderZero) {t =11; } lcdDualThickPrintDigit (pos, t); lcdDualThickPrintDigit (pos + 4, u);} // Desenhe um dígito de 2 linhas // pos - posição x para desenhar número // número - valor para drawvoid lcdDualThickPrintDigit (int pos, int number) {for (int y =0; y <2; y ++) {lcd.setCursor (pos, y); para (int x =0; x <3; x ++) {lcd.write (blockChar [número] [y] [x]); }}} // --------------------------------------------- --- Layout Dual Bevel -------------------------------------------- ------------------------- 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; se (h ==0) {h =12; } lcdDualBevelPrintNumber (8, M, verdadeiro); lcdDualBevelPrintNumber (0, h, falso); 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, verdadeiro); alarme bool =(S &0x01); lcdWordShowBell (15, 0, alarme, 65); // canto inferior direito lcdWordShowBell (15, 1,! alarm, 65); // canto inferior direito #endif byte c =(S &1)? 58:32; lcd.setCursor (7,0); lcd.write (c); lcd.setCursor (7,1); lcd.write (c);} // Desenhe um número de 2 linhas // pos - posição x para desenhar o número // número - valor para desenhar // leaderZero - se os zeros iniciais devem ser exibidos evite lcdDualBevelPrintNumber (int pos, int number, int leadZero) {int t =número / 10; int u =número% 10; if (t ==0 &&! leaderZero) {t =11; } lcdDualBevelPrintDigit (pos, t); lcdDualBevelPrintDigit (pos + 4, u);} // Desenhe um dígito de 2 linhas // pos - posição x para desenhar o número // número - valor para drawvoid lcdDualBevelPrintDigit (int pos, int number) {for (int y =0; y <2; y ++) {lcd.setCursor (pos, y); para (int x =0; x <3; x ++) {lcd.write (bevelChar [número] [y] [x]); }}} // --------------------------------------------- --- Layout 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, verdadeiro); lcdDualTrekPrintNumber (0, H, verdadeiro); 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.

Peças personalizadas e gabinetes

Esquemas