Orologio da 132 pixel: 5 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Da che ho memoria, sono stato ossessionato dai LED e dal tempo. In questo progetto ho creato un grande orologio da parete che visualizza l'ora corrente utilizzando 132 LED neopixel montati e che brillano attraverso una tavola di abete. È un ibrido analogico digitale con un singolo pixel per ogni ora, minuto e secondo.

Questo è stato il progetto più grande che ho intrapreso fino ad oggi, ho iniziato a pensarci 6 mesi fa e l'idea piano piano è venuta fuori. Sono davvero felice del risultato e non vedo l'ora di condividerlo con voi.

Passaggio 1: raccolta di materiali e strumenti

Componenti

Questo progetto è costruito su una tavola per hobby economica dal mio negozio di bricolage locale. La tavola misura 850 mm di larghezza per 500 mm di altezza e 18 mm di profondità.

I LED utilizzati in questo progetto sono 5050 WS2812b montati su PCB circolari di circa 9 mm di diametro con pad di saldatura sul retro.

Sto usando un micro controller compatibile con Arduino Pro Mini. È la versione 5V 16 MHZ. Ho scelto questo perché ha un design super sottile, un ingombro ridotto e tutte le porte necessarie più alcune di riserva per aggiornamenti futuri. È anche a 5 volt, quindi posso usare un singolo alimentatore per i LED, il micro controller e l'RTC

Il cronometraggio è gestito da un modulo RTC (Real Time Clock) che integra il chip DS3231. Questo chip è molto preciso, quindi il tempo non dovrebbe spostarsi troppo.

Utilizzato anche:

Filo. Saldatura e colla a caldo.

Utensili:

Trapano elettrico e punte per legno (10 mm e 5 mm)

Saldatore

Pistola per colla a caldo

tagli di filo

Dremel e accessori per fresa a tuffo

Passaggio 2: marcatura, foratura e fresatura

foratura

• Usando un bordo stretto, trova il centro del tabellone disegnando una linea dagli angoli opposti.
• Segna 3 cerchi usando un pezzo di spago e una penna. Il cerchio più esterno dovrebbe essere a circa 20 mm dal bordo del tabellone con le altre 2 linee che si muovono di 15 mm dall'ultima linea.
• Ho usato un quadrante di orologio stampato per aiutarmi a segnare le posizioni di ciascuno dei minuti e dei secondi sulle 2 linee esterne e delle ore sulla linea interna.
• Praticare fori da 10 mm di circa 5 mm di profondità per ogni ora, minuto e secondo.
• Usa il trapano da 5 mm per praticare fori sulla tavola per ore, minuti e secondi.

Instradamento

Sebbene questo passaggio non sia necessario, consentirà il montaggio dell'orologio a filo muro.

• Utilizzando un router e una guida circolare instradare i canali dei cavi nella scheda
• Tracciare e instradare una rientranza in cui far vivere l'RTC e il microcontrollore.
• Instradare un canale dalle linee esterne alla rientranza per i cavi

Passaggio 3: così tanto soldato, taglio e spogliatura

Questa parte successiva è molto più facile da dire che da fare. Il mio consiglio è di fare in fretta. cercare di trovare un sistema e entrare in un ritmo.

Ciascuno dei LED necessita di 5 volt in ingresso, 5 volt in uscita, ingresso dati, uscita dati, ingresso massa e uscita massa. compresa l'alimentazione per il microcontrollore e l'RTC, i suoi oltre 400 fili, tutti spellati e saldati ad entrambe le estremità.

Una sostanza blu appiccicosa è molto utile per questo passaggio.

• Ho iniziato posizionando 2 LED nei loro fori uno accanto all'altro per calcolare la lunghezza del cavo necessaria per collegarsi tra loro.
• Usando il primo pezzo di filo come guida, ho quindi tagliato 60 fili di ogni colore.
• Spellare 2 mm di guaina dalle estremità di ciascun filo e saldarli con la saldatura.
• Saldare un piccolo blob di saldatura su ciascuno dei pad LED.
• Saldare i fili ai LED per formare due catene da 60 per i minuti ei secondi e una catena da 12 per le ore. Ho usato il filo rosso per 5V, giallo per i dati e blu per la terra.
• Abbiate cura di collegare ogni Data Out (DOUT) al Data In (DIN) del LED successivo
• L'ultimo led in ogni dose di catena non necessita di un cavo di uscita dati.

