L’OROLOGIO STRANO IN NTP

Cari ElettroAmici,

E’ da un po’ di tempo che non vedo nuove pubblicazioni…. Spero non sia colpa di qualche virus e mi auguro che siate tutti in buona salute. Personalmente non ho (per fortuna) problemi, ma dal punto di vista sociale ne avrei in quantità industriale. Vivo a 1000 metri in un paese che dovrebbe essere a vocazione turistica: ma circolare in paese in questo periodo è come essere in un deserto. Anzi forse il deserto è più vivo.

Ma lasciamo stare e veniamo allo scopo di questo articolo. Ormai lo sapete che ho l’ossessione degli orologi e credo di averne prodotti qualche decina tra quelli attuali e altri più vetusti e dismessi.
Questa volta ho prodotto un orologio che segna solo le ore. E i minuti ?. Sì anche quelli ma ogni 5 minuti.
Questa foto rappresenta il prodotto finito (si fa per dire: abbiate pietà per l’ estetica): Ho usato come base per i 12 led che rappresentano le ore, un disco cannibalizzato da un Hard_Disk guasto. Ogni led rappresenta un’ ora secondo la classica disposizione di tutti i quadranti degli orologi.

Le foto seguenti: frontale dell’orologio e interno hardware:

E i minuti ??. Anche loro sono rappresentati ma con passo di 5 utilizzando i led delle ore e facendoli lampeggiare appunto per 5 minuti. I due led centrali definiscono AM/PM.
Facciamo un esempio: Ore 10 e 17 minuti: Si accende il led delle ore 10 e il led delle ore “3” che lampeggia fino a quando i minuti non passano a 20 facendo lampeggiare il led delle ore “4” e così via. Cosa succede per l’ora (ad esempio) come le 10,10. Lampeggerà solo il led delle ore “10” ad indicare le 10 e 10 minuti. E questo sistema vale per tutti i minuti che collimano con le ore.

Diciamo allora che l’orologio non segna mai l’ora precisa !. Ma conoscendo il trucco possiamo sempre dire che sono le ore X a cavallo di 5 minuti. Invece l’ orologio E’ preciso. Perché ?.
Perché mi sono stufato dei vari RTC tipo DS1307, DS3231 e altri che non sono mai precisi nel tempo e che hanno bisogno sempre di qualche regolazione. Ci sono altri modi per avere una tempificazione oraria precisa: ad esempio ricavare dalla rete 220V i 50 Hz disponibili con un semplicissimo circuito e che con un opportuno circuito divisore si può ottenere la frequenza di 1 HZ abile a pilotare i circuiti di conteggio a partire dai secondi. Ma questa soluzione andava bene qualche decennio fa: io stesso l’ho utilizzata per produrre il primo orologio digitale. Chiaro che oggi non è percorribile questa strada per una serie di motivi: 1) la tensione 220 è pericolosa, 2) occorrono diversi integrati per realizzare il tutto, 3) Non è conveniente. Allora in questo progetto mi sono affidato all’ ora INTERNET. Ovvero recuperando orario e data dai server NTP che gestiscono appunto il tempo. Avevo già prodotto un orologio che attraverso un LCD visualizzava la data completa e l’orario ripresi appunto dai server NTP.

Vediamo allora le caratteristiche costruttive:

L’Hardware usato:
• Micro Arduino Nano 328 come motore principale per la gestione dell’orologio
• Micro ESP8266_1 per la gestione del server NTP
• MAX7219 per la gestione dei led. Ottimo: con 3 fili si pilotano 64 led con un solo integrato con la possibilità di connettere altri chip in serie.
• 12 led (modello a cilindro alta luminosità bianco freddo).
• N.1 Convertitore di livello bidirezionale 3V/5V per adeguare i livelli del ESP a quelli di Arduino
• N.1 Modulo regolatore AMS1117 (da 5V a 3V) per alimentare il micro ESP

Il convertitore di livello si rende necessario in quanto l’ESP funziona solo a 3V e quindi tutti i livelli dei PIN vengono gestiti con questo livello. Il regolatore di tensione per avere i 3V serve per alimentare l’ESP in modo indipendente dal Micro Arduino_Nano (che a sua volta dispone di un’uscita a 3V).

Software:

