Reloj retro con ESP, RTC y matriz LED

Hola a todos

Ya teníamos algunos relojes en nuestro blog, ya sea Radio reloj o sobre eso Protocolo NTP, con pantalla  o la nuestra Panel U64. Hoy me gustaría presentarles una variante con ESP, RTC y matriz de LED. Un colega más joven me señaló amablemente que este tipo de relojes han estado desactualizados hace mucho tiempo y me hizo saber que mientras tanto ... bueno, no digamos que soy uno de los aficionados más jóvenes y me preguntó "retro" en el Poner títulos.

Para nuestro proyecto necesitamos:

Encontramos este proyecto en GitHub  y adaptado aquí para nuestros propósitos.

Antes de comenzar, recomiendo configurar el tiempo RTC con un Arduino, ya que esto a veces puede causar problemas con los ESP. Tenemos eso en nuestra libre E-book  explicado en detalle sobre el RTC.

Nos gusta mucho este proyecto, porque la fecha también se establece y el efecto del cambio de tiempo se ha implementado bien.

El cableado:

Amica Matriz de LED RTC DS3231
D1 SDA
D2 SCL
D5 CLK
D7 DIN
D8 CS
VIN VCC
GND GND GND
3.3V VCC

 

Aquí está el código:

 

//*********************************************************************************************************
// * ESP8266 MatrixClock *
//*********************************************************************************************************
//
// primer lanzamiento el 26/02/2017
// actualizado el 26/03/2019
// Versión 1.2.1
//
//
// EL SOFTWARE SE PROPORCIONA "TAL CUAL" PARA USO PRIVADO SOLAMENTE, NO ES PARA USO COMERCIAL EN TODO O PARTE O CONCEPTO.
// PARA USO PERSONAL SE SUMINISTRA SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO PERO SIN LIMITARSE AL
// GARANTÍAS DE COMERCIABILIDAD, APTITUD PARA UN PROPÓSITO EN PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO EL AUTOR
// O EL TITULAR DE LOS DERECHOS DE AUTOR SERÁ RESPONSABLE POR CUALQUIER RECLAMACIÓN, DAÑO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN DE CONTRATO, TORT O
// DE OTRA MANERA, DERIVADO DE, FUERA DE O EN RELACIÓN CON EL SOFTWARE O EL USO U OTRAS OFERTAS EN EL SOFTWARE
// Hecho de https://github.com/schreibfaul1/ESP8266-LED-Matrix-Clock
// Editado por AZ-Delivery

#include <SPI.h>
#include <Teletipo.h>
#include <ESP8266WiFi.h>
#include <Alambre.h>
#include <tiempo.h>

#definir SDA        5      // pin sda (I2C)
#definir SCL        4      // pin scl (I2C)
#definir CS         15     // pin cs (SPI)
#definir numMAX     4      // Número de módulos en cascada


sin firmar corta maxPosX = numMAX * 8 - 1;            // posición máxima calculada
sin firmar corta LEDarr[numMAX][8];                   // matriz de caracteres para mostrar (40 * 8)
sin firmar corta helpArrMAX[numMAX * 8];              // helperarray para chardecoding
sin firmar corta helpArrPos[numMAX * 8];              // helperarray pos de chardecoding
sin firmar int z_PosX = 0;                            // xPosition en la pantalla para mostrar la hora
sin firmar int d_PosX = 0;                            // xPosition en la pantalla para la fecha
bool f_tckr1s = falso;
bool f_tckr50ms = falso;
bool f_tckr24h = falso;
sin firmar largo época = 0;


// Variables para RTC DS3231
const sin firmar char DS3231_ADDRESS = 0x68;
const sin firmar char secondREG = 0x00;
const sin firmar char minutoREG = 0x01;
const sin firmar char hourREG = 0x02;
const sin firmar char WTREG = 0x03;                   // día de la semana
const sin firmar char dateREG = 0x04;
const sin firmar char mesREG = 0x05;
const sin firmar char añoREG = 0x06;
const sin firmar char alarm_min1secREG = 0x07;
const sin firmar char alarm_min1minREG = 0x08;
const sin firmar char alarm_min1hrREG = 0x09;
const sin firmar char alarm_min1dateREG = 0x0A;
const sin firmar char alarm_min2minREG = 0x0B;
const sin firmar char alarm_min2hrREG = 0x0C;
const sin firmar char alarm_min2dateREG = 0x0D;
const sin firmar char controlREG = 0x0E;
const sin firmar char statusREG = 0x0F;
const sin firmar char ageoffsetREG = 0x10;
Const Unsigned Char tempMSBREG = 0x11;
Const Unsigned Char tempLSBREG = 0x12;
Const Unsigned Char _24_hour_format = 0;
Const Unsigned Char _12_hour_format = 1;
Const Unsigned Char Soy = 0;
Const Unsigned Char PM = 1;

Estructura Datetime {     Unsigned Corto sek1, sek2, sek12, min1, min2, min12, std1, std2, std12;     Unsigned Corto tag1, tag2, tag12, mon1, mon2, mon12, jahr1, jahr2, jahr12, Wt;
} Mez;


