Retro Uhr mit ESP, RTC und LED-Matrix

Ciao a tutti

Abbiamo già avuto qualche orologio sul nostro blog, sia Orologio radio o al riguardo Protocollo NTP, con display  o il nostro Pannello U64, Oggi vorrei presentarvi una variante con matrice ESP, RTC e LED. Un collega più giovane mi ha gentilmente sottolineato che questi tipi di orologi sono obsoleti da tempo e mi ha fatto sapere che nel frattempo ... beh, non diciamo che sono uno degli hobbisti più giovani e mi ha chiesto "retrò" nel Per mettere titoli.

Per il nostro progetto abbiamo bisogno di:

Abbiamo trovato questo progetto su GitHub  e adattato qui per i nostri scopi.

Prima di iniziare, consiglio di impostare l'ora RTC con un Arduino, poiché ciò può talvolta causare problemi con gli ESP. Lo abbiamo nel nostro libero E-Book  spiegato in dettaglio sull'RTC.

Questo progetto ci piace moltissimo, perché anche la data è stata inserita e l'effetto del tempo che cambia è stato implementato bene.

Il cablaggio:

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

 

Ecco il codice:

 

//*********************************************************************************************************
// * ESP8266 MatrixClock *
//*********************************************************************************************************
//
// prima versione il 26/02/2017
// aggiornato il 26/03/2019
// Versione 1.2.1
//
//
// IL SOFTWARE È FORNITO "COSÌ COM'È" SOLO PER USO PRIVATO, NON È PER USO COMMERCIALE IN TUTTO O PARTE O CONCETTO.
// PER USO PERSONALE È FORNITO SENZA ALCUN TIPO DI GARANZIA, ESPRESSA O IMPLICITA, COMPRESE MA NON LIMITATE AL
// GARANZIE DI COMMERCIABILITÀ, IDONEITÀ A UNO SCOPO PARTICOLARE E NON VIOLAZIONE. IN NESSUN CASO L'AUTORE
// O IL TITOLARE DEL COPYRIGHT È RESPONSABILE DI QUALSIASI RECLAMO, DANNI O ALTRE RESPONSABILITÀ, SE IN AZIONE DI CONTRATTO, TORT O
// ALTRIMENTI, PROVENIENTI DA, FUORI O IN CONNESSIONE CON IL SOFTWARE O L'UTILIZZO O ALTRE OFFERTE NEL SOFTWARE
// Fatto da https://github.com/schreibfaul1/ESP8266-LED-Matrix-Clock
// A cura di AZ-Delivery

#include <SPI.B>
#include <telescrivente.B>
#include <ESP8266WiFi.B>
#include <filo.B>
#include <tempo.B>

#define SDA        5      // pin sda (I2C)
#define SCL        4      // pin scl (I2C)
#define CS         15     // pin cs (SPI)
#define anzMAX     4      // Numero di moduli in cascata


unsigned breve maxPosX = anzMAX * 8 - 1;            // posizione massima calcolata
unsigned breve LEDarr[anzMAX][8];                   // matrice di caratteri da visualizzare (40 * 8)
unsigned breve helpArrMAX[anzMAX * 8];              // helperarray per chardecoding
unsigned breve helpArrPos[anzMAX * 8];              // helperarray pos of chardecoding
unsigned int z_PosX = 0;                            // xPosizione nel display per la visualizzazione dell'ora
unsigned int d_PosX = 0;                            // xPosizione nella visualizzazione per la data
bool f_tckr1s = falso;
bool f_tckr50ms = falso;
bool f_tckr24h = falso;
unsigned lungo epoca = 0;


// Variabili per RTC DS3231
const unsigned carbonizzare DS3231_ADDRESS = 0x68;
const unsigned carbonizzare secondREG = 0x00;
const unsigned carbonizzare minuteREG = 0x01;
const unsigned carbonizzare hourREG = 0x02;
const unsigned carbonizzare WTREG = 0x03;                   // giorno della settimana
const unsigned carbonizzare dateREG = 0x04;
const unsigned carbonizzare monthREG = 0x05;
const unsigned carbonizzare yearREG = 0x06;
const unsigned carbonizzare alarm_min1secREG = 0x07;
const unsigned carbonizzare alarm_min1minREG = 0x08;
const unsigned carbonizzare alarm_min1hrREG = 0x09;
const unsigned carbonizzare alarm_min1dateREG = 0x0A;
const unsigned carbonizzare alarm_min2minREG = 0x0B;
const unsigned carbonizzare alarm_min2hrREG = 0x0C;
const unsigned carbonizzare alarm_min2dateREG = 0x0D;
const unsigned carbonizzare controlREG = 0x0E;
const unsigned carbonizzare statusREG = 0x0F;
const unsigned carbonizzare ageoffsetREG = 0x10;
Const Unsigned Char tempMSBREG = 0x11 (in questo formato 0x11);
Const Unsigned Char TempLSBREG = 0x12 (in questo 0x12);
Const Unsigned Char _24_hour_format = 0;
Const Unsigned Char _12_hour_format = 1;
Const Unsigned Char AM = 0;
Const Unsigned Char Funzione PM = 1;

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