IDE di ARDUINO per la compilazione e programmazione dello sketch relativo alla gestione del server NTP. L’IDE deve essere configurato opportunamente per riconoscere la serie ESP dal più piccolo al più versatile in termini di funzionalità e presenza di PIN. Occorre aggiornare l’elenco delle “SCHEDE” e delle “LIBRERIE”. Lo sketch MAIN per la gestione può essere gestito dall’IDE di ARDUINO: personalmente preferisco usare un altro IDE molto più performante: CODE:BLOCK. Funziona perfettamente per quello che riguarda la quasi totalità delle versioni ARDUINO comprese librerie standard. E’ velocissimo e per ogni funzione/istruzione presenta un pratico “completamento automatico”. E i messaggi di errore sono molto più chiari di quelli dell’IDE di Arduino. Non è aggiornato alle librerie WIFI. E se non ci sono le librerie necessarie per lo sketch è sufficiente inserirle all’interno del “progetto” sia come file .h he come file .cpp.

Per la gestione del MAX7219 utilizzo una libreria “custom” ampliata e modificata dal sottoscritto rispetto alle librerie originali (presenti nella rete). Non ha le caratteristiche e le forme di una libreria standard (non ha file .h e .cpp) ma è un file .ino. E’ in grado di gestire ogni tipo di led, ogni tipo di display 7 segmenti e i moduli display a matrice 8×8 e 7×5. Per i display a 7 segmenti è previsto anche il tipo a ANODO_COMUNE: questo perché il chip gestisce solo dispositivi a CATODO_COMUNE. In questo caso occorre una piccola aggiunta hardware. Qualcuno adesso si chiederà perché usare ben due Micro per produrre un orologio che non è mai “PRECISO”. Sarebbe stato molto più semplice utilizzare un ESP32 che ha in dotazione un numero di pin più che sufficiente per pilotare i dispositivi usati nel progetto. Ma ho diversi ESP8266 acquistati a suo tempo e non avevo nessun interesse a procurarmi un ESP32 e dover ri-scoprire le funzionalità.

Ma, ripeto, sono scelte personali.

Vediamo adesso come è stato sviluppato tutto il software di gestione:

Lato ESP: questo micro prodotto dalla “Espressif” permette la completa gestione di una connessione internet per lo sviluppo di pagine WEB (via WIFI) da visualizzare su un comune tablet o pc. Ho fatto diversi sketch per provare a costruire pagine WEB in varie misure e dimensioni. Nel mio progetto “CIABATTA ELETTRONICA” la gestione dei relais viene effettuata da una pagina WEB in cui compare lo stato ON/OFF dei 5 relais.

Purtroppo questo ESP è molto avaro di PIN: in pratica sono soltanto 2 usabili GPIO/0 e GPIO/2. I pin RX/TX vengono usati come interfaccia seriale. E’ molto importante avere una interfaccia tra l’IDE di arduino e lo stesso micro per la programmazione: se i livelli di GPIO/0, non sono nella condizione corretta NON riuscirete mai a programmarlo: l’IDE non riconosce la porta seriale anche se connessa.
Quando ho comprato il primo ESP ho comprato anche un modulo “DEBUGGER”. Questo modulo viene visto come una porta seriale. Inserendo l’ESP nel connettore, l’IDE riconosce la porta e la programmazione (porta a massa GPIO/0 automaticamente) viene effettuata correttamente. Il modulo presenta anche un pulsante di reset per far ripartire l’ESP.

Prima di passare alla struttura fisica del progetto vediamo la logica con cui sono stati sviluppati gli sketch:

Sketch su ESP8266_1:
Dopo le consuete impostazioni relativi al WIFI (con connessione al router e attribuzione dell’indirizzo dinamico IP) viene aperta una porta seriale (baud_rate 19200) gestita dalla libreria standard “Software_Serial” utilizzando i pin GPIO/0 e GPIO/1 come RX/TX che attraverso il modulo convertitore di livello vengono connessi a due pin di Arduino. Viene quindi instaurato un colloquio tipo “HAND_SHAKE” ovvero “io ti invio dati, tu rispondi che li hai ricevuti” utilizzando RX/TX definiti. Questo primo colloquio serve a gestire l’ora solare/legale: lo sketch si aspetta di ricevere da Arduino il codice “36” per l’ora solare o “72” per l’ora legale. Questo in quanto il server NTP trasmette solo il tempo in ora solare ma la libreria che lo gestisce con la funzione “SetTimeOffset” aggiorna il tempo a ora legale settando il valore a 7200. Tutto questo viene gestito nel “Setup”.