El objeto para el Ticker
teletipo tckr;



Meses
Char M_arr[12][5] = { { '.', 'J', 'a', 'n', '.' }, { '.', 'F', 'e', 'b', '.' },         { '.', 'M', 'a', 'r', '.' }, { '.', 'A', 'p', 'r', '.' }, { '.', 'M', 'a',                 'y', ' ' }, { '.', 'J', 'u', 'n', 'e' }, { '.', 'J', 'u', 'l', 'y' }, {                 '.', 'A', 'u', 'g', '.' }, { '.', 'S', 'e', 'p', 't' }, { '.', 'O', 'c',                 't', '.' }, { '.', 'N', 'o', 'v', '.' }, { '.', 'D', 'e', 'c', '.' } };
Días
Char WT_arr[7][4] = { { 'S', 'u', 'n', ',' }, { 'M', 'o', 'n', ',' }, { 'T', 'u', 'e', ',' }, {         'W', 'e', 'd', ',' }, { 'T', 'h', 'u', ',' }, { 'F', 'r', 'i', ',' }, { 'S', 'a', 't', ',' } };

Zeichensatz 5x8 en einer 8x8 Matrix, 0,0 ist rechts oben
Unsigned Corto Const font1[96][9] = { { 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,         0x00, 0x00, 0x00 },   0x20, Espacio         { 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x04, 0x00 },   0x21, !         { 0x07, 0x09, 0x09, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00 },   0x22, "         { 0x07, 0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a, 0x00 },   0x23, ?         { 0x07, 0x04, 0x0f, 0x14, 0x0e, 0x05, 0x1e, 0x04, 0x00 },   0x24, $         { 0x07, 0x19, 0x19, 0x02, 0x04, 0x08, 0x13, 0x13, 0x00 },   0x25, %         { 0x07, 0x04, 0x0a, 0x0a, 0x0a, 0x15, 0x12, 0x0d, 0x00 },   0x26, &         { 0x07, 0x04, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00 },   0x27, '         { 0x07, 0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02, 0x00 },   0x28, (         { 0x07, 0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08, 0x00 },   0x29, )         { 0x07, 0x04, 0x15, 0x0e, 0x1f, 0x0e, 0x15, 0x04, 0x00 },   0x2a, *         { 0x07, 0x00, 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00, 0x00 },   0x2b, +         { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02 },   0x2c, ,         { 0x07, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00 },   0x2d, -         { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00 },   0x2e, .         { 0x07, 0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x10, 0x00 },   0x2f, /         { 0x07, 0x0e, 0x11, 0x13, 0x15, 0x19, 0x11, 0x0e, 0x00 },   0x30, 0         { 0x07, 0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e, 0x00 },   0x31, 1         { 0x07, 0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f, 0x00 },   0x32, 2         { 0x07, 0x0e, 0x11, 0x01, 0x06, 0x01, 0x11, 0x0e, 0x00 },   0x33, 3         { 0x07, 0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02, 0x00 },   0x34, 4         { 0x07, 0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e, 0x00 },   0x35, 5         { 0x07, 0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e, 0x00 },   0x36, 6         { 0x07, 0x1f, 0x01, 0x02, 0x04, 0x08, 0x08, 0x08, 0x00 },   0x37, 7         { 0x07, 0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e, 0x00 },   0x38, 8         { 0x07, 0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c, 0x00 },   0x39, 9         { 0x04, 0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x00, 0x00 },   0x3a, :         { 0x07, 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x04, 0x08, 0x00 },   0x3b, ;         { 0x07, 0x02, 0x04, 0x08, 0x10, 0x08, 0x04, 0x02, 0x00 },   0x3c, <         { 0x07, 0x00, 0x00, 0x1f, 0x00, 0x1f, 0x00, 0x00, 0x00 },   0x3d, ?         { 0x07, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x00 },   0x3e, >         { 0x07, 0x0e, 0x11, 0x01, 0x02, 0x04, 0x00, 0x04, 0x00 },   0x3f, ?         { 0x07, 0x0e, 0x11, 0x17, 0x15, 0x17, 0x10, 0x0f, 0x00 },   0x40, ?         { 0x07, 0x04, 0x0a, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x00 },   // 0x41, A         { 0x07, 0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e, 0x00 },   // 0x42, B         { 0x07, 0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e, 0x00 },   // 0x43, C         { 0x07, 0x1e, 0x09, 0x09, 0x09, 0x09, 0x09, 0x1e, 0x00 },   // 0x44, D         { 0x07, 0x1f, 0x10, 0x10, 0x1c, 0x10, 0x10, 0x1f, 0x00 },   // 0x45, E         { 0x07, 0x1f, 0x10, 0x10, 0x1f, 0x10, 0x10, 0x10, 0x00 },   // 0x46, F         { 0x07, 0x0e, 0x11, 0x10, 0x10, 0x13, 0x11, 0x0f, 0x00 },   // 0x37, G         { 0x07, 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11, 0x00 },   // 0x48, H         { 0x07, 0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e, 0x00 },   // 0x49, yo         { 0x07, 0x1f, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c, 0x00 },   // 0x4a, J         { 0x07, 0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11, 0x00 },   // 0x4b, K         { 0x07, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f, 0x00 },   // 0x4c, L         { 0x07, 0x11, 0x1b, 0x15, 0x11, 0x11, 0x11, 0x11, 0x00 },   // 0x4d, M         { 0x07, 0x11, 0x11, 0x19, 0x15, 0x13, 0x11, 0x11, 0x00 },   // 0x4e, N         { 0x07, 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e, 0x00 },   // 0x4f, O         { 0x07, 0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10, 0x00 },   // 0x50, P         { 0x07, 0x0e, 0x11, 0x11, 0x11, 0x15, 0x12, 0x0d, 0x00 },   // 0x51, Q         { 0x07, 0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11, 0x00 },   // 0x52, R         { 0x07, 0x0e, 0x11, 0x10, 0x0e, 0x01, 0x11, 0x0e, 0x00 },   // 0x53, S         { 0x07, 0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00 },   // 0x54, T         { 0x07, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e, 0x00 },   // 0x55, U         { 0x07, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04, 0x00 },   // 0x56, V         { 0x07, 0x11, 0x11, 0x11, 0x15, 0x15, 0x1b, 0x11, 0x00 },   // 0x57, W         { 0x07, 0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11, 0x00 },   // 0x58, X         { 0x07, 0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04, 0x00 },   // 0x59, Y         { 0x07, 0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f, 0x00 },   // 0x5a, Z         { 0x07, 0x0e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0e, 0x00 },   // 0x5b, [         { 0x07, 0x10, 0x10, 0x08, 0x04, 0x02, 0x01, 0x01, 0x00 },   // 0x5c, '\'         { 0x07, 0x0e, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0e, 0x00 },   // 0x5d,]         { 0x07, 0x04, 0x0a, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00 },   // 0x5e, ^         { 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00 },   // 0x5f, _         { 0x07, 0x04, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 },   // 0x60, `         { 0x07, 0x00, 0x0e, 0x01, 0x0d, 0x13, 0x13, 0x0d, 0x00 },   // 0x61, a         { 0x07, 0x10, 0x10, 0x10, 0x1c, 0x12, 0x12, 0x1c, 0x00 },   // 0x62, b         { 0x07, 0x00, 0x00, 0x00, 0x0e, 0x10, 0x10, 0x0e, 0x00 },   // 0x63, c         { 0x07, 0x01, 0x01, 0x01, 0x07, 0x09, 0x09, 0x07, 0x00 },   // 0x64, d         { 0x07, 0x00, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0f, 0x00 },   // 0x65, e         { 0x07, 0x06, 0x09, 0x08, 0x1c, 0x08, 0x08, 0x08, 0x00 },   // 0x66, f         { 0x07, 0x00, 0x0e, 0x11, 0x13, 0x0d, 0x01, 0x01, 0x0e },   // 0x67, g         { 0x07, 0x10, 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x00 },   // 0x68, h         { 0x05, 0x00, 0x02, 0x00, 0x06, 0x02, 0x02, 0x07, 0x00 },   // 0x69, i         { 0x07, 0x00, 0x02, 0x00, 0x06, 0x02, 0x02, 0x12, 0x0c },   // 0x6a, j         { 0x07, 0x10, 0x10, 0x12, 0x14, 0x18, 0x14, 0x12, 0x00 },   // 0x6b, k         { 0x05, 0x06, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00 },   // 0x6c, l         { 0x07, 0x00, 0x00, 0x0a, 0x15, 0x15, 0x11, 0x11, 0x00 },   // 0x6d, m         { 0x07, 0x00, 0x00, 0x16, 0x19, 0x11, 0x11, 0x11, 0x00 },   // 0x6e, n         { 0x07, 0x00, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e, 0x00 },   // 0x6f, o         { 0x07, 0x00, 0x00, 0x1c, 0x12, 0x12, 0x1c, 0x10, 0x10 },   // 0x70, p         { 0x07, 0x00, 0x00, 0x07, 0x09, 0x09, 0x07, 0x01, 0x01 },   // 0x71, q         { 0x07, 0x00, 0x00, 0x16, 0x19, 0x10, 0x10, 0x10, 0x00 },   // 0x72, r         { 0x07, 0x00, 0x00, 0x0f, 0x10, 0x0e, 0x01, 0x1e, 0x00 },   // 0x73, s         { 0x07, 0x08, 0x08, 0x1c, 0x08, 0x08, 0x09, 0x06, 0x00 },   // 0x74, t         { 0x07, 0x00, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0d, 0x00 },   // 0x75, u         { 0x07, 0x00, 0x00, 0x11, 0x11, 0x11, 0x0a, 0x04, 0x00 },   // 0x76, v         { 0x07, 0x00, 0x00, 0x11, 0x11, 0x15, 0x15, 0x0a, 0x00 },   // 0x77, w         { 0x07, 0x00, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x00 },   // 0x78, x         { 0x07, 0x00, 0x00, 0x11, 0x11, 0x0f, 0x01, 0x11, 0x0e },   // 0x79, y         { 0x07, 0x00, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f, 0x00 },   // 0x7a, z         { 0x07, 0x06, 0x08, 0x08, 0x10, 0x08, 0x08, 0x06, 0x00 },   // 0x7b, {         { 0x07, 0x04, 0x04, 0x04, 0x00, 0x04, 0x04, 0x04, 0x00 },   // 0x7c, |         { 0x07, 0x0c, 0x02, 0x02, 0x01, 0x02, 0x02, 0x0c, 0x00 },   // 0x7d,}         { 0x07, 0x08, 0x15, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 },   // 0x7e, ~         { 0x07, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x00 }    // 0x7f, DEL
};
//**************************************************************************************************