Una volta completate tutte le catene, è una buona idea testarle prima di installarle. Ho usato il mio Arduino UNO e l'Adafruit NeoPixel Strand Test per confermare che ogni LED funzionava.

Saldare fili più lunghi su ciascuna delle catene per 5 V, terra e ingresso dati.

A questo punto dovrebbero esserci cinque fili 5v, tre fili dati collegati all'Arduino Pro Mini e 5 fili di terra.

Spelare 5 mm dalle estremità dei fili 5v e saldarli tutti insieme e ripetere per i fili di terra.

Dopo aver completato le tre catene, saldare un filo da 5 V sul pin RAW dell'Arduino Pro Mini e anche sul pin VCC per l'RTC. Un filo di terra a GND su Arduino Pro Mini e RTC e poi altri 2 fili:

SCL da RTC a A5 su Pro Mini

SDA da RTC a A4 su Pro Mini

Le linee dati dei LED dovrebbero collegarsi a:

• Secondi - Pin digitale 3.
• Minuti - DigitalPin 4
• Ore - DigitalPin 5

Passaggio 4: installazione

Una volta saldati, l'installazione dei LED nei loro fori dovrebbe essere semplice. I LED devono essere installati in modo che i dati scorrano in senso antiorario quando li si guarda dal retro poiché il codice è impostato frontalmente.

Ho usato una piccola quantità di colla a caldo per tenerli premuti perché voglio essere in grado di sostituire un singolo LED se si guasta in futuro.

Ho anche usato la colla a caldo per mantenere tutti i fili puliti e in ordine e per fissare il connettore cilindrico alla scheda.

Sono disponibili una serie di mini guide di programmazione arduino pro. Uso il metodo di conversione da USB a seriale esterno per caricare questo codice su Arduino:

Questo codice imposterà anche l'ora sull'RTC all'ora in cui è stata compilata. quindi è importante chiudere semplicemente il pulsante di caricamento in modo che sia conforme e si carichi il più rapidamente possibile.

Gran parte di questo codice è stato preso in prestito dal NeoPixel Ring Clock di Andy Doro. Alcuni dall'Adafruit NeoPixel Strand Test e alcuni che ho messo insieme.

Dovrai aver installato alcune librerie. Sono disponibili dal Libraries Manager sul software Arduino.

L'Adafruit NeoPixel per i LED ws2812b

Cavo per parlare con l'RTC su I2C (questo è integrato come standard)

e RTClib per sapere cosa chiedere all'RTC

