Orologio binario con pannello RGB

Nei nostri Post di blog dal 17 giugno, abbiamo già istituito un orologio in tempo reale con il nostro Nano V3Collegato.

Alcuni clienti hanno replicato questo e aveva essenzialmente 2 domande:

1. Come faccio a far lampeggiare i due punti?

2. Come si dovrebbe trasformare qualcosa di simile in un orologio binario?

Vorrei rispondere a entrambe le domande nel nostro post sul blog di oggi.

Per la visualizzazione binaria, io uso il popolare Pannello LED U-64 A-Derlivery con 64 LED RGB WS2812b. 

In caso contrario, abbiamo bisogno di un condensatore (1000 micron) e un resistore (220 x)

Come sempre quando lavoriamo con i LED WS2812b: questi sono molto luminosi, ma anche disegnano molta potenza. Uno dei 64 LED può tirare fino a 50mA a piena luminosità. Tuttavia, il nano può fornire un massimo di 200mA. Quindi, se non azionate il pannello a bassa luminosità o con un alimentatore esterno, rischiate la vostra salute e quella degli altri esseri umani. 

Prendiamo il circuito dal post menzionato all'inizio, ed espanderlo. DIN sul pannello RGB è collegato al 220- Resistenza del perno D6 dell'Arduino.

Per l'alimentatore vi consiglio un alimentatore 5V con 5A. Vir collega il palo più dell'alimentazione al perno da 5V del pannello e il polo meno dell'alimentazione al perno GND del pannello. Poi collegiamo i perni 5V e GND del pannello con il condensatore 1000-F (nota polarità!).

Affinché il pannello funzioni, dobbiamo ancora collegare il perno GND al perno GND dell'Arduino sul pannello.

Ora è un buon momento per verificare se l'orologio e il display sono ancora in corso.

Se tutto funziona come desiderato e nessun tormento magico sorge, abbiamo fatto tutto bene.

Poi arriva lo Sketsch. A tal fine, ho esteso lo schizzo dal post del blog menzionato in precedenza:

c!p/
Orologio binario con modulo RTC e matrice LED RGB 8x8
//
Estensione dell'orologio in tempo reale dal post del blog di consegna di A.A 
// https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/echtzeituhr-mit-display-am-nano-v3
//
Utilizza codice modificato da npowley https://codebender.cc/sketch:241472#NeoPixel%20Binary%20Clock.ino
Utilizza codice modificato da http://www.pjrc.com/teensy/td_libs_DS1307RTC.html 
//////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <Arduino.H>

#include <TM1637Schermo.H> per il display a 7 bit
#include <Filo.H> per leggere l'RTC
# define RTC_I2C_ADDRESS 0x68 (in inglese) Indirizzo I2C dell'RTC DS3231
#include <Led veloce.H> per controllare il pannello LED (https://github.com/FastLED/FastLED)
 
# define Clk 2 Arduino Pin D2 come CLK (RTC) 
# define Dio 3 Ardiono Pin D3 come DIO (RTC)
# define NUM_LEDS 64 Numero di LED
# define DATA_PIN 6 Pin dati D6 sul nano per il pannello LED U-64
# define Colore di ora Rosso Colore per ore
# define Colore Minuto Verde Colore per minuti
# define SecondColor (Colore) Blu Colore per secondi
# define HourNeutral Nero Fuori colore per ore
# define MinuteNeutral Nero Colore spento per minuti
# define SecondoNeutrale Nero Colore spento per secondi
# define LEDDimLevel (Livello LED) 8 Reverità dei LED. In alto si prega di non fornire pannello sopra quelli Nano con 5v.

TM1637Schermo Visualizzazione(Clk, Dio); Visualizzazione a 7 segmenti
uint8_t Punti = 0b1000000000; Doppio punk del display a 7 segmenti.

uint8_t bcdToDec( uint8_t Val )
{    Ritorno (uint8_t) ((Val / 16 * 10) + (Val % 16));
}

Int Pausa = 190;
 
Int Ora,minuto,Secondo;

CRGB Led[NUM_LEDS]; Creare un array per il pannello LED