//**************************************************************************************************
vacío rtc_init(no firmado carbonizarse sda, no firmado carbonizarse scl) {     Cable.empezar(sda, scl);     rtc_Write(controlREG, 0x00);
}
//**************************************************************************************************
// Código BCD
//**************************************************************************************************
no firmado carbonizarse dec2bcd(no firmado carbonizarse X) { // valor 0 ... 99     no firmado carbonizarse z, mi, r;     mi = X % 10;     z = X / 10;     z = z << 4;     r = mi | z;     regreso (r);
}
no firmado carbonizarse bcd2dec(no firmado carbonizarse X) { // valor 0 ... 99     En t z, mi;     mi = X & 0x0F;     z = X & 0xF0;     z = z >> 4;     z = z * 10;     regreso (z + mi);
}
//**************************************************************************************************
// Código RTC I2C
//**************************************************************************************************
no firmado carbonizarse rtc_Read(no firmado carbonizarse recapitulación) {     Cable.beginTransmission(DS3231_ADDRESS);     Cable.escribir(recapitulación);     Cable.endTransmission();     Cable.solicitud de((no firmado carbonizarse) DS3231_ADDRESS, (no firmado carbonizarse) 1);     regreso (Cable.leer());
}
vacío rtc_Write(no firmado carbonizarse recapitulación, no firmado carbonizarse valor) {     Cable.beginTransmission(DS3231_ADDRESS);     Cable.escribir(recapitulación);     Cable.escribir(valor);     Cable.endTransmission();
}
//**************************************************************************************************
no firmado carbonizarse rtc_sekunde() {     regreso (bcd2dec(rtc_Read(secondREG)));
}
no firmado carbonizarse rtc_minute() {     regreso (bcd2dec(rtc_Read(minutoREG)));
}
no firmado carbonizarse rtc_stunde() {     regreso (bcd2dec(rtc_Read(hourREG)));
}
no firmado carbonizarse rtc_wochentag() {     regreso (bcd2dec(rtc_Read(WTREG)));
}
no firmado carbonizarse rtc_tag() {     regreso (bcd2dec(rtc_Read(dateREG)));
}
no firmado carbonizarse rtc_monat() {     regreso (bcd2dec(rtc_Read(mesREG)));
}
no firmado carbonizarse rtc_jahr() {     regreso (bcd2dec(rtc_Read(añoREG)));
}
vacío rtc_sekunde(no firmado carbonizarse sek) {     rtc_Write(secondREG, (dec2bcd(sek)));
}
vacío rtc_minute(no firmado carbonizarse min) {     rtc_Write(minutoREG, (dec2bcd(min)));
}
vacío rtc_stunde(no firmado carbonizarse std) {     rtc_Write(hourREG, (dec2bcd(std)));
}
vacío rtc_wochentag(no firmado carbonizarse wt) {     rtc_Write(WTREG, (dec2bcd(wt)));
}
vacío rtc_tag(no firmado carbonizarse etiqueta) {     rtc_Write(dateREG, (dec2bcd(etiqueta)));
}
vacío rtc_monat(no firmado carbonizarse Lun) {     rtc_Write(mesREG, (dec2bcd(Lun)));
}
vacío rtc_jahr(no firmado carbonizarse jahr) {     rtc_Write(añoREG, (dec2bcd(jahr)));
}
//**************************************************************************************************
vacío rtc_set(tm* tt) {     rtc_sekunde((no firmado carbonizarse) tt->tm_sec);     rtc_minute((no firmado carbonizarse) tt->tm_min);     rtc_stunde((no firmado carbonizarse) tt->tm_hour);     rtc_tag((no firmado carbonizarse) tt->tm_mday);     rtc_monat((no firmado carbonizarse) tt->tm_mon + 1);     rtc_jahr((no firmado carbonizarse) tt->tm_year - 100);     rtc_wochentag((no firmado carbonizarse) tt->tm_wday);
}
//**************************************************************************************************
flotador rtc_temp() {     flotador t = 0.0;     sin firmar char lowByte = 0;     firmado char highByte = 0;     lowByte = rtc_Read(tempLSBREG);     highByte = rtc_Read(tempMSBREG);     lowByte >>= 6;     lowByte &= 0x03;     t = ((flotar) lowByte);     t *= 0.25;     t += highByte;     volver (t); // devuelve el valor temporal
}
//**************************************************************************************************
nulo rtc2mez() {     sin firmar corta Si no;       // número del año     sin firmar corta Número de siglo = 6;   // Número de siglo para el siglo 20     sin firmar corta TaZiff;       // número de día     sin firmar corta WoDag;        // día de la semana     sin firmar corta SJK = 0;      // corrección del año bisiesto     sin firmar corta ZDiff;        // Diferencia horaria UTC CET / CEST     sin firmar corta MoZiff[12] = { 0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5 }; // número de mes     sin firmar corta Días_mes[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,             31 };     sin firmar corta Año, Día, Mes, Hora, Minuto, Segundo;     // RTC_setMonat (3);     Año = rtc_year();     si (Año > 99)         Año = 0;     Mes = rtc_month();     si (Mes > 12)         Mes = 0;     Día = rtc_tag();     si (Día > 31)         Día = 0;     Hora = rtc_hour();     si (Hora > 23)         Hora = 0;     Minuto = rtc_minute();     si (Minuto > 59)         Minuto = 0;     Segundo = rtc_second();     si (Segundo > 59)         Segundo = 0;     Si no = ((Año + Año / 4) % 7);     TaZiff = (Día % 7);     si ((Año % 4) == 0)                          // año bisiesto?     {         Días_mes[1] = 29;                      // entonces febrero tiene 29 días         si (Mes < 3)             SJK = 6;         otra cosa             SJK = 0;     }     WoDag = ((TaZiff + MoZiff[Mes - 1] + Número de siglo + Si no + SJK) % 7);     si (Mes < 3 || Mes > 10)         ZDiff = 1; // no hay horario de verano en enero, febrero, noviembre, diciembre     si (Mes > 3 && Mes < 10)         ZDiff = 2; // Sommerz. en abril, mayo, junio, julio, agosto, septiembre     si (Mes == 3) {         ZDiff = 1;         si (Día > 24)     // Horario de verano del último domingo del mes         {             si (Día == 25) {                 si ((Día + WoDag) < 26)                     ZDiff = 2;             }             si (Día == 26) {                 si ((Día + WoDag) < 28)                     ZDiff = 2;             }             si (Día == 27) {                 si ((Día + WoDag) < 30)                     ZDiff = 2;             }             si (Día == 28) {                 si ((Día + WoDag) < 32)                     ZDiff = 2;             }             si (Día == 29) {                 si ((Día + WoDag) < 34)                     ZDiff = 2;             }             si (Día == 30) {                 si ((Día + WoDag) < 36)                     ZDiff = 2;             }             si (Día == 31) {                 si ((Día + WoDag) < 38)                     ZDiff = 2;             }             si ((ZDiff == 2) && (Hora + 1 < 2) && (WoDag == 0))                 ZDiff = 1; // solo a partir de las 2 a.m.         }     }     si (Mes == 10) {         ZDiff = 2;         si (Día > 24)     // Horario de verano del último domingo del mes         {             si (Día == 25) {                 si ((Día + WoDag) < 26)                     ZDiff = 1;             }             si (Día == 26) {                 si ((Día + WoDag) < 28)                     ZDiff = 1;             }             si (Día == 27) {                 si ((Día + WoDag) < 30)                     ZDiff = 1;             }             si (Día == 28) {                 si ((Día + WoDag) < 32)                     ZDiff = 1;             }             si (Día == 29) {                 si ((Día + WoDag) < 34)                     ZDiff = 1;             }             si (Día == 30) {                 si ((Día + WoDag) < 36)                     ZDiff = 1;             }             si (Día == 31) {                 si ((Día + WoDag) < 38)                     ZDiff = 1;             }             si ((ZDiff == 1) && (Hora == 0) && (WoDag == 0))                 ZDiff = 2; // solo a partir de las 2 a.m.         }     }     Hora = Hora + ZDiff;     si (Hora > 23)       // corrección diaria     {         Hora = Hora - 24; // puede ser 0 o 1         Día = Día + 1;         WoDag = WoDag + 1;         si (Día > Días_mes[Mes - 1]) {             Día = 1;             Mes = Mes + 1;             si (Mes > 12) {                 Mes = 1;                 Año = Año + 1;             }         }     }     CET.WT = WoDag;          // So = 0, Mo = 1, Di = 2 ...     CET.sec1 = Segundo % 10;     CET.sec2 = Segundo / 10;     CET.sec12 = Segundo;     CET.min1 = Minuto % 10;     CET.min2 = Minuto / 10;     CET.min12 = Minuto;     CET.std1 = Hora % 10;     CET.std2 = Hora / 10;     CET.std12 = Hora;     CET.día12 = Día;     CET.dia 1 = Día % 10;     CET.dia 2 = Día / 10;     CET.mon12 = Mes;     CET.lun1 = Mes % 10;     CET.mon2 = Mes / 10;     CET.año12 = Año;     CET.año1 = Año % 10;     CET.año2 = Año / 10;
}