/************************************************** ************************* * * Orologio ad anello NeoPixel di Andy Doro ([email protected]) https://andydoro.com/ringclock/ * * ********************************************** *************************

Cronologia delle revisioni

Data da cosa?

20140320 AFD Prima bozza 20160105 AFD Faded arcs 20160916 AFD Trinket compatibile 20170727 AFD aggiunto STARTPIXEL per custodia 3D, punto di partenza variabile, aggiunto supporto automatico DST 20180424 AFD utilizzando la libreria DST https://github.com/andydoro/DST_RTC *

/ includi il codice della libreria:

#include #include

#includere

// definisce i pin

#define SECPIN 3 #define MINPIN 4 #define HOUPIN 5

#define BRIGHTNESS 20 // imposta la luminosità massima

#definire r 10

#define g 10 #define b 10 RTC_DS3231 rtc; // Stabilire l'oggetto orologio

Striscia Adafruit_NeoPixelS = Adafruit_NeoPixel(60, SECPIN, NEO_GRB + NEO_KHZ800); // striscia oggetto

Striscia Adafruit_NeoPixelM = Adafruit_NeoPixel(60, MINPIN, NEO_GRB + NEO_KHZ800); // strip oggetto Adafruit_NeoPixel stripH = Adafruit_NeoPixel(24, HOUPIN, NEO_GRB + NEO_KHZ800); // elimina il byte dell'oggetto pixelColorRed, pixelColorGreen, pixelColorBlue; // contiene i valori del colore

void setup() {

Wire.begin(); // Inizia I2C rtc.begin(); // inizia l'orologio

Serial.begin(9600);

// imposta le modalità pin pinMode(SECPIN, OUTPUT); pinMode(MINPIN, OUTPUT); pinMode(HOUPIN, OUTPUT);

if (rtc.lostPower()) {

Serial.println("RTC ha perso potenza, impostiamo l'ora!"); // la riga seguente imposta l'RTC sulla data e l'ora in cui questo sketch è stato compilato rtc.adjust(DateTime(F(_DATE_), F(_TIME_))); // Questa riga imposta l'RTC con una data e un'ora esplicite, ad esempio per impostare // 21 gennaio 2014 alle 3 del mattino che chiameresti: // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0)); }

stripS.begin();

stripM.begin(); stripH.begin(); //striscia.mostra(); // Inizializza tutti i pixel su 'off'

// sequenza di avvio

ritardo (500);

colorWipeS(stripS. Color(0, g, 0), 5); // Blue colorWipeM(stripM. Color(r, 0, 0), 5); // Blue colorWipeH(stripH. Color(0, 0, b), 50); // Blu

ritardo(1000);

DateTime theTime = rtc.now(); // tiene conto del byte DST secondval = theTime.second(); // ottiene secondi byte minuteval = theTime.minute(); // ottieni minuti int hourval = theTime.hour(); valore orario = valore orario % 12; // Questo orologio è di 12 ore, se 13-23, converti in 0-11`

for (uint16_t i = 0; i < secondval; i++) { stripS.setPixelColor(i, 0, 0, b); stripS.show(); ritardo(5); }

for (uint16_t i = 0; i < minuteval; i++) { stripM.setPixelColor(i, 0, g, 0); stripM.show(); ritardo(5); }

for (uint16_t i = 0; i < hourval; i++) { stripH.setPixelColor(i, r, 0, 0); stripH.show(); ritardo(5); }

}

ciclo vuoto () {

// prendi tempo

DateTime theTime = rtc.now(); // tiene conto dell'ora legale

byte secondval = theTime.second(); // ottieni secondi

byte minuteval = theTime.minute(); // ottieni minuti int hourval = theTime.hour(); // ottieni ore valore orario = valore orario % 12; // Questo orologio è di 12 ore, se 13-23, converti in 0-11`

stripS.setPixelColor(secondval, 0, 0, 20); stripS.show(); ritardo(10); if (secondval ==59) { for (uint8_t i = stripS.numPixels(); i > 0; i--) { stripS.setPixelColor(i, 0, g, 0); stripS.show(); ritardo(16);} }

stripM.setPixelColor(valoreminuto, 0, g, 0);

stripM.show(); ritardo(10); if (secondval ==59 && minuteval == 59) { for (uint8_t i = stripM.numPixels(); i > 0; i--) { stripM.setPixelColor(i, r, 0, 0); stripM.show(); ritardo(16);} }

stripH.setPixelColor(hourval, r, 0, 0);

stripH.show(); ritardo(10); if (secondval == 59 && minuteval == 59 && hourval == 11) { for (uint8_t i = stripH.numPixels(); i > 0; i--) { stripH.setPixelColor(i, 0, 0, b); stripH.show(); delay(83);} } // per il debug seriale Serial.print(hourval, DEC); Serial.print(':'); Serial.print(minuteval, DEC); Serial.print(':'); Serial.println(secondval, DEC); }

// Riempi i punti uno dopo l'altro con un colore

void colorWipeS(uint32_t c, uint8_t wait) { for (uint16_t i = 0; i < stripS.numPixels(); i++) { stripS.setPixelColor(i, c); stripS.show(); ritardo (attesa); } }

void colorWipeM(uint32_t c, uint8_t aspetta) {

for (uint16_t i = 0; i < stripM.numPixels(); i++) { stripM.setPixelColor(i, c); stripM.show(); ritardo (attesa); } }

void colorWipeH(uint32_t c, uint8_t aspetta) {

for (uint16_t i = 0; i < stripH.numPixels(); i++) { stripH.setPixelColor(i, c); stripH.show(); ritardo (attesa); } }

Passaggio 5: ritocchi finali

Tutto ciò che dovrebbe essere lasciato ora è fissare l'RTC e il micro controller nella rientranza.

Ho montato la batteria dell'RTC con il lato rivolto verso l'alto in modo da poter cambiare facilmente la batteria se necessario.

Collegare i fili 5v al lato + del connettore e la massa al lato -

Accendilo!

Ho il mio collegato a un banco di batterie USB, ma un caricabatterie per telefono USB funzionerebbe altrettanto bene.

Nota:

La luminosità dei LED è impostata nel codice. È stato impostato su un valore basso per mantenere basso l'assorbimento di corrente. A piena luminosità con tutti i LED accesi potrebbe assorbire quasi 8 ampere. Con la configurazione attuale è inferiore a 1.

Secondo classificato al concorso degli orologi