Ceas 132 pixeli: 5 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

De cât timp îmi amintesc, am fost obsedat de LED-uri și de timp. În acest proiect am creat un ceas de perete mare care afișează ora curentă folosind 132 de LED-uri neopixel montate și strălucitoare printr-o placă de molid. Este un digital analog hibrid cu un pixel individual pentru fiecare oră, minut și secundă.

Acesta a fost cel mai mare proiect pe care l-am luat până acum, am început să mă gândesc la el acum 6 luni și ideea s-a reunit încet. Sunt foarte fericit cu rezultatul și aștept cu nerăbdare să vi-l împărtășesc.

Etapa 1: Colectarea consumabile și instrumente

Componente

Acest proiect este construit pe o placă hobby de la magazinul meu local de bricolaj. Placa măsoară 850 mm lățime pe 500 mm înălțime și 18 mm adâncime.

LED-urile utilizate în acest proiect sunt 5050 WS2812b montate pe PCB-uri circulare cu diametrul de aproximativ 9 mm, cu tampoane de lipit în spate.

Folosesc un microcontroler compatibil Arduino Pro Mini. Sale de 5V 16 versiunea MHZ. Am ales-o pe aceasta, deoarece are un design foarte subțire, amprentă mică și toate porturile Nessary, plus unele de rezervă pentru viitoarele actualizări. De asemenea, are 5 volți, astfel încât să pot utiliza o singură sursă de alimentare pentru LED-uri, controler micro și RTC

Păstrarea timpului este asigurată de un modul RTC (Real Time Clock) care dispune de cipul DS3231. Acest cip este foarte precis, astfel încât timpul nu ar trebui să treacă prea mult.

De asemenea, folosit:

Sârmă. Lipire și lipici fierbinte.

Instrumente:

Burghiu electric și burghie pentru lemn (10mm și 5mm)

Ciocan de lipit

Pistol de lipit fierbinte

fragmente de sârmă

Accesorii Dremel și plunge router

Pasul 2: Marcare, găurire și rutare

Foraj

• Folosind o margine strâmtoare, găsiți centrul plăcii trasând o linie din colțurile opuse.
• Marcați 3 cercuri folosind o bucată de șir și un stilou. Cel mai exterior cerc ar trebui să fie la aproximativ 20 mm de marginea plăcii, cu celelalte 2 linii care se deplasează cu 15 mm față de ultima linie.
• Am folosit o față de ceas tipărită pentru a mă ajuta să marcez pozițiile fiecărui minut și secundă pe cele 2 linii externe și pe orele pe linia interioară.
• Găuriți găuri de 10 mm adâncime de aproximativ 5 mm pentru fiecare oră, minut și secundă.
• Utilizați burghiul de 5 mm pentru a face găuri de pe tablă timp de oră, minut și secundă.

Rutare

Deși acest pas nu este necesar, acesta va permite ca ceasul să fie montat la perete.

• Folosind un router și un ghid de cerc, canalele de sârmă de traseu în placă
• Marcați și direcționați o pauză pentru ca RTC și Micro Controller să locuiască.
• Direcționați un canal de la liniile exterioare către locașul pentru fire

Pasul 3: Atâta soldare, tăiere și decupare

Următoarea parte este mult mai ușor de spus decât de făcut. Sfatul meu ar fi notat să-l grăbiți. încercați să găsiți un sistem și să intrați într-un ritm.

Fiecare dintre LED-uri are nevoie de 5 volți de intrare, 5 volți de ieșire, date de intrare, date de ieșire, împământare și ieșire la pământ. inclusiv puterea pentru microcontroler și RTC pentru cele peste 400 de fire, toate dezbrăcate și lipite la ambele capete.

O substanță albastră lipicioasă este foarte utilă pentru acest pas.