//*************************************************************************************************
const sin firmar corta InitArr[7][2] = { { 0x0C, 0x00 },    // mostrar         { 0x00, 0xFF },    // sin LEDtest         { 0x09, 0x00 },    // BCD desactivado         { 0x0F, 0x00 },    // funcionamiento normal         { 0x0B, 0x07 },    // inicio de visualización         { 0x0A, 0x04 },    // brillo         { 0x0C, 0x01 }     // mostrar en
};
//**************************************************************************************************
nulo max7219_init()  // todos los MAX7219 init
{     sin firmar corta yo, j;     para (yo = 0; yo < 7; yo++) {         digitalWrite(CS, BAJA);         delayMicroseconds(1);         para (j = 0; j < numMAX; j++) {             SPI.escribir(InitArr[yo][0]);  // registrarse             SPI.escribir(InitArr[yo][1]);  // valor         }         digitalWrite(CS, ALTO);     }
}
//**************************************************************************************************
nulo max7219_set_brightness(sin firmar corta br)  // brillo MAX7219
{     sin firmar corta j;     si (br < 16) {         digitalWrite(CS, BAJA);         delayMicroseconds(1);         para (j = 0; j < numMAX; j++) {             SPI.escribir(0x0A);  // registrarse             SPI.escribir(br);    // valor         }         digitalWrite(CS, ALTO);     }
}
//**************************************************************************************************
nulo helpArr_init(nulo)  helperarray init
{     Unsigned Corto , J, K;     J = 0;     K = 0;     Para ( = 0;  < anzMAX * 8; ++) {         helpArrPos[] = (1 << J);   Máscara         helpArrMAX[] = K;         J++;         Si (J > 7) {             J = 0;             K++;         }     }
}
//**************************************************************************************************
Vacío clear_Display()   Borrar todo
{     Unsigned Corto , J;     Para ( = 0;  < 8; ++)     8 filas     {         digitalWrite(Cs, Bajo);         delayMicroseconds(1);         Para (J = anzMAX; J > 0; J--) {             LEDarr[J - 1][] = 0;       LEDarr claro             Spi.Escribir( + 1);           fila actual             Spi.Escribir(LEDarr[J - 1][]);         }         digitalWrite(Cs, Alto);     }
}
//*********************************************************************************************************
Vacío rotate_90() para pantallas genéricas
{     Para (uint8_t K = anzMAX; K > 0; K--) {         uint8_t , J, M, imask, jmask;         uint8_t Tmp[8]={0,0,0,0,0,0,0,0};         Para (   = 0, imask = 0x01;  < 8; ++, imask <<= 1) {           Para (J = 0, jmask = 0x01; J < 8; J++, jmask <<= 1) {             Si (LEDarr[K-1][] & jmask) {               Tmp[J] |= imask;             }           }         }         Para(M=0; M<8; M++){             LEDarr[K-1][M]=Tmp[M];         }     }
}
//**************************************************************************************************
Vacío refresh_display() tomar información en LEDarr
{     Unsigned Corto , J;

#ifdef ROTATE_90     rotate_90();
#endif     Para ( = 0;  < 8; ++)     8 filas     {         digitalWrite(Cs, Bajo);         delayMicroseconds(1);         Para (J = anzMAX; J > 0; J--) {             Spi.Escribir( + 1);  fila actual

#ifdef REVERSE_HORIZONTAL             Spi.setBitOrder(LSBFIRST);      bitorder para columnas inversas
#endif

#ifdef REVERSE_VERTICAL             Spi.Escribir(LEDarr[J - 1][7-]);
#else             Spi.Escribir(LEDarr[J - 1][]);
#endif

#ifdef REVERSE_HORIZONTAL             Spi.setBitOrder(MSBFIRST);      restablecer bitorder
#endif         }         digitalWrite(Cs, Alto);     }
}
//**************************************************************************************************
Vacío char2Arr(Unsigned Corto Ch, Int PosX, Corto Posy) { personajes en el arr     Int , J, K, L, M, o1, o2, o3, o4;  en LEDarr     PosX++;     K = Ch - 32;                        Posición ASCII en la fuente     Si ((K >= 0) && (K < 96))           carácter encontrado en la fuente?     {         o4 = font1[K][0];                 ancho de carácter         o3 = 1 << (o4 - 2);         Para ( = 0;  < o4; ++) {             Si (((PosX -  <= maxPosX) && (PosX -  >= 0))                     && ((Posy > -8) && (Posy < 8))) dentro de la matriz?             {                 o1 = helpArrPos[PosX - ];                 o2 = helpArrMAX[PosX - ];                 Para (J = 0; J < 8; J++) {                     Si (((Posy >= 0) && (Posy <= J)) || ((Posy < 0) && (J < Posy + 8))) desplazamiento vertical                     {                         L = font1[K][J + 1];                         M = (L & (o3 >> ));  p. ej., o4-7 0zzzzz0, o4-4 0zz0                         Si (M > 0)                             LEDarr[o2][J - Posy] = LEDarr[o2][J - Posy] | (o1);  punto de consigna                         Más                             LEDarr[o2][J - Posy] = LEDarr[o2][J - Posy] & (~o1); punto claro                     }                 }             }         }     }
}

//**************************************************************************************************
Vacío timer50ms() {     Estática Unsigned Int cnt50ms = 0;     Estática Unsigned Int cnt1s = 0;     Estática Unsigned Int cnt1h = 0;     f_tckr50ms = Verdad;     cnt50ms++;     Si (cnt50ms == 20) {         f_tckr1s = Verdad; 1 seg         cnt1s++;         cnt50ms = 0;     }     Si (cnt1s == 3600) { 1h         cnt1h++;         cnt1s = 0;     }     Si (cnt1h == 24) { 1d         f_tckr24h = Verdad;         cnt1h = 0;     }
}
//**************************************************************************************************
//
La función de configuración se llama una vez al inicio del boceto
Vacío Configuración() {     Agregue su código de inicialización aquí        pinMode(Cs, Salida);     digitalWrite(Cs, Alto);     Serial.Comenzar(115200);     rtc.init(SDA, SCL);     Spi.Comenzar();     helpArr_init();     max7219_init();     rtc_init(Sda, Scl);     clear_Display();     tckr.adjuntar(0.05, timer50ms);    cada 50 ms     Tm* Tt;     Si (Tt != Null)         rtc_set(Tt);     Más         Serial.println("no se ha recibido ningún paquete de tiempo");
}
//**************************************************************************************************
La función de bucle se llama en un bucle sin fin
Vacío Bucle() {     Agregue su código repetido aquí     Unsigned Int sek1 = 0, sek2 = 0, min1 = 0, min2 = 0, std1 = 0, std2 = 0;     Unsigned Int sek11 = 0, sek12 = 0, sek21 = 0, sek22 = 0;     Unsigned Int min11 = 0, min12 = 0, min21 = 0, min22 = 0;     Unsigned Int std11 = 0, std12 = 0, std21 = 0, std22 = 0;     Firmado Int X = 0; x1,x2;     Firmado Int y y = 0, y1 = 0, y2 = 0;     Bool Updown = Falso;     Unsigned Int sc1 = 0, sc2 = 0, sc3 = 0, sc4 = 0, sc5 = 0, sc6 = 0;     Bool f_scrollend_y = Falso;     Unsigned Int f_scroll_x = Falso;     z_PosX = maxPosX;     d_PosX = -8;     x-0; x1-0; x2-0;     refresh_display();     Updown = Verdad;     Si (Updown == Falso) {         y2 = -9;         y1 = 8;     }     Si (Updown == Verdad) { desplazarse hacia abajo         y2 = 8;         y1 = -8;     }     Mientras (Verdad) {         Rendimiento();         Si (f_tckr24h == Verdad) { syncroniize RTC todos los días             f_tckr24h = Falso;             Tm* Tt;             Si (Tt != Null)                 rtc_set(Tt);             Más                 Serial.println("no se ha recibido ningún paquete de tiempo");         }         Si (f_tckr1s == Verdad)        bandera 1sek         {             rtc2mez();             sek1 = Mez.sek1;             sek2 = Mez.sek2;             min1 = Mez.min1;             min2 = Mez.min2;             std1 = Mez.std1;             std2 = Mez.std2;             y y = y2;                 desplazarse hacia arriba             sc1 = 1;             sek1++;             Si (sek1 == 10) {                 sc2 = 1;                 sek2++;                 sek1 = 0;             }             Si (sek2 == 6) {                 min1++;                 sek2 = 0;                 sc3 = 1;             }             Si (min1 == 10) {                 min2++;                 min1 = 0;                 sc4 = 1;             }             Si (min2 == 6) {                 std1++;                 min2 = 0;                 sc5 = 1;             }             Si (std1 == 10) {                 std2++;                 std1 = 0;                 sc6 = 1;             }             Si ((std2 == 2) && (std1 == 4)) {                 std1 = 0;                 std2 = 0;                 sc6 = 1;             }             sek11 = sek12;             sek12 = sek1;             sek21 = sek22;             sek22 = sek2;             min11 = min12;             min12 = min1;             min21 = min22;             min22 = min2;             std11 = std12;             std12 = std1;             std21 = std22;             std22 = std2;             f_tckr1s = Falso;             Si (Mez.sek12 == 45)                 f_scroll_x = Verdad;         } final 1s         Si (f_tckr50ms == Verdad) {             f_tckr50ms = Falso;             Si (f_scroll_x == Verdad) {                 z_PosX++;                 d_PosX++;                 Si (d_PosX == 101)                     z_PosX = 0;                 Si (z_PosX == maxPosX) {                     f_scroll_x = Falso;                     d_PosX = -8;                 }             }             Si (sc1 == 1) {                 Si (Updown == 1)                     y y--;                 Más                     y y++;                 char2Arr(48 + sek12, z_PosX - 42, y y);                 char2Arr(48 + sek11, z_PosX - 42, y y + y1);                 Si (y y == 0) {                     sc1 = 0;                     f_scrollend_y = Verdad;                 }             }             Más                 char2Arr(48 + sek1, z_PosX - 42, 0);             Si (sc2 == 1) {                 char2Arr(48 + sek22, z_PosX - 36, y y);                 char2Arr(48 + sek21, z_PosX - 36, y y + y1);                 Si (y y == 0)                     sc2 = 0;             }             Más                 char2Arr(48 + sek2, z_PosX - 36, 0);             char2Arr(':', z_PosX - 32, 0);             Si (sc3 == 1) {                 char2Arr(48 + min12, z_PosX - 25, y y);                 char2Arr(48 + min11, z_PosX - 25, y y + y1);                 Si (y y == 0)                     sc3 = 0;             }             Más                 char2Arr(48 + min1, z_PosX - 25, 0);             Si (sc4 == 1) {                 char2Arr(48 + min22, z_PosX - 19, y y);                 char2Arr(48 + min21, z_PosX - 19, y y + y1);                 Si (y y == 0)                     sc4 = 0;             }             Más                 char2Arr(48 + min2, z_PosX - 19, 0);             char2Arr(':', z_PosX - 15 + X, 0);             Si (sc5 == 1) {                 char2Arr(48 + std12, z_PosX - 8, y y);                 char2Arr(48 + std11, z_PosX - 8, y y + y1);                 Si (y y == 0)                     sc5 = 0;             }             Más                 char2Arr(48 + std1, z_PosX - 8, 0);             Si (sc6 == 1) {                 char2Arr(48 + std22, z_PosX - 2, y y);                 char2Arr(48 + std21, z_PosX - 2, y y + y1);                 Si (y y == 0)                     sc6 = 0;             }             Más                 char2Arr(48 + std2, z_PosX - 2, 0);             char2Arr(WT_arr[Mez.Wt][0], d_PosX - 5, 0);        día de la semana             char2Arr(WT_arr[Mez.Wt][1], d_PosX - 11, 0);             char2Arr(WT_arr[Mez.Wt][2], d_PosX - 17, 0);             char2Arr(WT_arr[Mez.Wt][3], d_PosX - 23, 0);             char2Arr(48 + Mez.tag2, d_PosX - 27, 0);           Día             char2Arr(48 + Mez.tag1, d_PosX - 33, 0);             char2Arr(M_arr[Mez.mon12 - 1][0], d_PosX - 39, 0); Mes             char2Arr(M_arr[Mez.mon12 - 1][1], d_PosX - 43, 0);             char2Arr(M_arr[Mez.mon12 - 1][2], d_PosX - 49, 0);             char2Arr(M_arr[Mez.mon12 - 1][3], d_PosX - 55, 0);             char2Arr(M_arr[Mez.mon12 - 1][4], d_PosX - 61, 0);             char2Arr('2', d_PosX - 68, 0);                     año             char2Arr('0', d_PosX - 74, 0);             char2Arr(48 + Mez.jahr2, d_PosX - 80, 0);             char2Arr(48 + Mez.jahr1, d_PosX - 86, 0);             refresh_display(); alle 50ms             Si (f_scrollend_y == Verdad) {                 f_scrollend_y = Falso;             }         } fin de 50ms         Si (y y == 0) {             hacer otra cosa         }     }

}

 

Viel Spass beim nachbauen und bis zum n'chsten Beitrag :)

Precipitador electrostático - 8266Projekte für anfänger

6 comentarios

Peter Teubner

Peter Teubner

Nachfrage,
leider bin ich mit der Fehlersuche noch nicht am Ziel.
Die Uhr geht eine Stunde vor.
Hat vielleicht jemand eine Lösung?
mfG
Peter

Peter Teubner

Peter Teubner

Hallo,
habe ein Problem das ich leider noch nicht lösen konnte.
Bis auf die Uhrzeit ist alles korrekt.
Ich habe das Uhrzeitmodul über meinen Arduino( RTC.lib) voreingestellt.
Die Uhr geht eine Stunde vor.
Es wäre schön wenn Sie mir helfen können!!!
mfG

Peter Teubner

udo godeck

udo godeck

mehr als 0:01:0 zeigt diese uhr nichts an

Carsten

Carsten

Servus, ich hab leider ohne Erfolg versucht den Code füt ein D1 mini umzuschreiben.
Worauf muss ich achten oder habt ihr vielleicht einen Code für den D1?
Gruß Carsten

Sven

Sven

Ich habe ebenfalls das Problem mit der Uhr. Sie geht 2 Stunden vor.

Uwe Hendel

Uwe Hendel

Ein sehr nettes kleines Projekt, die Umsetzung hat praktisch sofort geklappt. Einziges Problem, meine Uhr geht 2 Stunden vor, sicher ein Zeitzonen Problem. Nun bin ich mir nicht sicher ob ich schon beim stellen der Uhr mit dem Arduino einen Fehler gemacht habe, oder wo man das in dem Code hier ändern muss. Vielleicht kann mir einer der Profis hier einen Tipp geben.

Deja un comentario

Todos los comentarios son moderados antes de ser publicados