Vuoto Installazione(){   Filo.Iniziare();   Seriale.Iniziare(9600);   Visualizzazione.setLuminosità(0x0a);  luminosità visualizzazione a 7 segmenti   Led veloce.addLed<WS2812B (informazioni in stato in stato inquestoe>, DATA_PIN, Grb>(Led, NUM_LEDS); Riempi matrice pannello LED
}
 
Vuoto Ciclo(){    Filo.beginTransmission(RTC_I2C_ADDRESS); Stabilire la connessione all'indirizzo 0x68    Filo.Scrivere(0);    Filo.endTransmission();    Filo.richiestaDa(RTC_I2C_ADDRESS, 7);      Secondo = bcdToDec(Filo.Leggere() & 0x7f);    minuto = bcdToDec(Filo.Leggere());     Ora = bcdToDec(Filo.Leggere() & 0x3f (in modo 0x3f));           Seriale.Stampare(Ora);      Seriale.Stampare(":");      Seriale.Stampare(minuto);      Seriale.Stampare(":");      Seriale.println(Secondo);      Se ((Secondo % 2) == 0){ Delimitatore di visualizzazione a 7 segmenti ":" attivato o disattivato          Punti = 0b1111111111;      }      Altro {         Punti = 0b0000000000;      }      Visualizzazione.showNumberDecEx(Ora, Punti, Vero, 2, 0);      Visualizzazione.showNumberDec(minuto, Vero, 2, 2);        Led veloce.Chiaro();    Led.setLuminosità(LEDDimLevel (Livello LED));      Se (Ora > 12) { dal formato 24h al formato 12h        Ora = Ora -12;      }      displayHour (Ora di visualizzazione)(Ora); Mostra ora binaria      displayMinute (VisualizzazioneMinute)(minuto); Mostra minuto binario      displaySecondo(Secondo); Mostra secondo binario     Ritardo(Pausa);
}

Vuoto displayHour (Ora di visualizzazione)(Byte Ora){   Per (Int H = 0; H <= 3; H++) contare dal bit più a destra (0) al 4o bit (3)
per (int h - 3; h >   {     Se (bitRead(Ora, H) == 1){ Leggere i singoli bit da destra a sinistra e se c'è un !1!, portare il LED       Led[55 - H] = CRGB::Colore di ora; mostrare il colore definito nella parte superiore di questo schizzo       Led[63 - H] = CRGB::Colore di ora; mostrare il colore definito nella parte superiore di questo schizzo     }     Altro     {       Led[55 - H] = CRGB::HourNeutral; se il LED non viene utilizzato, portarlo verso il basso o in un colore diverso. Vedi la parte superiore del ketch       Led[63 - H] = CRGB::HourNeutral; se il LED non viene utilizzato, portarlo verso il basso o in un colore diverso. Vedi la parte superiore del ketch     }   }   Led veloce.Visualizza(); Mostra i LED
}
 
Vuoto displayMinute (VisualizzazioneMinute)(Byte minuto){   Per (Int M = 0; M <= 5; M++){     Se (bitRead(minuto, M) == 1){       Led[31 - M] = CRGB::Colore Minuto; Iniziare dal primo LED per i minuti (4) e aggiungere il bit minuto       Led[39 - M] = CRGB::Colore Minuto; Iniziare dal primo LED per i minuti (4) e aggiungere il bit minuto     }     Altro     {       Led[31 - M] = CRGB::MinuteNeutral;       Led[39 - M] = CRGB::MinuteNeutral;     }   }   Led veloce.Visualizza();
}
 
Vuoto displaySecondo(Byte Secondo){   Per (Int S (in vi = 0; S (in vi <= 5; S (in vi++){     Se (bitRead(Secondo, S (in vi) == 1){       Led[7 - S (in vi] = CRGB::SecondColor (Colore); Iniziare dal primo LED per i secondi (10) e aggiungere i bit secondi       Led[15 - S (in vi] = CRGB::SecondColor (Colore); Iniziare dal primo LED per i secondi (10) e aggiungere i bit secondi     }     Altro     {       Led[7 - S (in vi] = CRGB::SecondoNeutrale;       Led[15 - S (in vi] = CRGB::SecondoNeutrale;     }   }   Led veloce.Visualizza();
}

Ora, a seconda del tempo corrente, puoi vedere più o meno molti LED colorati, ma il display non sempre facilmente decifrare anche per le persone con esperienza binaria.

Così ho creato un piccolo stencil da stampare. Questo può essere scaricato dal seguente link Dropbox: https://www.dropbox.com/s/nr2kuth73zbqka1/bin%20uhr.svg?dl=0

Come dice il proverbio: "Ci sono 10 tipi di persone. Coloro che capiscono il codice binario e quelli che non lo capiscono."

Pertanto, un orologio binario non dovrebbe mancare da qualsiasi classe di computer.

Certo, c'è ancora del lavoro da fare. Lo schizzo potrebbe ancora essere ottimizzato in alcuni punti. Ad esempio, non mi piace il fatto che i LED RGB sfarfallino ogni volta che passano.

Inoltre, qualcuno voleva un sensore di temperatura, e un servo controllato nel tempo, e un ricevitore DCF, e un cicalino, e uno scanner Larson per i LED inutilizzati, e, e ...

Ma questo dovrebbe essere stato il caso per oggi. 

Attendiamo con ansia i vostri commenti.

Fino al prossimo post da A-Delivery, il tuo esperto di microelettronica!