Nel “loop”: si rimane in attesa di ricevere da parte di Arduino un carattere specifico ad indicare che lo stesso Arduino è pronto a ricevere i valori ORA e MINUTI che servono per aggiornare l’orologio. Ricevuto questo carattere l’ESP chiede al server NTP l’invio dei valori orari e vengono ricevuti 8 caratteri nella forma HH:MM:SS e memorizzati in una stringa. Il server NTP può inviare anche i valori della data che in questo caso non servono. Attenzione che ci sono diverse librerie che gestiscono i server NTP ma non tutte gestiscono sia i valori della data che del tempo. La libreria usata è invece completa. Si procede quindi a convertire i valori dell’ora e dei minuti in formato binario ottenendo due byte: il byte ORA (valori da 00 a 23) e il byte MINUTI (valori in gruppi di 5) dopo una semplice conversione decimale/binario. Questi due byte vengono inviati in sequenza via seriale ad ARDUINO che li utilizzerà per aggiornare l’orologio. Il ciclo quindi riprende dall’inizio.

NOTA: Il sistema appena descritto è l’ultimo di una serie di prove: inizialmente l’ESP inviava la stringa HH:MM:SS completa che Arduino riceveva e memorizzava a sua volta in una stringa simile per poi effettuare le conversioni e aggiornare l’orario. Questo sistema agiva correttamente fino ad un certo punto: poi “impazziva” nel senso che la stringa ricevuta era “SPORCA” di valori assolutamente fuori controllo. Il che pregiudicava la correttezza dei valori. Ho potuto rilevare tutto ciò attraverso il solito sistema “debug”, su monitor seriale, di messaggi per verificare cosa effettivamente Arduino ricevesse. E l’ESP inviava valori corretti !.

Sketch su Arduino (micro usato Arduino_Nano):

Anche in questo sketch effettuati i soliti settaggi delle porte comprese quelle seriali standard e quella relativa al “Software_Serial” e inizializzata la libreria per la gestione del MAX719 e relativi LED, la prima operazione che viene effettuata è quella di inviare all’ ESP il codice “36” o “72” per settare l’ora legale/solare. Questa scelta deriva da un ponticello su un pin di arduino portato a massa o lasciato libero. Dopo questo invio e la conferma da parte dell’ESP il ciclo di setup termina.

La sezione LOOP è più semplice di quanto si possa immaginare: vengono lanciate in sequenza 3 funzioni: la prima per ricevere i valori dell’ora (i due byte che vengono spediti dall’ESP), la seconda per aggiornare i led delle ore e la terza per aggiornare il led dei minuti. E il ciclo riprende.
La parte del “leone” è la routine che deve ricevere i valori “HH” e “MM” dall’ESP: anche in questo caso si utilizza la tecnica “HAND_SHAKE”: viene inviato un carattere per avvisare l’ESP. L’ESP risponde inviando i due bye convertiti. Il test sul valore delle ore determina l’accensione dei led AM/PM posti sul frontale dell’orologio. Le altre due routine si occupano di testare i valori HH e MM e accedere i relativi LED.

Vediamo la logica con cui si accendono i led delle ore quindi anche per i minuti:
Il MAX7219 singolarmente può gestire fino a 64 led oppure una matrice 8×8 (64 led). Un registro indirizza le singole catene (D0/D7) mentre un altro registro definisce quale led (o punto della matrice) accendere (o spegnere) in funzione di come viene settato un altro registro secondo la seguente configurazione:

DP, A/G si riferiscono rispettivamente alla posizione dei segmenti di un classico display a 7 segmenti + il punto decimale (DP). Oppure a 8 led connessi (catodo comune) nello stesso modo assegnando a ciascun led una posizione da DP a G. L’orologio ha 12 led: per poterli indirizzare tutti ho definito due catene ognuna di 6 led: in questo caso: il registro “D0” indirizzerà i led dalle ore 12(00) alle 5(17), mentre il registro “D1” indirizzerà le ore dalle 6(18) alle 11(23). I led rimarranno accesi fino a quando non si effettua la modifica delle ore o dei minuti. Ciò in quanto il MAX7219 si preoccupa anche del Multiplexing. E non sono necessarie resistenze di limitazione per i led.