• Am început prin plasarea a două LED-uri în găurile lor una lângă cealaltă pentru a calcula lungimea firului necesar pentru conectarea între ele.
• Folosind prima bucată de sârmă ca ghid, am tăiat apoi 60 din fiecare sârmă de culoare.
• Îndepărtați 2 mm de mâneci de la capetele fiecărui fir și tăiați-le cu lipit.
• Lipiți o mică blobă de lipit pe fiecare dintre plăcile LED.
• Lipiți firele pe LED-uri pentru a forma două lanțuri de 60 pentru minute și secunde și un lanț de 12 pentru ore. Am folosit fir roșu pentru 5V, galben pentru date și albastru pentru masă.
• Aveți grijă să conectați fiecare ieșire de date (DOUT) la intrarea de date (DIN) a următorului LED
• Ultimul led din fiecare doză de lanț nu are nevoie de un fir de ieșire a datelor.

Odată ce toate lanțurile sunt finalizate, este o idee bună să le testați înainte de a le instala. Am folosit Arduino UNO și Adafruit NeoPixel Strand Test pentru a confirma că fiecare LED funcționează.

Lipiți fire mai lungi pe fiecare lanț pentru 5V, masă și date de intrare.

În acest moment ar trebui să existe cinci fire de 5V, trei fire de date conectate la Arduino Pro Mini și 5 fire de masă.

Îndepărtați 5 mm de la capetele firelor de 5v și lipiți-le pe toate împreună și repetați pentru firele de la sol.

După finalizarea celor trei lanțuri, lipiți un fir de 5V pe pinul RAW al Arduino Pro Mini și, de asemenea, pe pinul VCC pentru RTC. Un fir de împământare către GND pe Arduino Pro Mini și RTC și apoi încă 2 fire:

SCL de la RTC la A5 pe Pro Mini

SDA de la RTC la A4 pe Pro Mini

Liniile de date de la LED-urile trebuie să se conecteze la:

• Secunde - Pin digital 3.
• Proces-verbal - DigitalPin 4
• Ore - DigitalPin 5

Pasul 4: Instalare

Odată lipite, instalarea LED-urilor în găurile lor ar trebui să fie direct înainte. LED-urile trebuie instalate, astfel încât datele să ruleze în sens invers acelor de ceasornic atunci când le privim din spate, deoarece codul este configurat cu fața către față.

Am folosit o cantitate mică de adeziv fierbinte pentru a-i ține apăsat, deoarece vreau să pot înlocui un singur LED dacă nu va reuși în viitor.

De asemenea, am folosit adeziv fierbinte pentru a menține toate firele îngrijite și ordonate și pentru a fixa conectorul butoiului pe placă.

Există mai multe ghiduri de programare arduino pro mini disponibile. Folosesc metoda USB externă către convertorul serial pentru a încărca acest cod pe Arduino:

Acest cod va seta, de asemenea, ora de pe RTC la ora la care a fost compilat. deci este important să închideți butonul de încărcare, astfel încât să se conformeze și să se încarce cât mai repede posibil.

O mare parte din acest cod a fost împrumutat de la NeoPixel Ring Clock de Andy Doro. Unele de la Adafruit NeoPixel Strand Test și unele le-am pus împreună.

Va trebui să aveți instalate câteva biblioteci. Acestea sunt disponibile de la Libraries Manager pe software-ul Arduino.

Adafruit NeoPixel pentru LED-urile ws2812b

Sârmă pentru a vorbi cu RTC prin I2C (acesta este încorporat standard)

și RTClib pentru că știu ce să întrebe RTC

/ ************************************************** ************************* * * NeoPixel Ring Clock de Andy Doro ([email protected]) https://andydoro.com/ringclock/ * * ************************************************ **************************

Istoricul reviziilor

Data după ce

20140320 AFD Prima schiță 20160105 AFD Arce decolorate 20160916 AFD compatibil cu bibelou 20170727 AFD a adăugat STARTPIXEL pentru carcasă 3D, punct de pornire variabil, a adăugat suport automat DST 20180424 AFD utilizând biblioteca DST https://github.com/andydoro/DST_RTC *

/ include codul bibliotecii:

#include #include

#include

// defineste pinii

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

#define BRIGHTNESS 20 // setează luminozitatea maximă

#define r 10

#define g 10 #define b 10 RTC_DS3231 rtc; // Stabiliți obiectul de ceas

Adafruit_NeoPixel stripS = Adafruit_NeoPixel (60, SECPIN, NEO_GRB + NEO_KHZ800); // obiectul strip

