Autore: gvsoft

  • L’OROLOGIO STRANO IN NTP

    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

  • Ciabatta Elettronica

    Ciabatta Elettronica

    CIABATTA ELETTRONICA

    Ovvero pilotare 5 prese a 220V tramite WIFI 

    Eccomi con un nuovo progetto e questa volta non si tratta dell’ennesimo orologio più o meno digitale. Qualche tempo fa ravanando su YouTube alla ricerca di qualche novità da riproporre, ho trovato il progetto fatto e finito di una ciabatta comandata tramite Bluetooth. Mi sono chiesto allora se potevo riprodurlo in qualche modo adattandolo alle mie esigenze. Mi sono messo a studiare ciò che avevo visto a condizione di usare solo componenti già in possesso e quindi a costi non dico irrisori ma quasi.

    Partendo dalla base ho cannibalizzato una ciabatta a 6 posti con interruttori singoli che aveva qualche problema proprio negli interruttori. Non sono proprio il massimo e dopo qualche tempo si guastano rompendosi. La ciabatta in questione è quella nella foto sottostante:

     

    Ogni interruttore ha una spia consistente in una piccola lampadina pisello (ricordate quelle che si usavano una volta per illuminare l’albero di Natale ?) con una resistenza di caduta. Però sono fragili e a furia di manovrarli prima o poi su rompono.

    Allora procediamo con il progetto: la base c’è. Allora mano al cacciavite e apriamo la ciabatta. Scolleghiamo tutti gli interruttori e togliamoli dall’alloggiamento. Ogni interruttore è facilmente smontabile lasciando solo un alloggiamento rettangolare vuoto usabile e sufficientemente capiente.

    Passiamo alle prese: Ognuna di esse è connessa in parallelo al un ramo della tensione di ingresso mentre l’altro ramo fa capo ad un interruttore connesso all’altro ramo della tensione. Isoliamo quindi 5 dei sei capi in modo da avere 5 fili singoli (uno per ogni presa). Perché cinque e non sei ?.
    Perché ho lasciato la prima presa connessa al 220 in modo da utilizzarla fuori dal contesto.

    Però più che le parole valgono i fatti e nella foto sottostante si può vedere cosa è diventata:

    Possiamo vedere: ogni alloggiamento degli interruttori è stato riempito con un led rosso ad alta luminosità e inglobato (con la sua resistenza di caduta) in una colata di cera (quella delle candele per intenderci). Anche se in questa foto non si vedono sul lato sinistro della ciabatta sono stati praticati 2 fori: uno per fa passare il singolo filo di tensione di ogni presa e il filo “master” per la chiusura di ogni singolo contatto. Il secondo foro per far passare i fili di ciascun led e il filo di massa comune per tutti i led. Notare il buco che alloggiava l’interruttore della prima presa. Nella foto si può vedere che la seconda e la sesta presa sono sotto tensione 220 e la spia LED relativa è accesa. Questa foto si riferisce alla prime prove di funzionamento prima della produzione dell’ Hardware vero e proprio.

    STUDIO DEL PROGETTO:

    Come ho già detto l’intero progetto deve costare pochissimo a patto di utilizzare solo componenti già in possesso o al massimo acquistare solo quelli necessari.

    Prima idea: utilizzare una pagina WEB con cui comandare singolarmente ognuna delle prese in accensione e/o spegnimento.

    Seconda idea: utilizzare un dispositivo BlueTooth per fare lo stesso.

    Quale è la più semplice ? : dipende dal grado di esperienza che ognuno di noi hobbista, dilettante o professionista, ha relativamente alla programmazione dei due sistemi. Personalmente sono un hobbista senza grandi pretese e ritengo di cavarmela a sufficienza in entrambi i sistemi. Allora per ogni modalità vediamo complicazioni e facilitazioni:

    Idea WEB: Forse è la più complicata in quanto richiede risorse e conoscenze di un certo livello. Le risorse possono essere: scheda Arduino e shield Ethernet ma le esperienze effettuate dal sottoscritto qualche anno fa non mi hanno soddisfatto e la stessa shield NON gestisce il WIFI. Per cui è stata scartata. Se vogliamo allora fare qualcosa di più “moderno” e usare il WIFI (tanto oggi va di moda !) è possibile utilizzare i moduli ESP_8266 che in una dimensione di 25mm per 12,5 raccolgono un completo microprocessore programmabile via Arduino e specifico per effettuare connessioni in WIFI utilizzando WEB_SERVER e altri sistemi.

    Qual’ è la complicazione di questa scelta ?: Una buona esperienza di programmazione “C”, la personalizzazione dell’ambiente Arduino a gestire questo modulo, la conoscenza delle pagine HTML e la loro programmazione. Tutto questo potrebbe non essere alla portata di tutti. Personalmente ho fatto un po’ di esperienza sia in tempi recenti che in tempi remoti almeno per quanto riguarda le pagine HTML. Però credo che anche a non essere “esperti” c’è tanto materiale ON_LINE che aiuta a programmare questi moduli ESP fornendo esempi più o meno complessi.
    L’unico svantaggio molte volte è la lingua: moltissimi siti sono di lingua inglese.

    Idea BlueTooth: Questa forse è la più semplice: il modulo BlueTooth non si connette in WIFI ma appunto tramite protocollo Bluetooth disponibile su tutti i tablet e cellulari. Può essere usato connettendolo in modalità seriale ad un micro arduino, oppure utilizzare qualche APP (o programmarla per chi è capace) prodotta allo scopo. Nella fattispecie in questo progetto può essere utilizzato in modalità seriale con la libreria “Serial_Software” di Arduino. Lo sketch deve essere programmato in modo da ricevere i caratteri seriali che l’APP invia appunto via seriale. Ci sono diverse APP che gestiscono questo modulo in modo seriale. Quindi l’ unica complicazione è la programmazione dello sketch.

    Dopo aver analizzato le due idee ho deciso di usare i moduli ESP_8266 per una serie di motivi. Qualche tempo fa ne avevo acquistati ben 5 del modello ESP_01 per fare delle esperienze. Ne avevo utilizzato solo uno per produrre un orologio digitale ON_LINE ovvero riprendendo il tempo da internet visualizzandolo su un LCD (data e orario completi). Perché allora lasciarli invecchiare nel cassetto ?.

    L’uso di questo micro implica una serie di “complicazioni” e “aggiustamenti” nell’ambiente IDE di Arduino. Non è difficile basta seguire le indicazioni che si trovano nel WEB per aggiornare l’IDE sia in termini di “schede” che devono essere gestite sia in termini di “librerie” usabili. In effetti sia le “schede” che le “librerie” sono tantissime ma per prima cosa occorre inserire nelle impostazioni dell’IDE di Arduino la seguente definizione:

    Url aggiuntive per il gestore schede: http//arduino.esp8266.com/stable/package_esp8266com_index,json

    Poi se non viene eseguito in automatico, da menù “strumenti” selezionare “Gestione schede” e lasciare che l’IDE ricerchi le “schede” da aggiungere. Si dovrà allora nell’ elenco proposto scegliere come da figura: (nel mio ide sono già installate).

    Se tutto va a buon fine nella selezione delle schede da usare si troverà un elenco di schede ESP che possono essere utilizzate: nella fattispecie è sufficiente selezionare la voce “Generic ESP8266 module”.

    L’ESP8266_01 presenta (pur nelle sue dimensioni) ben 8 pin:

    • VCC (3,3V tassativi !) e GND.
    • Due pin definiti GPIO_0 e GPIO_2. Sono di pin che possono essere visti come INPUT/OUTPUT di segnali logici (Bit “0” Bit “1”) sempre rispetto al livello dei 3V. .
    • RST per il reset del micro a massa per resettarlo altrimenti a “1” logico.
    • Il pin EN (enable) che abilita il micro se posto a “1” logico.
    • Due pin TX/RX che possono essere usati per ricevere e trasmettere dati seriali ricordandosi che il livello dei segnali è basato sui 3V di alimentazione. TX e TX vengono anche definiti come GPIO_1 e GPIO_3 in quanto potrebbero essere usati come pin di I/O ma con attenzione.

    La complicazione sull’uso di questo micro sta nella programmazione se non si usa un adeguato sistema. Il pin GPIO_0 viene anche definito GPIO_0FLASH in quanto se posto a massa permette la scrittura dello sketch nella memoria flash del micro.

    Non è così facile come sembra: c’è una specifica sequenza di operazioni da fare per portare detto micro in nella condizione di accettare il caricamento: spegnerlo, portare GPIO_0 a massa quindi riaccenderlo oppure fare un reset sempre con GPIO_0 a massa. Ma non è stato semplice. Ho avuto l’accortezza (senza saperlo) di acquistare un modulo “debugger” con il quale ho risolto appunto senza saperlo (inizialmente) proprio questo problema di caricamento.

    Ecco i due moduli: A sinistra un modulo ESP_01 e a destra il modulo Debugger. E’ utilissimo: viene visto come una porta seriale (COM), ha un tastino per il reset del micro e il connettore maschio è la copia esatta degli 8 pin del micro e quindi perfettamente utilizzabili. Nessun problema per il caricamento dello sketch in quanto effettua un modo automatico l’operazione descritta al paragrafo precedente. Dopo il caricamento si può provare lo sketch senza toglierlo dall’adattatore. Ho trovato questo modulo su Futura_Shop a circa 6 euro. Diffidate da altri adattatori perché non hanno queste caratteristiche.

    Un’ altra complicazione nell’uso di questo micro sta nell’ alimentazione: vuole soltanto 3,3 V e necessita di un sistema di alimentazione che fornisca i 3V con almeno 1A di corrente.
    E non finisce qui: i livelli GPIO_0, GPIO_2 sono anch’essi a livello 3V. Ora se devono essere usati per interfacciare altri dispositivi che lavorano a livello 5V si rende necessario un convertitore di livello (o partitori di tensione che io sconsiglio) come interfaccia tra i pin del micro e i pin di altri dispositivi. Quasi tutti i dispositivi con protocollo I2C richiedono ai pin SDA/SCL i livelli corretti a 5V. Per inciso nel mio orologio internet con LCD I2C ho usato questi convertitori tra GPIO_0 e GPIO_2 del micro.

    Ecco come si presentano: A sinistra l’ alimentatore con uscita 3V e a destra il modulo convertitore di livello con 4 canali. Questi convertitori hanno un ingresso a 5V e uno a 3V denominati HV e LV.
    Le uscite sono bidirezionali: ciò che entra a 5V esce a 3 e viceversa.

    (Immagini copiate dal sito EBMSTORE.it)

    NOTA IMPORTANTE che quasi dimenticavo: quando escono dalla fabbrica (cinese) tutti gli ESP sono dotati di un software per gestire i comandi “AT” per intenderci quelli che venivano usati una volta sui vecchi modem telefonici. Con questi comandi è possibile verificare, tra gli altri, anche la connessione WIFI al proprio router e verificare anche quanti sono nel raggio di azione del chip anche se limitato. Per provare questi comandi, anche senza bisogno di sketch appositi, occorre effettuare una connessione seriale (baud rate 115200) utilizzando il monitor seriale di Arduino oppure l’Hyper Terminal di Windows. Serve allora un convertitore RS232/USB per connettersi ad una porta USB del PC. DI seguito una delle connessioni fattibili. Nel convertitore RS232 FTDI occorre spostare il ponticello da 5V a 3V per rendere compatibili i segnali.

    ATTENZIONE: al primo caricamento di un qualsiasi  sketch sull’ ESP questo software “AT” viene perso e occorre scaricare dal web un’apposita applicazione “FLASH” per ricaricarlo.

    Il progetto comincia a prendere forma: abbiamo il micro, l’ alimentazione corretta e l’ adattatore logico di livello. Adesso occorre studiare come accendere/spegnere singolarmente le 5 prese a 220 della ciabatta. Ho verificato due sistemi:

    1. Pilotare un triac tramite foto accoppiatore con segnale a logica “1”. Avevo già sperimentato questi dispositivi con diversi circuiti ma si sono dimostrati sempre poco affidabili e non vanno bene per le lampade a risparmio energetico. Questo è uno dei circuiti.

    2. Pilotare un relais con foto accoppiatore o tramite transistor anch’esso pilotato da un segnale a logica “1”. I due schemi seguenti non presentano problemi specifici salvo quello con foto accoppiatore funzionante solo con relais a 12V.

    La scelta è caduta sull’interfaccia relais a 5V anche perché avevo a disposizione quasi 10 relais da circuito stampato con doppio scambio utilizzabili per commutare anche tensioni a 220V. Questi relais sono piuttosto anzianotti e non ricordo da dove li ho cannibalizzati. Questo il modello:

    Fatto un prototipo ho provato la funzionalità e quindi ho deciso di preparare tutta l’interfaccia per gestire cinque di questi relais usando l’interfaccia con transistor.

    Rimane solo un ultimo problema: i relais sono 5, il micro ESP ha sono 2 pin usabili senza problemi. Occorre quindi un dispositivo che permetta di aumentare questi pin. Anche in questo caso mi aiuta la mia passata esperienza con dispositivi tipo PCF8574 come quello in figura:

     

    Questo dispositivo si interfaccia con protocollo I2C indirizzabile su 7 indirizzi diversi (vedi ponticelli nella figura). Può essere inserito in cascata con altri dispositivi analoghi o altri tipo LCD sempre I2C salvo il corretto indirizzo. L’unico problema di questi dispositivi è l’ingombro e inserirlo in un PCB può dare qualche problema. Sarebbe preferibile usare il singolo chip in quanto non necessita di particolari circuiti: 5V per l’alimentazione anche se supporta i 3V, un paio di resistenza di pull_up ai pin SDA/SCL, qualche ponticello per assegnare l’indirizzo e niente altro.
    Gli 8 pin (più uno definito INT come interrupt) possono essere solo di Input o solo di Output o in modo misto. La lettura o scrittura su questi pin avviene semplicemente con la libreria WIRE (Wire.write o Wire.read).

    Ma ci sono dei problemi: non per i pin definiti in ingresso, ma per quelli definiti in uscita occorre verificare bene come si devono usare. La corrente massima (vedi i datasheet) è troppo poca anche per pilotare un singolo led. Diversi forum ON_LINE dimostrano come devono essere connessi eventuali led o dispositivi che per loro natura assorbono correnti superiori a quella erogata dal dispositivo.

    Questo in figura è uno degli esempi funzionanti per l’accensione di 8 led: si può notare la loro connessione: Anodo a VCC, catodo con R verso i pin. Facendo opportune prove ho potuto notare l’ottima luminosità di un classico LED verde. E’ importante però sapere che all’accensione del sistema tutti i pin del chip vengono posti a “1” logico: quindi mentre per lo schema precedente non ci sono anomalie (i led si accendono solo se il relativo pin viene posto a massa), nel mio caso può dare problemi in quanto tutti i relais si innescano con il segnale a “1” logico. E’ però superabile in quanto nello sketch la prima operazione da fare sarebbe quella di portare a “0” logico tutti i pin. Ma, c’è sempre un “ma”, c’è un tempo che per quanto sia in termini di millesimi è da tener presente: il micro si avvia dopo qualche secondo e ciò potrebbe causare problemi.
    Non dimentichiamo che nei relais passerà una tensione a 220V.

    Date queste premesse per non avere sorprese provo a fare qualche prova con cablaggi volanti e sketch minimali, connetto il PCF ad arduino (protocollo WIRE) e un pin all’ingresso del prototipo di accensione relais (Innesco con “1” logico). Perfetto: si accende e si spegne ma se ripetuto anche ad intervalli di qualche secondo a volte NON FUNZIONA !, risultando inaffidabile.

    Ritengo allora che la scarsa disponibilità di corrente sia la causa di questa inaffidabilità: dopo qualche giro ON_LINE decido di modificare il metodo di innesco: invece di portare “1” logico il pin lo porto a massa. Ma questo comporta una modifica al circuito di innesco per cui, per non dover modificare il tutto, interpongo tra i pin del PCF e gli ingressi un circuito inversore. A prima vista un 74Ls04 potrebbe andare bene, però ho preferito usare un ULN2003A che è un “SEVEN DARLIGTON ARRAY” che fornisce una corrente di 500ma. Sette ingressi ed altrettante uscite tutte però “Open_Collector” per cui si rende necessaria una R da 4,7 ohm (o superiore) in pull_up verso i 5V per ogni pin. E agisce anche da inversore per cui un ingresso a “1” viene invertito in uscita a “0” e viceversa. Ottimo per quello che mi serve: dovrò semplicemente modificare nello sketch il metodo di accensione: da “1” a “0” per ogni relais. E non dovrò preoccuparmi se all’accensione i pin del chip vanno tutti a “1”. Nella figura la disposizione dei pin.

    AVVIAMENTO DEL PROGETTO:

    Ritengo, a questo punto, di aver tutto a disposizione per iniziare a produrre PCB e implementare qualche sketch con l’ ESP_01. Facciamo la “lista della spesa” per sapere se abbiamo effettivamente tutto quello che serve e cioè:

    • N.1 ESP8266 modello 01
    • N.1 Convertitore di livello 5V/3V
    • N.1 Alimentatore da 3V (Input da 5 a 9V max)
    • N. 1 PCF8574
    • N. 1 ULN2003A
    • N. 5 Relais Finder modello 30.22
    • N. 5 transistor BC547
    • N. 5 diodi 1N4007
    • N. 5 LED AL. (qualunque colore)
    • N. 10 resistenze valori secondo lo schema
    • Connettori vari e zoccoli per il montaggio.
    • Pulsante di Reset del micro
    • Led (qualunque colore) come spia del sistema ON_LINE

    Non avendo strumentazione più o meno professionale e nemmeno un ambiente idoneo mi devo accontentare di produrre solo pcb di piccole dimensioni. Pertanto questo progetto si compone di due PCB: PCB MAIN per alloggiare il cuore del sistema e PCB RELAIS per alloggiare i relais.

    PCB MAIN:

    Non ho disegnato un circuito da cui ricavare questo pcb ma è stato disegnato a mano libera cercando di evitare ponticelli e compattare meglio i componenti.

    Si può notare: in alto a sinistra i connettori per alimentare la stessa scheda e altre; il connettore a quattro pin per l’inserimento del PCF8574. In basso a sinistra nel rettangolo rosso l’alimentatore da 3V. Nel mezzo il convertitore di livello a destra il connettore femmina per l’inserimento dell’ ESP_01. Il rettangolo giallo a forma di “L” rovesciata serve da guida per il taglio della parte in eccesso del PCB. Ecco la foto del PCB prodotto. Il taglio serviva ad inserire la scheda del PCF.

     

     

    PCB RELAIS:

    Questo pcb è il più complesso e per il disegno sono partito da un altro pcb prototipo prodotto per prove effettuando le dovute correzioni e facendo in pratica un copia/incolla.
    Lo schema elettrico è quello delle figure precedenti. In alto nel pcb possiamo vedere i 6 connettori relativi a: 5 per le 5 prese e il sesto per il secondo ramo della tensione a 220.In basso a sinistra i pin di alimentazione 5V che verranno connessi al PCB main. Al centro i 5 pin di ingresso dei segnali di innesco dei relais. I diodi dopo ogni ingresso sono 1n4148.

    Ecco nella foto come si presenta la scheda relais completata.

    Non ci crederete ma dopo tutta la produzione di PCB (progettazione e produzione) mi accorgo di aver dimenticato di inserire un componente fondamentale: il driver di interfaccia tra le uscite del PCF8574 e gli ingressi del PCB relais. Non potevo certo mandare all’aria quanto fatto e mi sono dovuto accontentare di fare un ulteriore pcb per alloggiare il driver da interporre. E ho prodotto il seguente:

    Le resistenze di PULL_UP sono da 4,7K.

    Alla fine in questa foto il progetto completato:

    Nel mezzo tra il PCB_Main e il PCB_Relais la schedina del driver. I tre connettori bianchi a destra della scheda relais servono a connettere i cavi di tensione delle 5 prese. Il sesto l’altro cavo di tensione del 220. Anche se non si nota bene in basso destra c’è il pulsante rosso che resetta il micro ESP e accanto un led che si accende quando tutto il sistema è ON_LINE come spiegherò nel capitolo software.

    Abbiate pietà sulla costruzione del supporto: come bricolage sono una vera e propria frana: le dimensioni del contenitore sono 10×20 cm !! in plexiglass.

    Nella foto seguente il progetto completo e funzionante.

    Purtroppo la ciabatta non è in grado di ospitare niente data anche la dimensione dei dispositivi.

    IL SOFTWARE DI GESTIONE:

    Ed eccoci arrivati alla parte più interessante e fondamentale di tutto il progetto. Come ho già detto all’inizio la scelta è caduta sull’ utilizzo di una interfaccia WEB tramite una pagina HTML gestibile via WIFI da un qualsiasi PC, Tablet, o cellulare. Premetto che la realizzazione degli sketch non sono tutta farina del mio sacco, ma attraverso il WEB ho potuto scaricare vari esempi di gestione di un WEB_SERVER per accendere e spegnere dei led e da questi esempi sono partito per implementare gli sketch completandoli con la gestione del PCF8574. Un po’ di esperienza nella implementazione delle pagine HTML l’avevo fatta anni fa ma è passato molto tempo ho dovuto rinfrescare la memoria.

    Gli sketch realizzati producono la seguente pagina HTML:

    Nella prima riga lo stato dei relais ad indicare quali sono “ON” e quali “OFF”. Nella seconda e riga 5 bottoni per portare “ON” ciascun relais, nella terza riga altri 5 bottoni per portare “OFF” ciascun relais. Ad ogni pressione del relativo bottone la prima riga viene aggiornata di conseguenza. Infine nella 4 riga due bottoni “ALL_ON” e “ALL_OFF” accendono o spengono tutti i relais in un colpo solo.

    Questa sottostante è la pagina HTML di un ulteriore sketch: Per inciso il disegno dei bottoni e stato effettuato con il software WYSIWYG che produce pagine HTML in modo visivo.

    Il procedimento è analogo ma con una diversità: La prima riga evidenzia sempre lo stato dei relais. I bottoni sottostanti hanno una doppia funzione: quando sono di colore “rosso” significa che il relativo relais è spento. Ad ogni pressione il relativo bottone diventa di colore blu e la dicitura cambia da ON a OFF e così per tutti gli altri, così come il bottone “ALL_ON “ che diventa “ALL_OFF” di colore blu. E la la prima riga evidenzia sempre lo stato dei relais.

    STRUTTURA E LOGICA DEGLI SKETCH:

    Ho implementato due sketch chiamati Ciabatta_Web e Ciabatta_Web3. La logica di programmazione è sostanzialmente la stessa cambia solo il metodo di gestione del PCF8574 relativamente alla accensione/spegnimento dei relais e la scrittura delle righe che compongono la pagina web.

    Per gestire delle pagine HTML ON_LINE con il supporto dell’ ESP_01 e altri modelli, ci sono vari metodi per un approccio corretto: non mi dilungo in questa sede su quali e quanti sono in quanto ognuno ha le sue caratteristiche specifiche ed un diverso metodo di gestione. Mi limito a descrivere quello usato nei due sketch.

    Per accedere ad un sistema WIFI_Server occorre:

    La libreria “ESP8266WiFi”. Che deve essere stata caricata una_tantum quando è stato aggiornato l’Ide di Arduino per le schede ESP.

    La definizione dei parametri per accedere al proprio router casalingo: “ssid” che è il nome assegnato al router, e la sua password. Due semplici definizioni come queste: I nomi possono essere di propria scelta.

    const char* ssid = “nome del router”;
    const char* pwd = “password assegnata”

    Infine l’assegnazione della porta al WiFiServer con questa definizione:
    WiFiServer server (80); (il server “ascolta” sulla porta 80)

    Ovviamente occorre anche definizione della libreria WIRE che serve a gestire il PCF8574.

    In entrambi gli sketch è stato inserita la possibilità di effettuare un debug inserendo la classica Serial.print() in punti più o meno critici dello sketch attraverso il monitor seriale di Arduino o (che io consiglio) l’Hyper Terminal di Windows. Purtroppo su Windows 10 questa APP non viene fornita per cui occorre cercarla nel Web e scaricare la versione gratuita.

    Viene quindi abilitata la porta seriale con baud a 115200 per l’ ESP (sembra che non funzioni a velocità inferiori) ma viene inserita anche una procedura per cui se non si preme un qualsiasi tasto entro 3 secondi vengono inibite le scritture sul monitor seriale delle segnalazioni di debug opportunamente programmate. Ma questa è una mia scelta personale. Del resto non esistendo altri metodi di debug interattivo, questa è la soluzione migliore per evitare di trovarsi al buio quando lo sketch per qualche motivo non risponde.

    NOTA: per eseguire il debug sul monitor è necessario che l’ ESP sia connesso ad un convertitore seriale tipo FTDI232 oppure al modulino “debugger” che ho descritto in precedenza in modo da assegnare una porta COM.

    Si passa quindi ad inizializzare il Wifi con il comando: WiFi.begin(ssid, pwd) e verificando attraverso un loop “while” che il WiFi.status sia ok: ovvero testando il parametro WL_CONNECTED finchè non è OK. Poiché la risposta del router potrebbe essere più lunga del normale è buona cosa inserire un timer di qualche secondo per evitare un loop infinito. Il router potrebbe non rispondere se i parametri sono errati o per altri cause.

    Effettuando il WiFI.begin(ssid, pwd) per default quando il router risponde e la connessione viene effettuata, viene assegnato all’ ESP un indirizzo IP nella classica forma 192.168.1.XXX dove XXX è l’indirizzo effettivo assegnato. Diventa necessario quindi sapere quale indirizzo è stato assegnato (DHCP abilitato nel router) all’ ESP per poter poi dal browser connettersi e lanciare la pagina HTML. Questo indirizzo non cambierà mai un quanto viene associato al MAC Address dell’ ESP.

    Ma come facciamo a sapere quale indirizzo è stato assegnato ?: Viene in aiuto il sistema di debug sul monitor seriale: dopo che la connessione è ok, viene inviato attraverso la classica Serial.print l’indirizzo assegnato con la frase: Serial.print(WiFi.localIP()).

    C’è un altro sistema per ovviare questo possibile inconveniente: assegnare un indirizzo statico con le seguenti definizioni:

    IPAddress ip (192.168.1.XXX) per definire l’indirizzo che si vuole nel parametro XXX.
    IPAddress gateway (192.168.1.1) indirizzo del gateway del router
    IPAddress subnet (255.255.255.0) maschera per gli indirizzi.

    Quindi dopo il WiFi.begin aggiungere la frase WiFi.config(ip,gateway,subnet). Dal browser per accedere sarà sufficiente digitare l’indirizzo assegnato per connettersi. I nomi sono a piacere proprio.

    Alla conclusione di queste operazioni andate a buon fine con la frase “server.begin()” si avvia il server pronto ad ascoltare le richieste che arrivano dal browser.

    A questo punto e solo questo punto attraverso il PCF8574 (che è già stato inizializzato) viene inviato un byte con la configurazione 0111 111: ovvero il bit 7 su cui è connesso un led si accende ma rimangono spenti tutti i relais della ciabatta. L’accensione di questo led verifica che tutte le operazioni effettuate sono ok e che il sistema “server” è on_line. Questo sistema del led è una scelta personale.

    Nel “setup” non c’è altro da aggiungere salvo eventuali operazioni per il settaggio di altri dispositivi che nella fattispecie del progetto non ci sono.

    Nel “loop” la parte del leone viene dalla gestione del “client” ovvero del sistema che deve interagire con il server e ricevere i comandi inviati dalla pagina WEB. La prima cosa è istruire il “client” a verificare se il server è disponibile: un loop dopo la frase” WiFiClient client = server.available()” permette di verificare quando il server è disponibile. Se risponde positivamente verifichiamo con un loop che il client sia disponibile . Se tutto procede OK possiamo procedere con leggere quando viene inviato da browser, memorizzandolo in una stringa, e di conseguenza inviare al client le istruzioni che compongono la pagina HTML. L’ istruzione client.print o client.println funziona come una Serial.print e quindi tra parantesi si definiscono le frasi HTML. La stringa che abbiamo memorizzata contiene quanto definito nei parametri cioè quale bottone è stato premuto. Una apposita routine analizza questa stringa e prepara quella che deve essere visualizzata nella pagina WEB ad indicare quale relais è ON o OFF.

    Ma più che le parole servono i fatti: ecco cosa viene emesso (debug dello sketch attivo) da quando con il browser ci connettiamo:

    Output su porta seriale per la verifica della connessione:

    Ciabatta WEB 3
    Connecting to TPLINK_8968                      >>>>> CONNESSIONE AL ROUTER
    ………….                                                              >>>>>> ATTESA DELLA CONNESSIONE
    WiFi connected. IP address: 192.168.1.113 >>>>>>> SERVER CONNESSO IP ASSOCIATO

    SI EFFETTUA DAL BROWSER LA CONNESSIONE ALL’INDIRIZZO 192.168.1.113 E VIENE EMESSA LA PAGINA HTML PROGRAMMATA

    New Client
    GET / HTTP/1.1
    Host: 192.168.1.113
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0
    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
    Accept-Language: it-IT,it;q=0.8,en-US;q=0.5,en;q=0.3
    Accept-Encoding: gzip, deflate
    Connection: keep-alive
    Upgrade-Insecure-Requests: 1

    Client disconnected.                  >>>>>>> DISCONNESSIONE DEL CLIENT DALLO SKETCH
                                                     >>>>>>>> NESSUNA OPERAZIONE RICHIESTA

    DA QUI IN AVANTI PER OGNI OPERAZIONE EFFETTUATA NELLA PAGINA DEL BROWSER VERRANNO EMESSE LE SEGUENTI FRASI QUANDO VIENE PREMUTO UN BOTTONE

    Host: 192.168.1.113
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0
    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
    Accept-Language: it-IT,it;q=0.8,en-US;q=0.5,en;q=0.3
    Accept-Encoding: gzip, deflate
    Connection: keep-alive
    Referer: http://192.168.1.113/6/ON   >>>>>>>> ECCO COSA INVIA IL BROWSER A SEGUITO DELLA PRESSIONE DI UN  BOTTONE: IN QUESTO CASO IL SESTO BOTTONE

    Upgrade-Insecure-Requests: 1

    Client disconnected.

    CONCLUSIONI:

    Premetto che tutto quanto è stato realizzato e completato è solo ed esclusivamente prodotto dal sottoscritto. Sicuramente può essere migliorato e pensato anche in modo diverso e più professionale. Anche le scelte circuitali possono essere oggetto di modifiche e sicuramente un approccio diverso potrebbe dare risultati migliori. Ma non sono un professionista e la mia esperienza in elettronica è limitata.

    Ringrazio comunque dell’ attenzione.

    Gvsoft luglio 2020.

     

  • Un filo per un orologio

    Un filo per un orologio

    UN FILO PER UN OROLOGIO

    Eccomi dopo una discreta assenza, a riproporvi l’ennesimo orologio digitale: ma ormai lo sanno tutti…la mia è una mania… o forse non so fare altro.

    Come è nato quest’ultimo orologio ?… ancora nel mese di marzo girovando nel web in cerca di qualche dispositivo da provare e sperimentare ho trovato sul sito di Futura_Elettronica un led particolare: somigliante in tutto e per tutto ad un led RGB (quattro pin R,G,B,anodo/catodo) ma non era un led RGB. Pur avendo i 4 canonici piedini è in realtà un led WS212. Ecco come si presenta:

    I piedini sono sempre 4 ma con definizioni diverse: ovvero DATA_IN, VCC,GND,DATA_OUT. Una tacchetta su un lato del led identifica il pin DATA_OUT. Alimentazione 5V. Formato del led: 5mm.

    La curiosità uccide il gatto (famoso detto….) e così ho effettuato un primo ordine di 20 led per sperimentare e provare il funzionamento. Ho detto che sono led WS2812: ovvero utilizzano un protocollo specifico di tipo seriale gestito dalle librerie ADAFRUIT_NEOPIXEL.  Non è facile descrivere questo protocollo: praticamente una sequenza di 24 bit (8 per ogni colore) inviata serialmente accende il led con il colore definito per il led R, per il G e per il led B come da questa immagine (fonte ws2812.pdf).

    Ovviamente ci sono delle tempistiche da rispettare ma non mi sono preoccupato più di tanto in quanto tutto il lavoro di gestione è affidato alla libreria. La particolarità di questi led è data dal tipo di connessione: ogni led viene connesso in cascata con il precedente formando quindi un catena praticamente senza limiti specifici: in effetti per realizzare questo orologio ho utilizzato ben 112 led.

    Ecco allora in anteprima il risultato finale:

    Abbiate pietà: sono una vera e propria frana nel bricolage e stavolta  mi sono anche superato: non è stato facile e solo in questi giorni ho praticamente finito i test.

     

    LA REALIZZAZIONE DEFINITIVA:

    Prima di partire in quarta ho effettuato uno studio di fattibilità (oggi è di moda) per decidere come connettere questi led, quale RTC usare, come aggiornare i valori dell’orario, come assegnare i colori e quale luminosità può essere accettabile per la visibilità e sopratutto come alimentare il tutto considerando la presenza di ben 112 led.  Questo problema dell’alimentazione e dell’assorbimento totale mi è costato molto tempo: non volevo correre il rischio di trovarmi senza un alimentatore adeguato: da fonti web ognuno di questi led dovrebbe assorbire ben 20ma per ogni colore. Quindi per un led al colore bianco occorre accendere i tre led con un assorbimento totale di 60ma. Ma questo poi si rileva un falso problema in quanto mai in questo orologio saranno accesi tutti i 112 led. Ma per evitare appunto inconvenienti ho preparato alcuni pcb con una serie di led connessi serialmente.

    Secondo alcune prove effettuate con un normale tester sulla portata 200ma si sono rilevate le seguenti misure:  (Valore della luminosità  = 25 e secondo funzioni della libreria è un valore basso).

    Catena con un solo led: Led spento: 07,7ma; Acceso rosso: 08,6ma; idem verde e blu; bianco 10,3ma; purple: 09,4;  giallo: 09,4.

    Catena con 2 led: Spenti: 15,3; Acceso rosso 1: 16,1ma; idem verde e blu; bianco 17,8ma; purple/giallo 16,9ma; Acceso rosso 1+2: 16,9ma: idem con verde e blu. Bianco 20,3ma; purple/giallo 18,6.

    Catena con 3 led: Spenti: 15,7; Acceso rosso 1: 16,6; verde, blu idem; Acceso rosso 1+2: 17,4; verde, blu idem; bianco 20,8; purple/giallo 19,1ma.Acceso rosso 1+2+3: 18,4; verde e blu idem; bianco 23,6ma; purple/ giallo  21ma.

    Catena con 4 led: Spenti: 16,2 ma; Acceso rosso 1: 17,1; verde e blu idem; bianco 18,8; purple 18ma/giallo; Acceso rosso 1+2: 17,9 ma; verde e blu 18,0 ma; bianco 21,4; purple/giallo 19,6; Accesso rosso 1+2+3: 18,8ma; idem verde e blu;  bianco 24,2; purple/giallo 21,5ma; Acceso rosso 1+2+3+4: 19,8 m; idem verde e blu; bianco 26,7; purple/giallo 23,3.

    Si può notare che i colori base (rosso, verde, blu) presentano sempre gli stessi valori così come il giallo e il purple. L’eccezione viene data dal colore bianco. Da prove effettuate con un campione di 12 led e usufruendo di un alimentatore separato (un carica batterie con potenza 1A e quindi separato dal micro) si possono riscontrare i seguenti valori: (valori rilevati con un comune tester con fondo scala a 200ma).

    Valore della luminosità (come da funzioni Neopixel) = 25

    Tutti i led spenti: ~ 34,3/35ma, 

    12 Led accesi colore rosso, verde, blu –> 41,9/42,0;

    12 Led accesi colore giallo/rosa: –> 51/51,2;

    12 Led accesi color bianco: –> 49,8/49,9

    Prove con 16 led: spenti 40ma. Rosso/verde/blu 16 accesi 49/50ma;  

    Con questi valori e azzardando una ipotesi, l’assorbimento totale di un quadrante di 28 led dovrebbe essere tra i 100 e i 150mA. E in teoria, l’insieme dei 4 quadranti dovrebbe essere intorno a 400/600 mA.  Ma rimane una teoria allo stato dell’arte avendo effettuato prove con solo 16 led.

    Il risultato finale dopo queste prove e dopo la completa realizzazione dell’orologio è che con un carica batterie per telefonini (5V,1A) tutto funziona stabilmente: l’alimentatore dopo 24 ore di funzionamento continuo è rimasto sempre “FREDDO“. Ho tuttavia optato per un alimentatore specifico da 5V,2A per avere una tensione stabile a 5V (i carica batterie a regime hanno una caduta di tensione di quasi 0,5V)  e anch’esso dopo 24 ore è sempre rimasto “FREDDO“.

    Un’altra particolarità da tener presente: al momento dell’accensione del sistema (indipendentemente dal numero di led connessi) tutti i led si accendono la massimo della loro luminosità e quindi si può crare un picco di assorbimento. Deve essere previsto quindi il totale spegnimento (via software) immediamente dopo l’avvio del sistema. 

    Partiamo allora con le specifiche definitive del progetto:

    1. Quattro display (che chiamerò quadranti), per visualizzare le ore e i minuti. Ogni quadrante viene formato ad immagine e somiglianza di un display a 7 segmenti: ogni segmento è composto da 4 led. Scelta dovuta ad un compromesso tra costo e ingombro.
    2. Due led con lampeggio alternativo in base al valore dei secondi
    3. RTC DS3231 ritenuto più stabile e preciso del Ds1307
    4. Un trimmer analogico per gestire fino a 8 livelli di luminosità modificabile anche a caldo
    5. Un dip_switch a 8 posizioni per scegliere fino a 4 colori per ciascun quadrante modificabili a caldo (due switch per ogni quandrante).
    6. Pulsanti per la regolazione dell’ora e dei minuti in fase di inizializzazione se necessario.
    7. Due pulsanti per l’avvio del sistema e per il reset.

    Date queste specifiche l’Hardware utilizzato è il seguente:

    • Micro Arduinio Nano scelto per le dimensioni e per avere già tutto quello che serve: USB per la connessione e il caricamento del software, alimentazione via USB.
    • RTC DS3231 come dispositivo per il mantenimento dei valori del tempo e della data
    • PCF8574 8 bit exapander I2C. Questo dispositivo mi permette di risparmiare per 8 pin di Arduino. Viene utilizzato per leggere i valori impostati nel Dip_Swtich.

    Vediamo ora alcuni schemi elettrici del progetto:

    Tipica connessione dei led:

    Questo schema dimostra (parzialmente) come vengono connessi i led: ogni gruppo di 4 forma un segmento del quadrante: quindi 7 segmenti vengono formati da 28 led totali. Ognuno di questi led è connesso in serie al successivo. Sarà compito del software selezionare opportunamente quale gruppo di 4 led (e quindi un segmento) accendere o spegnere. All’ingresso del primo led viene connessa una resistenza da 470 ohm. (come recitano i sacri testi). Ogni quadrante fa gruppo a se stante: l’uscita dell’ultimo led NON viene connessa con l’ingresso del primo led del quadrante successivo: c’è una ragione specifica. Durante le prove ho notato che questi led sono delicati ed è capitato anche uno “farlocco“. E’ chiaro che essendo tutti in serie è sufficiente che uno solo abbia qualche problema per inficiare tutta la catena successiva. Per evitare questo genere di problemi ho deciso di gestire singolarmente (la libreria lo permette) i 4 quadranti. Ne deriva soltanto una complicazione a livello programmazione nella scelta di quale quadrante utilizzare.

    Connessione dispositivi:

    In questo schema si mostra come sono stati connessi sia il pcf8574 che l’RTC Ds3231. In realtà questo è uno schema esemplificativo in quanto sia per L’RTC che per Il PCF sono stati utilizzati dispositivi già premontati: sono dispositivi di facile installazione e utilizzano il protocolo I2C. Nello schema era stato previsto anche un ulteriore PCF8574 per la visualizzazione dei secondi in modo binario utilizzando 7 bit. Per non complicare ulteriormente il sistema ho preferito poi usare 2 led con lampeggio alternativo. Nello schema sono visibili anche le connessioni scelte per i pin di Arduino a cui connettere pulsanti e trimmer.

    PCB di ogni quadrante:

    Questo è il pcb definitivo valido per ogni quadrante. Ne avevo realizzato uno più piccolo ma in pratica con i led da 5mm risultava problematica la connessione in quanto troppo vicini tra loro. Putroppo da come potete vedere nella prima foto complessiva del progetto, la precisione non brilla.

    LAYOUT DI OGNI QUADRANTE:

    A titolo di esemplificazione ogni quadrante ha la seguente disposizione e numerazione logica di ogni led che lo compone. La tacca di ogni led identifica il pin DATA_OUT

     

    PCB del pannello di controllo:

    Questo pannello alloggia: il trimmer per la regolazione della luminosità, i 2 pulsanti per l’aggiornamento dei valori ORA e MINUTI, il pulsanti di START del sistema, il pulsante di RESET, il ponticello che a seconda di come viene impostato permette l’aggiornamento in più o in meno dei valori ORA e MINUTI quando devono essere aggiornati, infine l’alloggiamento del dip_swtich per il cambio dei colori ai quadranti.

    PCB MAIN:

    Questo è il pcb definito “MAIN” in quanto alloggia il micro Arduino_Nano, i vari connettori per i dispositivi I2C e per il pannello di controllo. E’ stato previsto anche un ingresso separato per l’alimentazione dei quadranti (previsto ma poi non utilizzato). L’USB del  micro provvede all’alimentazione del resto del circuito.

    PCB BUS_QUADRI e LED_SECONDS

    Questi due ultimi pcb sono di supporto: BUS_QUADRI consente il collegamento dei 4 quadranti verso il pcb MAIN con il segnale di ingresso e l’alimentazione ciascuno. LED_SECONDS alloggia i due led che devono lampeggiare al ritmo di un secondo. Questo PCB è situato tre i due quadranti delle ore e i due dei minuti; l’alimentazione e il segnale vengono connessi tramite il BUS_QUADRI.

     

    COSTRUZIONE DELL’OROLOGIO

    Nella foto sottostante si può notare come è stato costruito l’alloggiamento dei quadranti:

    Con un telaio di 28cm con base in legno e laterali in plexiglass sono stati incollati i 4 quadranti come da foto: nel centro i due led per i secondi e a destra il pcb BUS_QUADRI per le connessioni al main. Dato che i led anche la minimo della luminosità sono comunque molto luminosi, per evitare che la luminosità dei singoli led possa coprire quella laterale destra e sinistra, ogni quadrante viene “coperto” da una mascherina nera (plastificata) per evidenziare i singoli segmenti. Ogni segmento è stato avvolto con una striscia di cartoncino nero.  Ecco come si presena a “nudo”.:

    Con questo sistema si ottiene una buona visualizzazione “separata” dell’intero orologio senza che la luminosità di un quadrante non interferisca con quella laterale. (Si ricordi che i colori Red,Green, Blu hanno comunque una luminosità diversa l’uno dall’altro).

    IL CUORE DEL SISTEMA:

    Nella foto sottostante l’immagine del pannello di controllo che chiude una scatoletta in plexiglass dove è alloggiato il micro Arduino_Nano, RTC e il PCf8574 e i connettori verso i quadranti. Il pannello è composto dal trimmer (10K) per la regolazione della luminosità, dai pulsanti per l’aggiornamento delle ORE e dei Minuti. il pulsante di START e il RESET, infine il ponticello per l’aggiornamento un positivo o negativo dei valori del tempo. Sul lato destro il DIP_SWITCH e l’array delle resistenze di pull_up.

     

    L’ IMPLEMENTAZIONE DEL SOFTWARE

    Se non mi complico la vita non sono soddisfatto: gestire un orologio non è assolutamente difficile se proprio non si è alle prime armi. Avrei potuto fare uno sketch molto semplice limitandomi alla lettura dell’ RTC la decodifica dei valori e l’esposizione sui quadranti.

    Ma poi siccome “l’appetito vien mangiando”  ho implementato uno sketch che prevede:

    • Gestione dei 4 quadranti tramite la libreria ADAFRUIT_NEOPIXEL.
    • Gestione dell’ RTC con aggiornamento dei valori quando necessario. (che se rispetto al DS1307 è più preciso, ogni tanto va aggiornato se non altro per l’ora legale/solare).
    • Gestione della luminosità per variare in un range di 8 valori da un limite minimo ad un massimo (anche se non è il massimo sopportabile) tramite un trimmer con lettura analogica.
    • Gestione dei colori dei singoli quadranti: ognuno può avere un colore diverso dal precedente e dal successivo: tramite un DIP_SWITCH si può selezionare uno dei 4 colori definiti: ROSSO, VERDE, BLU, ROSA. Ho scelto questi colori in quanto sono quelli che “consumano meno corrente”.

    FILOSOFIA DI GESTIONE:

    Come ho già specificato per evitare problemi di connessione o malfunzionamenti vari, ho deciso di gestire i 4 quadranti singolarmente (quindi solo 28 led per quadrante). Ho definito allora 4 istanze della libreria ADAFRUIT_NEOPIXEL per avere la gestione separata di ciascun quadrante. Questo ha comportato sicuramente una complicazione in quanto lo sketch deve provvedere a gestire singolarmente le accensioni e lo spegnimento dei singoli quadranti per le ore e per i minuti. 

    All’ atto dell’avvio dello sketch dopo le inizializzazioni della libreria occorre effettuare SUBITO lo spegnimento dei singoli quadranti: questi si accendono con colori casuali e alla massima luminosità. Per spegnere occorre inviare a ciascuna catena il colore ZERO: in pratica il nero. Una alternativa potrebbe essere portare la luminosità = a zero.

    Lo sketch prosegue con l’avvio del protocollo WIRE per la gestione dei dispositivi I2C, con la lettura del DIP_SWITCH per determinare i colori, con la lettura del trimmer per la luminosità, quindi inizia la lettura dei valori orari dell’ RTC e effettua subito una visualizzazione delle ore e dei minuti nei rispettivi 4 quadranti. Si pone quindi in attesa della lettura di uno dei pulsanti del pannello di controllo. Se viene premuto il pulsante delle ore aggiorna il valore relativo in più o in meno in funzione della posizione del ponticello “+/-“.  E visualizza subito il valore modificato. Lo stesso avviene per i valori dei minuti se viene premuto il relativo pulsante. La pressione del pulsante “START” innesca il ciclo finale dello sketch: se ci sono stati degli aggiornamenti questi vengono ricaricati nell’ RTC.  Il ciclo perenne legge la posizione del trimmer per variare la luminosità e del Dip_Swtich per i colori effettuando le variazioni del caso. Vengono letti quindi i valori orari dell’ RTC e soltanto se sono variati ne effettua la visualizzazione.

    ASSEGNAZIONE PIN ARDUINO:

    La sottostante tabella deifinisce come sono stati assegnati i pin di Arduino:

    PIN

    ASSEGNAZIONE

    A0

    Input analogico per trimmer luminosità

    PIN 2

    DataIn quadrante 1

    PIN 3

    DataIn quadrante 2

    PIN 4

    DataIn quadrante 3

    PIN 5

    DataIn quadrante 4

    PIN 6

    Pulsante ORE (Pull_Up)

    PIN 7

    Pulsante MINUTI (Pull_Up)

    Pin 8

    Pulsante START (Pull_Up)

    Pin 9

    Switch +/- (Pull_Up)

    PIN 10

    Lampeggio led secondi

    PIN A4

    SDA per RTC e DS3231

    PIN A5

    SCL per RTC e DS3231

     

    LA LIBRERIA ADAFRUIT_NEOPIXEL:

    Scaricata dall’omonimo sito (esistono due versioni una più aggiornata ed un altra che gestisce i NEO_PIXEL RING e le matrici Neo_Pixel) questa libreria con poche funzioni è in grado di gestire un numero quasi illimitato di led WS2812. Le principali funzioni possono essere riassunte come segue:

    Per prima cosa occorre istanziare l’oggetto con i seguenti parametri:

    Adafruit_NeoPixel pixels = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800);

    dove: pixels è il nome dato all’istanza,  NUMPIXELS il numero dei led connessi (il primo della catena si identifica con l’offset “ZERO” e in totale sono 28 per quadrante), PIN indentifica il pin digitale di Arduino per connettere il primo DATA_IN del led di ogni catena. (Vedi tabella precednte).  NEO_RGB + NEO_KHZ800 indica che la sequenza dei colori del led sono nel formato R-G-B e la frequenza in 800Hkz. Da alcuni esempi scaricati quest’ultimo valore è pressochè standard. E’ possibile istanziare più oggetti dando a ciascun un nome diverso (ovviamente). Queste definizioni vanno inserite nella sezione variabili.

    Nella sezione SETUP occorre per ogni istanza inizializzare la libreria con: nome_istanza.begin(). Nello sketch ci sono quindi 4 di queste frasi.

    Le successive funzioni effettuano la gestione effettiva di ciascuna istanza (e relativa catena associata). La luminosità viene gestita con al funzione: nome_istanza.setBrightness(valore) e viene applicata all’intera catena dei led.

    L’accensione di ogni led di una catena (ricodiamoci sono 28 per catena) avviene indicando sia la posizione del led (il suo offset partendo da zero) che il colore da assegnare. Ne deriva che per ogni led della catena è possibile assegnare un colore diverso. La funzione ha due formati:

    nome_istanza.setPixelColor(Led_Offset,nome_istanza.Color(r,g,b));  con questo si devolve alla libreria la codifica del colore secondo i valori definiti in r1,g1,b1 (da o a 255), in alternativa il secondi formato definisce direttamene il codice colore (32 bit unsigned): nome_istanza.setPixelColor(Led_Offset,codice_colore).

    Nello sketch viene effettuato un ciclo di 28 iterazioni per assegnare e quindi accendere un segmento della catena dei led di ogni quadrante.

    Tutto ciò non porterebbe a nessun risultato se non venisse eseguita la funzione: nome_instanza.show(). Questa funzione deve essere sempre eseguita se vogliamo vedere accendere o spegnere i led o modificarne la luminosità.

    C’è una riflessione da fare circa l’uso di quest’ultima funzione: se si tratta di accendere/spegnere un solo led o variarne la luminosità dopo la funzione specifica, è sufficiente lanciare la funzione show() per eseguire quanto programmato. Se però (nel caso specifico) i led da accendere/spegnere sono più di uno si possono utilizzare due tecniche: nel ciclo eseguire la funzione specifica di accensione/spegnimento  e alla fine del ciclo eseguire la funzione show() oppure durante lo stesso ciclo eseguire di seguito la funzione show().

    Ecco un esempio (tratto allo sketch). La routine che spegne i led: NQ il numero della catena da 1 a 4 in quanto è la routine prevede lo spegimento di un solo quadrante o di tutti (NQ = 0).

    void Spegnimento(byte NQ)
    { int kl;
      if (NQ == 0 || NQ == 1)
       { for (kl = 0; kl < NUMPIXELS; kl++) QDR_DEC_ORE.setPixelColor(kl,0);
        QDR_DEC_ORE.show(); }

    In questo caso la funzione show() viene eseguita alla fine del ciclo for.

    In questo esempio la lumimosità viene modificata soltanto se dopo viene eseguita la funzione show():

    QDR_DEC_ORE.setBrightness(Lumen_Value);
    QDR_DEC_ORE.show();

    Un’altra funzione della libreria permette di rilevare il colore assegnato al led: ritorna il codice del colore nel formato  32 bit unsigned: nome_istanza.getPixelColor(Led_Offset).

     

    CONCLUSIONE:

    Spero di aver sufficentemente esposto questo progetto che dal mese di  marzo ad oggi ha occupato quel poco di tempo libero a disposizione. Di solito non dedico più di 2 ore al giorno a questo hobby: ho una certa esperienza in programmazione per cui è difficile che abbia problemi si programmazione. Sto pensando ad un upgrandig del progetto: inserire anche la visualizzazione della temperatura visto che il DS3231 alloggia anche il sensore e la modifica casuale dei colori. Vedremo….

    Ringrazio comunque tutti gli ElettroAmici per il tempo che hanno dedicato a leggere questo articolo. So di essere ripetitivo…..questo è l’ennesimo orologio. In ogni caso sono a disposizione per chi volesse documentazione o altro in merito a questo progetto.

    Grazie

    Gvsoft Gugno 2019

    gvsoft75@hotmail.com

  • Allegria ! l’orologiaio matto è tornato !!

    Allegria ! l’orologiaio matto è tornato !!

    Il titolo è volutamente provocatorio perchè sarebbe dovuto essere:

    I DISPLAY A MATRICE: TECNICHE HW E SW PER L’UTILIZZO

    Questo in quanto ciò che mi accingo a descrivere sono i display a matrice 8×8 (o 7×5 o 8×5) cercando di approfondire i metodi sia hardware che software per il loro utilizzo. Per questo ho prodotto alcuni prototipi (rimasti tali allo stato dell’arte) di orologi digitali che utilizzano proprio queste matrici. Premetto che le caratteristiche HW sono pressochè identiche (cambia solo la piedinatura) sia ad ANODO COMUNE che a CATODO COMUNE.  Quindi prima di entrare specificatamente nell’ argomento qualche video per mostrare alcuni di questi prototipi. (altro…)

  • L’ennesimo orologio calendario

    L’ennesimo orologio calendario

    Eccomi di nuovo con un ennesimo orologio calendario…..è una provocazione fatta dall’ ElettroAmico Marcello che nel suo commento al mio articolo del novembre scorso terminava: ” in attesa del prossimo orologio”. Beh ho cercato di accontentarLo e questo è il risultato. (altro…)

  • ARROW GAME CONSOLLE

    ARROW GAME CONSOLLE

     

    Eccolo qui il giocattolo di Natale per gli amanti del gioco delle freccette….

    Tutto nasce da una scommessa con mio figlio: papà invece di fare sempre orologi, perchè non mi fai un totalizzatore punti per il gioco delle freccette ????. (così mi fai risparmiare un pò di soldini per non comprarne uno già fatto !!). (altro…)

  • BINARY_COLOR_CLOCK (e altri orologi)

    BINARY_COLOR_CLOCK (e altri orologi)

    Eccomi con un nuovo “orologio”: qualcuno dirà che sono fissato (meglio: maniaco) perchè ormai di orologi elettronici ne ho fatti diversi ognuno con stili e caratteristiche diverse. (altro…)

  • NANO TIMER

    NANO TIMER

    [av_section min_height=” min_height_px=’500px’ padding=’default’ shadow=’no-shadow’ bottom_border=’no-border-styling’ bottom_border_diagonal_color=’#333333′ bottom_border_diagonal_direction=’scroll’ bottom_border_style=’scroll’ scroll_down=” id=” color=’main_color’ custom_bg=” src=” attach=’scroll’ position=’top left’ repeat=’no-repeat’ video=” video_ratio=’16:9′ video_mobile_disabled=” overlay_enable=” overlay_opacity=’0.5′ overlay_color=” overlay_pattern=” overlay_custom_pattern=” av-desktop-hide=” av-medium-hide=” av-small-hide=” av-mini-hide=” av_element_hidden_in_editor=’0′]
    [av_one_full first min_height=” vertical_alignment=” space=” custom_margin=” margin=’0px’ padding=’0px’ border=” border_color=” radius=’0px’ background_color=” src=” background_position=’top left’ background_repeat=’no-repeat’ animation=” mobile_breaking=” mobile_display=”]

    [av_textblock size=” font_color=’custom’ color=’#0015ff’ av-medium-font-size=” av-small-font-size=” av-mini-font-size=” admin_preview_bg=”]

    NANO TIMER

    Timer da 1 secondo a 199 ore

    PREMESSA:

    Sono sempre alla ricerca di nuovi dispositivi da provare e sperimentare onde accrescere le mie conoscenze ed esperienze. Così ravanando nel WEB scopro una allettante offerta di 5 board ARDUINO NANO per 15 euro spedizione compresa. Dopo una veloce ricerca per approfondire in cosa consistenva l’offerta, faccio partire l’ordine e dopo 24 ore mi ritrovavo con queste board pronte all’uso. (altro…)