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:

• ESP8266 módulo Amica
• RTC3231
• Matriz de LED

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:

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 :)