Reloj de 132 píxeles: 5 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Desde que tengo uso de razón, he estado obsesionado con los LED y el tiempo. En este proyecto, he creado un gran reloj de pared que muestra la hora actual utilizando 132 LED de neopixel montados y brillando a través de un tablero de abeto. Es un digital analógico híbrido con un píxel individual para cada hora, minuto y segundo.

Este fue el proyecto más grande que he emprendido hasta la fecha, comencé a pensar en él hace 6 meses y la idea poco a poco se fue formando. Estoy muy contento con el resultado y espero poder compartirlo con ustedes.

Paso 1: Recopilación de suministros y herramientas

Componentes

Este proyecto se basa en un tablero de pasatiempos barato de mi tienda de bricolaje local. El tablero mide 850 mm de ancho por 500 mm de alto y 18 mm de profundidad.

Los LED utilizados en este proyecto son 5050 WS2812b montados en PCB circulares de aproximadamente 9 mm de diámetro con almohadillas de soldadura en la parte posterior.

Estoy usando un microcontrolador compatible con Arduino Pro Mini. Es la versión de 5V 16 MHZ. Elegí este porque tiene un diseño súper delgado, una huella pequeña y todos los puertos necesarios, además de algunos de repuesto para futuras actualizaciones. También es de 5 voltios, por lo que puedo usar una sola fuente de alimentación para los LED, el microcontrolador y el RTC

El mantenimiento del tiempo está a cargo de un módulo RTC (reloj en tiempo real) que cuenta con el chip DS3231. Este chip es muy preciso, por lo que el tiempo no debería variar demasiado.

También usado:

Cable. Soldadura y pegamento termofusible.

Instrumentos:

Taladro eléctrico y brocas para madera (10 mm y 5 mm)

Soldador

Pistola de silicona

tijeras de alambre

Accesorios para fresadoras de inmersión y Dremel

Paso 2: marcado, taladrado y enrutamiento

Perforación

• Usando un borde recto, encuentre el centro del tablero trazando una línea desde las esquinas opuestas.
• Marca 3 círculos con un trozo de cuerda y un bolígrafo. El círculo más exterior debe estar a unos 20 mm del borde del tablero con las otras 2 líneas moviéndose 15 mm desde la última línea.
• Usé una esfera de reloj impresa para ayudarme a marcar las posiciones de cada uno de los minutos y segundos en las 2 líneas externas y las horas en la línea interna.
• Taladre orificios de 10 mm de aproximadamente 5 mm de profundidad por cada hora, minuto y segundo.
• Utilice el taladro de 5 mm para hacer agujeros en la tabla durante horas, minutos y segundos.

Enrutamiento

Aunque este paso no es necesario, permitirá que el reloj se instale al ras de la pared.

• Usando un enrutador y una guía circular enrute los canales de cable en la placa
• Marque y enrute un receso para que el RTC y el microcontrolador vivan.
• Enrute un canal desde las líneas exteriores hasta el hueco para cables.

Paso 3: mucho soldado, corte y pelado

La siguiente parte es mucho más fácil de decir que de hacer. Mi consejo sería apresurarlo. Intenta encontrar un sistema y ponte en ritmo.

Cada uno de los LED necesita entrada de 5 voltios, salida de 5 voltios, entrada de datos, salida de datos, entrada a tierra y salida a tierra. incluida la alimentación para el microcontrolador y el RTC, sus más de 400 cables, todos pelados y soldados en ambos extremos.

Una sustancia azul pegajosa es muy útil para este paso.

• Comencé colocando 2 LED en sus orificios uno al lado del otro para calcular la longitud del cable necesario para conectarse entre sí.
• Usando el primer trozo de alambre como guía, corté 60 de cada color de alambre.
• Pele 2 mm de funda de los extremos de cada cable y estañe con soldadura.
• Suelde una pequeña gota de soldadura en cada una de las almohadillas LED.
• Suelde los cables a los LED para formar dos cadenas de 60 para los minutos y segundos y una cadena de 12 para las horas. Usé cable rojo para 5V, amarillo para datos y azul para tierra.
• Tenga cuidado de conectar cada salida de datos (DOUT) a la entrada de datos (DIN) del siguiente LED
• El último led de cada dosis de cadena no necesita un cable de salida de datos.

Una vez completadas todas las cadenas, es una buena idea probarlas antes de instalarlas. Usé mi Arduino UNO y Adafruit NeoPixel Strand Test para confirmar que cada LED estaba funcionando.

Suelde cables más largos en cada una de las cadenas para 5 V, tierra y entrada de datos.

En este punto, debería haber cinco cables de 5v, tres cables de datos conectados al Arduino Pro Mini y 5 cables de tierra.

Pele 5 mm de los extremos de los cables de 5v y suéldelos todos juntos y repita para los cables de tierra.

Después de completar las tres cadenas, suelde un cable de 5V al pin RAW del Arduino Pro Mini y también al pin VCC para el RTC. Un cable de tierra a GND en el Arduino Pro Mini y RTC y luego 2 cables más:

SCL del RTC al A5 en el Pro Mini

SDA del RTC al A4 en el Pro Mini

Las líneas de datos de los LED deben conectarse a:

• Segundos - Pin digital 3.
• Minutos - DigitalPin 4
• Horas - DigitalPin 5

Paso 4: instalación

Una vez soldados, la instalación de los LED en sus orificios debe ser sencilla. Los LED deben instalarse para que los datos se ejecuten en sentido contrario a las agujas del reloj cuando se mire desde la parte posterior, ya que el código se configura de frente.