Adafruit_NeoPixel stripM = Adafruit_NeoPixel (60, MINPIN, NEO_GRB + NEO_KHZ800); // obiect strip Adafruit_NeoPixel stripH = Adafruit_NeoPixel (24, HOUPIN, NEO_GRB + NEO_KHZ800); // octeț de bandă pixelColorRed, pixelColorGreen, pixelColorBlue; // deține valori de culoare

configurare nulă () {

Wire.begin (); // Începeți I2C rtc.begin (); // începe ceasul

Serial.begin (9600);

// set pinmodes pinMode (SECPIN, OUTPUT); pinMode (MINPIN, OUTPUT); pinMode (HOUPIN, OUTPUT);

if (rtc.lostPower ()) {

Serial.println ("RTC a pierdut puterea, permite să setăm ora!"); // următoarea linie setează RTC la data și ora la care a fost compilată această schiță rtc.adjust (DateTime (F (_ DATE_), F (_ TIME_)))); // Această linie setează RTC-ul cu o dată și o oră explicite, de exemplu pentru a seta // 21 ianuarie 2014 la ora 03:00 sunați: // rtc.adjust (DateTime (2014, 1, 21, 3, 0, 0)); }

stripS.begin ();

stripM.begin (); stripH.begin (); //strip.show (); // Inițializați toți pixelii la „dezactivat”

// secvența de pornire

întârziere (500);

colorWipeS (stripS. Color (0, g, 0), 5); // Blue colorWipeM (stripM. Color (r, 0, 0), 5); // Culoare albastră Ștergeți H (stripH. Color (0, 0, b), 50); // Albastru

întârziere (1000);

DateTime theTime = rtc.now (); // ia în calcul octetul DST secondval = theTime.second (); // obține secunde octet minuteval = theTime.minute (); // get minutes int hourval = theTime.hour (); hourval = hourval% 12; // Acest ceas are 12 ore, dacă este 13-23, convertiți la 0-11`

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

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

pentru (uint16_t i = 0; i <hourval; i ++) {stripH.setPixelColor (i, r, 0, 0); stripH.show (); întârziere (5); }

}

bucla nulă () {

// Fă-ți timp

DateTime theTime = rtc.now (); // ia în calcul DST

octet secondval = theTime.second (); // obține secunde

byte minuteval = theTime.minute (); // get minutes int hourval = theTime.hour (); // obține ore hourval = hourval% 12; // Acest ceas are 12 ore, dacă este 13-23, convertiți la 0-11`

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

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

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

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

stripH.show (); întârziere (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);}} // pentru depanare serială Serial.print (hourval, DEC); Serial.print (':'); Serial.print (minuteval, DEC); Serial.print (':'); Serial.println (secondval, DEC); }

// Umpleți punctele unul după altul cu o culoare

void colorWipeS (uint32_t c, uint8_t wait) {for (uint16_t i = 0; i <stripS.numPixels (); i ++) {stripS.setPixelColor (i, c); stripS.show (); întârziere (așteptați); }}

void colorWipeM (uint32_t c, uint8_t așteptați) {

pentru (uint16_t i = 0; i <stripM.numPixels (); i ++) {stripM.setPixelColor (i, c); stripM.show (); întârziere (așteptați); }}

void colorWipeH (uint32_t c, uint8_t așteptați) {

pentru (uint16_t i = 0; i <stripH.numPixels (); i ++) {stripH.setPixelColor (i, c); stripH.show (); întârziere (așteptați); }}

Pasul 5: Atingeri finale

Tot ce ar trebui să rămână acum este să fixați RTC și Micro Controller jos în spațiu.

Am montat bateria RTC cu fața în sus, astfel încât să pot schimba cu ușurință bateria, dacă este necesar.

Conectați firele de 5v la partea + a conectorului și la masă la - partea

Porniți-l!

Am conectat-o la o baterie de baterii USB, dar un încărcător de telefon USB ar funcționa la fel de bine.

Notă:

Luminozitatea LED-urilor este setată în cod. A fost setat la un nivel scăzut pentru a menține extragerea curentă scăzută. La luminozitate maximă, cu toate LED-urile aprinse, ar putea atrage aproape 8 amperi. Cu configurația actuală de mai puțin de 1.

Locul doi în concursul de ceasuri