Nello sketch MAIN su arduino_Nano una apposita tabella di 12 elementi contiene la codifica del registro dati con i bit da accendere o spegnere e il bit DP viene usato per discriminare quale catena utilizzare per l’accensione delle ore/minuti. I led si accendono portando a “1” la relativa posizione o a “0” per spegnerlo. Questa è la tabella:

byte Tab_Led_Ore [12] =
{
DPABCDEFG                           ORE    MIN HEX            Nota:  il bit “G” non è mai usato
B01000000, // Offset 0 ore “0” “12” 00 0x40
B00100000, // Offset 1 ore  “1” “13”   5 0x20
B00010000, // Offset 2 ore “2” “14” 10 0x10
B00001000, // Offset 3 ore “3” “15” 15 0x08
B00000100, // Offset 4 ore “4” “16” 20 0x04
B00000010, // Offset 5 ore “5” “17” 25 0x02
B11000000, // Offset 6 ore “6” “18” 30 0xC0
B10100000, // Offset 7 ore  “7” “19” 35 0xA0
B10010000, // Offset 8 ore “8” “20” 40 0x90
B10001000, // Offset 9 ore “9” “21” 45 0x88
B10000100, // Offset A ore “10” “22” 50 0x84
B10000010 // Offset B ore “11” “23” 55 0x82
};

ATTENZIONE: Non c’è obbligo di utilizzare i registri D0/D1. Possono essere usati anche gli altri da D2 a D7 se non vengono utilizzati per altri scopi. Il chip non ha preferenze specifiche.

PRODUZIONE PCB E CIRCUITI

Non avendo attrezzatura speciale mi devo accontentare di produrre piccoli PCB utilizzando il metodo “PRESS_AND_PEEL”. Dopo una serie di esperienze sono comunque riuscito ad avere un prodotto finale sufficientemente valido. I tre PCB di questo progetto sono: il primo alloggia il micro Arduino Nano e il chip MAX7219, il secondo l’ESP e l’elettronica di interfaccia e il terzo i 12 led dell’orologio.

Layout del primo PCB:

A destra il connettore per inserire il micro Arduino Nano, a sinistra l’alloggiamento del MAX7219. Non c’è un alimentatore specifico in quanto la presa USB del micro connessa ad un qualsiasi carica batterie per cellulari o tablet con uscita 5V 1/A, è sufficiente a sostenere il tutto. Al reset è connesso un pulsantino che provvede a resettare il Nano e l’ESP nello stesso momento. Un connettore porta i segnali RESET,V5, GND, TX, RX verso il PCB che alloggia l’ESP. Il pin AM/PM viene connesso alla piccola piastrina con i due led AM/PM. Infine un ponticello 36/72 per settare la cosiddetta ora legale/solare.

Layout del secondo PCB:

Questo pcb sostiene: il regolatore 5V > 3V per alimentare l’ESP, il convertitore di livello per adeguare i livelli 5v a 3v, e infine il connettore per alloggiare l’ESP. I 5 pin in alto vengono connessi rispettivamente a 5 pin del pcb main. I segnali RX/TX in ingresso vengono connessi regolarmente ai pin TX/RX dell’ESP tramite il convertitore di livello. NOTA: sarebbe stato sufficiente anche un partitore di tensione.

Layout del terzo PCB:

Alloggia i 12 led con i due connettori (A_F) per le rispettive catene e i due pin DG0/DG1. Le connessioni A/F vengono poi unite in parallelo (A con A, B con B, ecc) per essere poi connesse ai rispettivi pin del MAX7219. Così come DG0/DG1.

Dimenticavo quest’ultimo PCB: è relativo ai due led AM/PM che si accendono a seconda del livello 0/1 presente sul pin di ingresso.

                                                        .

Concludendo:

Ad oggi l’unico problema da risolvere è racchiudere il tutto in una opportuna scatola o qualcosa del genere. Essendo una frana in bricolage non mi riesce mai di fare qualcosa, almeno esteticamente, valido.

Nel frattempo Vi ringrazio dell’attenzione e rimango in attesa dei Vs commenti tenendo presente che tutto è perfettibile e fattibile con risultati migliori. Io rimango solo un hobbista che si diletta, con la propria ignoranza, a scoprire sempre cose nuove.

gvsoft marzo 2021