Usé una pequeña cantidad de pegamento caliente para mantenerlos presionados, ya que quiero poder reemplazar un solo LED si falla en el futuro.

También utilicé pegamento caliente para mantener todos los cables limpios y ordenados y para fijar el conector de barril a la placa.

Hay varias guías de programación mini arduino pro disponibles. Utilizo el método de convertidor de USB a serie externo para cargar este código en el Arduino:

Este código también establecerá la hora en el RTC a la hora en que se compiló. por lo que es importante mantener el botón de carga para que cumpla y cargue lo más rápido posible.

Gran parte de este código fue tomado del NeoPixel Ring Clock de Andy Doro. Algunos de Adafruit NeoPixel Strand Test y otros que puse juntos.

Deberá haber instalado algunas bibliotecas. Están disponibles en el Administrador de bibliotecas del software Arduino.

Adafruit NeoPixel para los LED ws2812b

Cable para hablar con el RTC a través de I2C (está integrado de serie)

y RTClib por saber qué preguntarle al RTC

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

Revisión histórica

Fecha por qué

20140320 AFD Primer borrador 20160105 AFD Arcos difuminados 20160916 AFD Compatible con Trinket 20170727 AFD agregó STARTPIXEL para gabinete 3D, punto de inicio variable, soporte DST automático agregado 20180424 AFD usando la biblioteca DST https://github.com/andydoro/DST_RTC *

/ incluir el código de la biblioteca:

#incluir #incluir

#incluir

// definir pines

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

#define BRIGHTNESS 20 // establece el brillo máximo

#define r 10

#define g 10 #define b 10 RTC_DS3231 rtc; // Establecer objeto de reloj

Adafruit_NeoPixel stripS = Adafruit_NeoPixel (60, SECPIN, NEO_GRB + NEO_KHZ800); // quitar objeto

Adafruit_NeoPixel stripM = Adafruit_NeoPixel (60, MINPIN, NEO_GRB + NEO_KHZ800); // quitar objeto Adafruit_NeoPixel stripH = Adafruit_NeoPixel (24, HOUPIN, NEO_GRB + NEO_KHZ800); // quitar el byte del objeto pixelColorRed, pixelColorGreen, pixelColorBlue; // contiene valores de color

configuración vacía () {

Wire.begin (); // Iniciar I2C rtc.begin (); // iniciar el reloj

Serial.begin (9600);

// establecer pinmodes pinMode (SECPIN, OUTPUT); pinMode (MINPIN, SALIDA); pinMode (HOUPIN, SALIDA);

if (rtc.lostPower ()) {

Serial.println ("RTC perdió energía, ¡ajustemos la hora!"); // la siguiente línea establece el RTC en la fecha y hora en que se compiló este boceto rtc.adjust (DateTime (F (_ DATE_), F (_ TIME_))); // Esta línea establece el RTC con una fecha y hora explícitas, por ejemplo, para establecer // 21 de enero de 2014 a las 3 am, llamaría: // rtc.adjust (DateTime (2014, 1, 21, 3, 0, 0)); }

stripS.begin ();

stripM.begin (); stripH.begin (); //strip.show (); // Inicializar todos los píxeles a 'desactivados'

// secuencia de inicio

retraso (500);

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

retraso (1000);

DateTime theTime = rtc.now (); // tiene en cuenta el byte DST secondval = theTime.second (); // obtener segundos byte minuteval = theTime.minute (); // obtener minutos int hourval = theTime.hour (); hourval = hourval% 12; // Este reloj es de 12 horas, si es 13-23, conviértalo a 0-11`

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

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

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

}

bucle vacío () {

// consigue tiempo

DateTime theTime = rtc.now (); // tiene en cuenta el horario de verano

byte secondval = theTime.second (); // obtener segundos

byte minuteval = theTime.minute (); // obtener minutos int hourval = theTime.hour (); // obtener horas hourval = hourval% 12; // Este reloj es de 12 horas, si es 13-23, conviértalo a 0-11`

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

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

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

stripH.setPixelColor (valor de hora, r, 0, 0);

stripH.show (); retraso (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);}} // para depuración en serie Serial.print (hourval, DEC); Serial.print (':'); Serial.print (minuteval, DEC); Serial.print (':'); Serial.println (secondval, DEC); }

// Rellena los puntos uno tras otro con un color

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

void colorWipeM (uint32_t c, uint8_t espera) {

para (uint16_t i = 0; i <stripM.numPixels (); i ++) {stripM.setPixelColor (i, c); stripM.show (); retrasar (esperar); }}

void colorWipeH (uint32_t c, uint8_t espera) {

para (uint16_t i = 0; i <stripH.numPixels (); i ++) {stripH.setPixelColor (i, c); stripH.show (); retrasar (esperar); }}

Paso 5: Toques finales

Todo lo que debería quedar ahora es fijar el RTC y el microcontrolador en el hueco.

He colocado la batería del RTC con el lado hacia arriba para poder cambiarla fácilmente si es necesario.

Conecte los cables de 5v al lado + del conector y la tierra al lado -

¡Enciendelo!

Tengo el mío conectado a un banco de baterías USB, pero un cargador de teléfono USB funcionaría igual de bien.

Nota:

El brillo de los LED se establece en el código. Se ha establecido bajo para mantener bajo el consumo de corriente. A pleno brillo con todos los LED encendidos, podría consumir casi 8 amperios. Con la configuración actual es menos de 1.

Finalista en el Concurso de Relojes