L'oggetto per il Ticker
Telescrivente tckr;



Mesi
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', '.' } };
Giorni
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', ',' } };

Eichensatz 5x8 in einer 8x8 Matrix, 0,0 ist rechts oben
Unsigned Breve Const tipo di carattere1[96][9] = { { 0x07 (in tissuta in stato di, 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00),         0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00) },   0x20, Spazio         { 0x07 (in tissuta in stato di, 0x04 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x00 (in questo 0x00), 0x04 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x21, !         { 0x07 (in tissuta in stato di, 0x09 (in tissuta 0x0, 0x09 (in tissuta 0x0, 0x12 (in questo 0x12), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00) },   0x22, "         { 0x07 (in tissuta in stato di, 0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a, 0x00 (in questo 0x00) },   0x23, s.c.         { 0x07 (in tissuta in stato di, 0x04 (in tissuta 0x0, 0x0f (in formato 0x0f), 0x14 (in questo 0x14), 0x0e, 0x05 (in tissuta 0x0, 0x1e, 0x04 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x24, .         { 0x07 (in tissuta in stato di, 0x19 (in tissuta 0x1, 0x19 (in tissuta 0x1, 0x02 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x13 (in questo formato 0x13), 0x13 (in questo formato 0x13), 0x00 (in questo 0x00) },   0x25, %         { 0x07 (in tissuta in stato di, 0x04 (in tissuta 0x0, 0x0a, 0x0a, 0x0a, 0x15 (in questo formato 0x15), 0x12 (in questo 0x12), 0x0d, 0x00 (in questo 0x00) },   0x26, &         { 0x07 (in tissuta in stato di, 0x04 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00) },   0x27, '         { 0x07 (in tissuta in stato di, 0x02 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x02 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x28, (         { 0x07 (in tissuta in stato di, 0x08 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x02 (in tissuta 0x0, 0x02 (in tissuta 0x0, 0x02 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x29, )         { 0x07 (in tissuta in stato di, 0x04 (in tissuta 0x0, 0x15 (in questo formato 0x15), 0x0e, 0x1f, 0x0e, 0x15 (in questo formato 0x15), 0x04 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x2a,         { 0x07 (in tissuta in stato di, 0x00 (in questo 0x00), 0x04 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x1f, 0x04 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x00 (in questo 0x00), 0x00 (in questo 0x00) },   0x2b,         { 0x04 (in tissuta 0x0, 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x01 (in tissuta (in ti, 0x01 (in tissuta (in ti, 0x02 (in tissuta 0x0 },   0x2c, ,         { 0x07 (in tissuta in stato di, 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x1f, 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00) },   0x2d, -         { 0x04 (in tissuta 0x0, 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x03 (in tissuta (in ti, 0x03 (in tissuta (in ti, 0x00 (in questo 0x00) },   0x2e, .         { 0x07 (in tissuta in stato di, 0x01 (in tissuta (in ti, 0x01 (in tissuta (in ti, 0x02 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x10 (in modo 0x10), 0x10 (in modo 0x10), 0x00 (in questo 0x00) },   0x2f, /         { 0x07 (in tissuta in stato di, 0x0e, 0x11 (in questo formato 0x11), 0x13 (in questo formato 0x13), 0x15 (in questo formato 0x15), 0x19 (in tissuta 0x1, 0x11 (in questo formato 0x11), 0x0e, 0x00 (in questo 0x00) },   0x30, 0         { 0x07 (in tissuta in stato di, 0x04 (in tissuta 0x0, 0x0c (in formato 0x0c), 0x04 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x0e, 0x00 (in questo 0x00) },   0x31, 1         { 0x07 (in tissuta in stato di, 0x0e, 0x11 (in questo formato 0x11), 0x01 (in tissuta (in ti, 0x02 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x1f, 0x00 (in questo 0x00) },   0x32, 2         { 0x07 (in tissuta in stato di, 0x0e, 0x11 (in questo formato 0x11), 0x01 (in tissuta (in ti, 0x06 (in inglese), 0x01 (in tissuta (in ti, 0x11 (in questo formato 0x11), 0x0e, 0x00 (in questo 0x00) },   0x33, 3         { 0x07 (in tissuta in stato di, 0x02 (in tissuta 0x0, 0x06 (in inglese), 0x0a, 0x12 (in questo 0x12), 0x1f, 0x02 (in tissuta 0x0, 0x02 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x34, 4         { 0x07 (in tissuta in stato di, 0x1f, 0x10 (in modo 0x10), 0x1e, 0x01 (in tissuta (in ti, 0x01 (in tissuta (in ti, 0x11 (in questo formato 0x11), 0x0e, 0x00 (in questo 0x00) },   0x35, 5         { 0x07 (in tissuta in stato di, 0x06 (in inglese), 0x08 (in tissuta 0x0, 0x10 (in modo 0x10), 0x1e, 0x11 (in questo formato 0x11), 0x11 (in questo formato 0x11), 0x0e, 0x00 (in questo 0x00) },   0x36, 6         { 0x07 (in tissuta in stato di, 0x1f, 0x01 (in tissuta (in ti, 0x02 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x37, 7         { 0x07 (in tissuta in stato di, 0x0e, 0x11 (in questo formato 0x11), 0x11 (in questo formato 0x11), 0x0e, 0x11 (in questo formato 0x11), 0x11 (in questo formato 0x11), 0x0e, 0x00 (in questo 0x00) },   0x38, 8         { 0x07 (in tissuta in stato di, 0x0e, 0x11 (in questo formato 0x11), 0x11 (in questo formato 0x11), 0x0f (in formato 0x0f), 0x01 (in tissuta (in ti, 0x02 (in tissuta 0x0, 0x0c (in formato 0x0c), 0x00 (in questo 0x00) },   0x39, 9         { 0x04 (in tissuta 0x0, 0x00 (in questo 0x00), 0x03 (in tissuta (in ti, 0x03 (in tissuta (in ti, 0x00 (in questo 0x00), 0x03 (in tissuta (in ti, 0x03 (in tissuta (in ti, 0x00 (in questo 0x00), 0x00 (in questo 0x00) },   0x3a, :         { 0x07 (in tissuta in stato di, 0x00 (in questo 0x00), 0x0c (in formato 0x0c), 0x0c (in formato 0x0c), 0x00 (in questo 0x00), 0x0c (in formato 0x0c), 0x04 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x3b, ;         { 0x07 (in tissuta in stato di, 0x02 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x10 (in modo 0x10), 0x08 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x02 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x3c, <         { 0x07 (in tissuta in stato di, 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x1f, 0x00 (in questo 0x00), 0x1f, 0x00 (in questo 0x00), 0x00 (in questo 0x00), 0x00 (in questo 0x00) },   0x3d ,         { 0x07 (in tissuta in stato di, 0x08 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x02 (in tissuta 0x0, 0x01 (in tissuta (in ti, 0x02 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x08 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x3e, >         { 0x07 (in tissuta in stato di, 0x0e, 0x11 (in questo formato 0x11), 0x01 (in tissuta (in ti, 0x02 (in tissuta 0x0, 0x04 (in tissuta 0x0, 0x00 (in questo 0x00), 0x04 (in tissuta 0x0, 0x00 (in questo 0x00) },   0x3f, ?         { 0x07 (in tissuta in stato di, 0x0e, 0x11 (in questo formato 0x11), 0x17 (in questo 0x17), 0x15 (in questo formato 0x15), 0x17 (in questo 0x17), 0x10 (in modo 0x10), 0x0f (in formato 0x0f), 0x00 (in questo 0x00) },   0x40, n.         { 0x07 (in tissuta in stato di, 0x04 (in tissuta 0x0, 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, I         { 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, pag         { 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, sett         { 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
};
//**************************************************************************************************

//**************************************************************************************************
vuoto rtc_init(unsigned carbonizzare sda, unsigned carbonizzare SCL) {     Filo.inizio(sda, SCL);     rtc_Write(controlREG, 0x00);
}
//**************************************************************************************************
// Codice BCD
//**************************************************************************************************
unsigned carbonizzare dec2bcd(unsigned carbonizzare X) { // valore 0 ... 99     unsigned carbonizzare z, e, r;     e = X % 10;     z = X / 10;     z = z << 4;     r = e | z;     ritorno (r);
}
unsigned carbonizzare bcd2dec(unsigned carbonizzare X) { // valore 0 ... 99     int z, e;     e = X & 0x0F;     z = X & 0xF0;     z = z >> 4;     z = z * 10;     ritorno (z + e);
}
//**************************************************************************************************
// RTC I2C Code
//**************************************************************************************************
unsigned carbonizzare rtc_Read(unsigned carbonizzare regaddress) {     Filo.beginTransmission(DS3231_ADDRESS);     Filo.Scrivi(regaddress);     Filo.endTransmission();     Filo.richiesta da((unsigned carbonizzare) DS3231_ADDRESS, (unsigned carbonizzare) 1);     ritorno (Filo.leggere());
}
vuoto rtc_Write(unsigned carbonizzare regaddress, unsigned carbonizzare valore) {     Filo.beginTransmission(DS3231_ADDRESS);     Filo.Scrivi(regaddress);     Filo.Scrivi(valore);     Filo.endTransmission();
}
//**************************************************************************************************
unsigned carbonizzare rtc_sekunde() {     ritorno (bcd2dec(rtc_Read(secondREG)));
}
unsigned carbonizzare rtc_minute() {     ritorno (bcd2dec(rtc_Read(minuteREG)));
}
unsigned carbonizzare rtc_stunde() {     ritorno (bcd2dec(rtc_Read(hourREG)));
}
unsigned carbonizzare rtc_wochentag() {     ritorno (bcd2dec(rtc_Read(WTREG)));
}
unsigned carbonizzare rtc_tag() {     ritorno (bcd2dec(rtc_Read(dateREG)));
}
unsigned carbonizzare rtc_monat() {     ritorno (bcd2dec(rtc_Read(monthREG)));
}
unsigned carbonizzare rtc_jahr() {     ritorno (bcd2dec(rtc_Read(yearREG)));
}
vuoto rtc_sekunde(unsigned carbonizzare sek) {     rtc_Write(secondREG, (dec2bcd(sek)));
}
vuoto rtc_minute(unsigned carbonizzare min) {     rtc_Write(minuteREG, (dec2bcd(min)));
}
vuoto rtc_stunde(unsigned carbonizzare std) {     rtc_Write(hourREG, (dec2bcd(std)));
}
vuoto rtc_wochentag(unsigned carbonizzare in peso) {     rtc_Write(WTREG, (dec2bcd(in peso)));
}
vuoto rtc_tag(unsigned carbonizzare etichetta) {     rtc_Write(dateREG, (dec2bcd(etichetta)));
}
vuoto rtc_monat(unsigned carbonizzare mon) {     rtc_Write(monthREG, (dec2bcd(mon)));
}
vuoto rtc_jahr(unsigned carbonizzare Jahr) {     rtc_Write(yearREG, (dec2bcd(Jahr)));
}
//**************************************************************************************************
vuoto rtc_set(tm* TT) {     rtc_sekunde((unsigned carbonizzare) TT->tm_sec);     rtc_minute((unsigned carbonizzare) TT->tm_min);     rtc_stunde((unsigned carbonizzare) TT->tm_hour);     rtc_tag((unsigned carbonizzare) TT->tm_mday);     rtc_monat((unsigned carbonizzare) TT->tm_mon + 1);     rtc_jahr((unsigned carbonizzare) TT->tm_year - 100);     rtc_wochentag((unsigned carbonizzare) TT->tm_wday);
}
//**************************************************************************************************
galleggiante rtc_temp() {     galleggiante t = 0.0;     unsigned carbonizzare byte basso = 0;     firmato carbonizzare byte alto = 0;     byte basso = rtc_Read(tempLSBREG);     byte alto = rtc_Read(tempMSBREG);     byte basso >>= 6;     byte basso &= 0x03;     t = ((galleggiante) byte basso);     t *= 0.25;     t += byte alto;     ritorno (t); // restituisce valore temporaneo
}
//**************************************************************************************************
vuoto rtc2mez() {     unsigned breve Si no;       // numero dell'anno     unsigned breve Numero del secolo = 6;   // Numero del secolo per il 20 ° secolo     unsigned breve TaZiff;       // numero del giorno     unsigned breve WoTag;        // giorno della settimana     unsigned breve SJK = 0;      // Correzione dell'anno bisestile     unsigned breve zdiff;        // Differenza di tempo UTC CET / CEST     unsigned breve MoZiff[12] = { 0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5 }; // numero del mese     unsigned breve Tage_Monat[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,             31 };     unsigned breve anno, giorno, mese, ora, minuto, secondo;     // RTC_setMonat (3);     anno = rtc_jahr();     se (anno > 99)         anno = 0;     mese = rtc_monat();     se (mese > 12)         mese = 0;     giorno = rtc_tag();     se (giorno > 31)         giorno = 0;     ora = rtc_stunde();     se (ora > 23)         ora = 0;     minuto = rtc_minute();     se (minuto > 59)         minuto = 0;     secondo = rtc_sekunde();     se (secondo > 59)         secondo = 0;     Si no = ((anno + anno / 4) % 7);     TaZiff = (giorno % 7);     se ((anno % 4) == 0)                          // anno bisestile?     {         Tage_Monat[1] = 29;                      // allora febbraio ha 29 giorni         se (mese < 3)             SJK = 6;         altro             SJK = 0;     }     WoTag = ((TaZiff + MoZiff[mese - 1] + Numero del secolo + Si no + SJK) % 7);     se (mese < 3 || mese > 10)         zdiff = 1; // nessuna ora legale in gennaio, febbraio, novembre, dicembre     se (mese > 3 && mese < 10)         zdiff = 2; // Sommerz. in aprile, maggio, giugno, luglio, agosto, settembre     se (mese == 3) {         zdiff = 1;         se (giorno > 24)     // Ora legale dall'ultima domenica del mese         {             se (giorno == 25) {                 se ((giorno + WoTag) < 26)                     zdiff = 2;             }             se (giorno == 26) {                 se ((giorno + WoTag) < 28)                     zdiff = 2;             }             se (giorno == 27) {                 se ((giorno + WoTag) < 30)                     zdiff = 2;             }             se (giorno == 28) {                 se ((giorno + WoTag) < 32)                     zdiff = 2;             }             se (giorno == 29) {                 se ((giorno + WoTag) < 34)                     zdiff = 2;             }             se (giorno == 30) {                 se ((giorno + WoTag) < 36)                     zdiff = 2;             }             se (giorno == 31) {                 se ((giorno + WoTag) < 38)                     zdiff = 2;             }             se ((zdiff == 2) && (ora + 1 < 2) && (WoTag == 0))                 zdiff = 1; // solo dalle 2 del mattino         }     }     se (mese == 10) {         zdiff = 2;         se (giorno > 24)     // Ora legale dall'ultima domenica del mese         {             se (giorno == 25) {                 se ((giorno + WoTag) < 26)                     zdiff = 1;             }             se (giorno == 26) {                 se ((giorno + WoTag) < 28)                     zdiff = 1;             }             se (giorno == 27) {                 se ((giorno + WoTag) < 30)                     zdiff = 1;             }             se (giorno == 28) {                 se ((giorno + WoTag) < 32)                     zdiff = 1;             }             se (giorno == 29) {                 se ((giorno + WoTag) < 34)                     zdiff = 1;             }             se (giorno == 30) {                 se ((giorno + WoTag) < 36)                     zdiff = 1;             }             se (giorno == 31) {                 se ((giorno + WoTag) < 38)                     zdiff = 1;             }             se ((zdiff == 1) && (ora == 0) && (WoTag == 0))                 zdiff = 2; // solo dalle 2 del mattino         }     }     ora = ora + zdiff;     se (ora > 23)       // Correzione giornaliera     {         ora = ora - 24; // può essere 0 o 1         giorno = giorno + 1;         WoTag = WoTag + 1;         se (giorno > Tage_Monat[mese - 1]) {             giorno = 1;             mese = mese + 1;             se (mese > 12) {                 mese = 1;                 anno = anno + 1;             }         }     }     CET.WT = WoTag;          // Quindi = 0, Mo = 1, Di = 2 ...     CET.sek1 = secondo % 10;     CET.sec2 = secondo / 10;     CET.sek12 = secondo;     CET.min1 = minuto % 10;     CET.min2 = minuto / 10;     CET.min12 = minuto;     CET.STD1 = ora % 10;     CET.STD2 = ora / 10;     CET.std12 = ora;     CET.Tag12 = giorno;     CET.giorno 1 = giorno % 10;     CET.giorno 2 = giorno / 10;     CET.mon12 = mese;     CET.MON1 = mese % 10;     CET.MON2 = mese / 10;     CET.jahr12 = anno;     CET.year1 = anno % 10;     CET.anno2 = anno / 10;
}

//*************************************************************************************************
const unsigned breve InitArr[7][2] = { { 0x0C, 0x00 },    // display off         { 0x00, 0xFF },    // nessun LEDtest         { 0x09, 0x00 },    // BCD disattivato         { 0x0F, 0x00 },    // funzionamento normale         { 0x0B, 0x07 },    // avvia la visualizzazione         { 0x0A, 0x04 },    // luminosità         { 0x0C, 0x01 }     // display on
};
//**************************************************************************************************
vuoto max7219_init()  // tutti MAX7219 init
{     unsigned breve io, j;     per (io = 0; io < 7; io++) {         digitalWrite(CS, LOW);         microsecondi di ritardo(1);         per (j = 0; j < anzMAX; j++) {             SPI.write(InitArr[io][0]);  // registrati             SPI.write(InitArr[io][1]);  // valore         }         digitalWrite(CS, ALTA);     }
}
//**************************************************************************************************
vuoto max7219_set_brightness(unsigned breve br)  // luminosità MAX7219
{     unsigned breve j;     se (br < 16) {         digitalWrite(CS, LOW);         microsecondi di ritardo(1);         per (j = 0; j < anzMAX; j++) {             SPI.write(0x0A);  // registrati             SPI.write(br);    // valore         }         digitalWrite(CS, ALTA);     }
}
//**************************************************************************************************
vuoto helpArr_init(vuoto)  helperarray init
{     Unsigned Breve Ho, J, K;     J = 0;     K = 0;     Per (Ho = 0; Ho < anzMAX * 8; Ho++) {         helpArrPos[Ho] = (1 << J);   Maschera         helpArrMAX[Ho] = K;         J++;         Se (J > 7) {             J = 0;             K++;         }     }
}
//**************************************************************************************************
Vuoto clear_Display()   Cancella tutto
{     Unsigned Breve Ho, J;     Per (Ho = 0; Ho < 8; Ho++)     8 righe     {         digitalWrite (Scrittura digitale)(Cs, Basso);         delayMicrosecondi(1);         Per (J = anzMAX; J > 0; J--) {             LEDarr[J - 1][Ho] = 0;       LEDarr chiaro             Spi.Scrivere(Ho + 1);           riga corrente             Spi.Scrivere(LEDarr[J - 1][Ho]);         }         digitalWrite (Scrittura digitale)(Cs, alto);     }
}
//*********************************************************************************************************
Vuoto rotate_90() per display generici
{     Per (uint8_t K = anzMAX; K > 0; K--) {         uint8_t Ho, J, M, imask, jmask;         uint8_t Tmp[8]={0,0,0,0,0,0,0,0};         Per (  Ho = 0, imask = 0x01 (in tissuta (in ti; Ho < 8; Ho++, imask <<= 1) {           Per (J = 0, jmask = 0x01 (in tissuta (in ti; J < 8; J++, jmask <<= 1) {             Se (LEDarr[K-1][Ho] & jmask) {               Tmp[J] |= imask;             }           }         }         Per(M=0; M<8; M++){             LEDarr[K-1][M]=Tmp[M];         }     }
}
//**************************************************************************************************
Vuoto refresh_display() prendere informazioni in LEDarr
{     Unsigned Breve Ho, J;

#ifdef ROTATE_90     rotate_90();
#endif     Per (Ho = 0; Ho < 8; Ho++)     8 righe     {         digitalWrite (Scrittura digitale)(Cs, Basso);         delayMicrosecondi(1);         Per (J = anzMAX; J > 0; J--) {             Spi.Scrivere(Ho + 1);  riga corrente

#ifdef REVERSE_HORIZONTAL             Spi.setBitOrder (ordine di informazioni su setBitOrder(LSBPRIMO);      bitorder per le colonne inverse
#endif

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

#ifdef REVERSE_HORIZONTAL             Spi.setBitOrder (ordine di informazioni su setBitOrder(NUMERO DI MSBFIRST);      reset bitorder
#endif         }         digitalWrite (Scrittura digitale)(Cs, alto);     }
}
//**************************************************************************************************
Vuoto char2Arr(Unsigned Breve Ch, Int Posx, Breve Posy) { caratteri in arr     Int Ho, J, K, L, M, o1 olora, o2, o3, o4;  in LEDarr     Posx++;     K = Ch - 32;                        Posizione ASCII nel carattere     Se ((K >= 0) && (K < 96))           carattere trovato nel carattere?     {         o4 = tipo di carattere1[K][0];                 larghezza carattere         o3 = 1 << (o4 - 2);         Per (Ho = 0; Ho < o4; Ho++) {             Se (((Posx - Ho <= MaxPosX (informazioni in base al valore maxPos) && (Posx - Ho >= 0))                     && ((Posy > -8) && (Posy < 8))) all'interno della matrice?             {                 o1 olora = helpArrPos[Posx - Ho];                 o2 = helpArrMAX[Posx - Ho];                 Per (J = 0; J < 8; J++) {                     Se (((Posy >= 0) && (Posy <= J)) || ((Posy < 0) && (J < Posy + 8))) scorrere verticalmente                     {                         L = tipo di carattere1[K][J + 1];                         M = (L & (o3 >> Ho));  ad es. o4-7 0zzzzz0, o4-4 0zz0                         Se (M > 0)                             LEDarr[o2][J - Posy] = LEDarr[o2][J - Posy] | (o1 olora);  set point                         Altro                             LEDarr[o2][J - Posy] = LEDarr[o2][J - Posy] & (~o1 olora); punto chiaro                     }                 }             }         }     }
}

//**************************************************************************************************
Vuoto timer50ms() {     Statico Unsigned Int cnt50ms = 0;     Statico Unsigned Int cnt1s = 0;     Statico Unsigned Int cnt1h = 0;     f_tckr50ms = Vero;     cnt50ms++;     Se (cnt50ms == 20) {         f_tckr1s = Vero; 1 sec         cnt1s++;         cnt50ms = 0;     }     Se (cnt1s == 3600) { 1ora         cnt1h++;         cnt1s = 0;     }     Se (cnt1h == 24) { 1d         f_tckr24h = Vero;         cnt1h = 0;     }
}
//**************************************************************************************************
//
La funzione di impostazione viene chiamata una volta all'avvio dello schizzo
Vuoto Installazione() {     Aggiungere qui il codice di inizializzazioneAdd your initialization code here        PinMode (Modalità pin)(Cs, Output);     digitalWrite (Scrittura digitale)(Cs, alto);     Seriale.Iniziare(115200);     rtc.init(SDA, SCL);     Spi.Iniziare();     helpArr_init();     max7219_init();     rtc_init(Sda, Scl);     clear_Display();     tckr.allegare(0.05, timer50ms);    ogni 50 msec     Tm* Tt;     Se (Tt != Null)         rtc_set(Tt);     Altro         Seriale.println("nessun timepacket ricevuto");
}
//**************************************************************************************************
La funzione loop viene chiamata in un ciclo infinito
Vuoto Ciclo() {     Aggiungi qui il tuo codice ripetuto     Unsigned Int sek1 = 0, sek2 = 0, min1 = 0, min2 = 0, std1 = 0, std2 = 0;     Unsigned Int sek11 = 0, sek12 (sek12) = 0, sek21 (in seguito alla sint21) = 0, sek22 = 0;     Unsigned Int min11 = 0, min12 = 0, min21 = 0, min22 = 0;     Unsigned Int std11 = 0, std12 = 0, std21 = 0, std22 = 0;     Firmato Int X = 0; x1,x2;     Firmato Int Y = 0, y1 = 0, y2 = 0;     Bool Updown = False;     Unsigned Int sc1 = 0, sc2 = 0, sc3 = 0, sc4 (sc4) = 0, sc5 (sc5) = 0, sc6 (sc6) = 0;     Bool f_scrollend_y = False;     Unsigned Int f_scroll_x = False;     z_PosX = MaxPosX (informazioni in base al valore maxPos;     d_PosX = -8;     x-0; x1-0; x2-0;     refresh_display();     Updown = Vero;     Se (Updown == False) {         y2 = -9;         y1 = 8;     }     Se (Updown == Vero) { scorrere verso l'alto fino al basso         y2 = 8;         y1 = -8;     }     Mentre (Vero) {         Rendimento();         Se (f_tckr24h == Vero) { syncronizza RTC ogni giorno             f_tckr24h = False;             Tm* Tt;             Se (Tt != Null)                 rtc_set(Tt);             Altro                 Seriale.println("nessun timepacket ricevuto");         }         Se (f_tckr1s == Vero)        bandiera 1sek         {             rtc2mez();             sek1 = Mez.sek1;             sek2 = Mez.sek2;             min1 = Mez.min1;             min2 = Mez.min2;             std1 = Mez.std1;             std2 = Mez.std2;             Y = y2;                 scorrere verso l'alto             sc1 = 1;             sek1++;             Se (sek1 == 10) {                 sc2 = 1;                 sek2++;                 sek1 = 0;             }             Se (sek2 == 6) {                 min1++;                 sek2 = 0;                 sc3 = 1;             }             Se (min1 == 10) {                 min2++;                 min1 = 0;                 sc4 (sc4) = 1;             }             Se (min2 == 6) {                 std1++;                 min2 = 0;                 sc5 (sc5) = 1;             }             Se (std1 == 10) {                 std2++;                 std1 = 0;                 sc6 (sc6) = 1;             }             Se ((std2 == 2) && (std1 == 4)) {                 std1 = 0;                 std2 = 0;                 sc6 (sc6) = 1;             }             sek11 = sek12 (sek12);             sek12 (sek12) = sek1;             sek21 (in seguito alla sint21) = sek22;             sek22 = sek2;             min11 = min12;             min12 = min1;             min21 = min22;             min22 = min2;             std11 = std12;             std12 = std1;             std21 = std22;             std22 = std2;             f_tckr1s = False;             Se (Mez.sek12 (sek12) == 45)                 f_scroll_x = Vero;         } fine 1s         Se (f_tckr50ms == Vero) {             f_tckr50ms = False;             Se (f_scroll_x == Vero) {                 z_PosX++;                 d_PosX++;                 Se (d_PosX == 101)                     z_PosX = 0;                 Se (z_PosX == MaxPosX (informazioni in base al valore maxPos) {                     f_scroll_x = False;                     d_PosX = -8;                 }             }             Se (sc1 == 1) {                 Se (Updown == 1)                     Y--;                 Altro                     Y++;                 char2Arr(48 + sek12 (sek12), z_PosX - 42, Y);                 char2Arr(48 + sek11, z_PosX - 42, Y + y1);                 Se (Y == 0) {                     sc1 = 0;                     f_scrollend_y = Vero;                 }             }             Altro                 char2Arr(48 + sek1, z_PosX - 42, 0);             Se (sc2 == 1) {                 char2Arr(48 + sek22, z_PosX - 36, Y);                 char2Arr(48 + sek21 (in seguito alla sint21), z_PosX - 36, Y + y1);                 Se (Y == 0)                     sc2 = 0;             }             Altro                 char2Arr(48 + sek2, z_PosX - 36, 0);             char2Arr(':', z_PosX - 32, 0);             Se (sc3 == 1) {                 char2Arr(48 + min12, z_PosX - 25, Y);                 char2Arr(48 + min11, z_PosX - 25, Y + y1);                 Se (Y == 0)                     sc3 = 0;             }             Altro                 char2Arr(48 + min1, z_PosX - 25, 0);             Se (sc4 (sc4) == 1) {                 char2Arr(48 + min22, z_PosX - 19, Y);                 char2Arr(48 + min21, z_PosX - 19, Y + y1);                 Se (Y == 0)                     sc4 (sc4) = 0;             }             Altro                 char2Arr(48 + min2, z_PosX - 19, 0);             char2Arr(':', z_PosX - 15 + X, 0);             Se (sc5 (sc5) == 1) {                 char2Arr(48 + std12, z_PosX - 8, Y);                 char2Arr(48 + std11, z_PosX - 8, Y + y1);                 Se (Y == 0)                     sc5 (sc5) = 0;             }             Altro                 char2Arr(48 + std1, z_PosX - 8, 0);             Se (sc6 (sc6) == 1) {                 char2Arr(48 + std22, z_PosX - 2, Y);                 char2Arr(48 + std21, z_PosX - 2, Y + y1);                 Se (Y == 0)                     sc6 (sc6) = 0;             }             Altro                 char2Arr(48 + std2, z_PosX - 2, 0);             char2Arr(WT_arr[Mez.Wt][0], d_PosX - 5, 0);        giorno della settimana             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);           Giorno             char2Arr(48 + Mez.tag1, d_PosX - 33, 0);             char2Arr(M_arr[Mez.mon12 - 1][0], d_PosX - 39, 0); Mese             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);                     Anno             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             Se (f_scrollend_y == Vero) {                 f_scrollend_y = False;             }         } fine 50ms         Se (Y == 0) {             fare qualcos'altro         }     }

}

 

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

Esp-8266Projekte für anfänger

6 Kommentare

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.

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert

Post di blog consigliati

  1. Installa ESP32 ora dal gestore del consiglio di amministrazione
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - Programmazione ESP tramite WLAN

Prodotti consigliati