Horloge 132 pixels : 5 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

D'aussi loin que je me souvienne, j'ai été obsédé par les LED et le temps. Dans ce projet, j'ai créé une grande horloge murale qui affiche l'heure actuelle à l'aide de 132 LED néopixels montées et brillant à travers une planche d'épicéa. C'est un numérique analogique hybride avec un pixel individuel pour chaque heure, minute et seconde.

C'était le plus gros projet que j'ai entrepris à ce jour, j'ai commencé à y penser il y a 6 mois et l'idée est venue petit à petit. Je suis vraiment content du résultat et j'ai hâte de le partager avec vous.

Étape 1: Rassembler les fournitures et les outils

Composants

Ce projet est construit sur une planche de passe-temps bon marché de mon magasin de bricolage local. La planche mesure 850 mm de large sur 500 mm de haut et 18 mm de profondeur.

Les LED utilisées dans ce projet sont des 5050 WS2812b montées sur des circuits imprimés circulaires d'environ 9 mm de diamètre avec des plots à souder à l'arrière.

J'utilise un microcontrôleur compatible Arduino Pro Mini. C'est la version 5V 16MHZ. J'ai choisi celui-ci car il a un design super mince, un petit encombrement et tous les ports nécessaires ainsi que quelques pièces de rechange pour les futures mises à niveau. C'est aussi 5 volts donc je peux utiliser une seule alimentation pour les LED, le micro-contrôleur et le RTC

Le chronométrage est assuré par un module RTC (Real Time Clock) équipé de la puce DS3231. Cette puce est très précise, donc le temps ne devrait pas trop dériver.

Également utilisé:

Câble. Soudure et colle chaude.

Outils:

Perceuse électrique et forets à bois (10 mm et 5 mm)

Fer à souder

Pistolet à colle chaude

coupes de fil

Accessoires de défonceuse Dremel et plongeante

Étape 2: Marquage, perçage et routage

Forage

• À l'aide d'un bord droit, trouvez le centre de la planche en traçant une ligne à partir des coins opposés.
• Marquez 3 cercles à l'aide d'un morceau de ficelle et d'un stylo. Le cercle le plus à l'extérieur doit être à environ 20 mm du bord de la planche avec les 2 autres lignes se déplaçant de 15 mm à partir de la dernière ligne.
• J'ai utilisé un cadran d'horloge imprimé pour m'aider à marquer les positions de chacune des minutes et des secondes sur les 2 lignes extérieures et les heures sur la ligne intérieure.
• Percez des trous de 10 mm d'environ 5 mm de profondeur toutes les heures, minutes et secondes.
• Utilisez la perceuse de 5 mm pour percer des trous dans la planche pendant les heures, les minutes et les secondes.

Routage

Bien que cette étape ne soit pas nécessaire, elle permettra à l'horloge d'être encastrée dans un mur.

• À l'aide d'un routeur et d'un guide circulaire, acheminez les canaux de câbles dans la carte
• Marquez et acheminez un évidement pour l'horloge RTC et le microcontrôleur.
• Acheminez un canal des lignes extérieures à l'évidement pour les fils

Étape 3: Tant de soldats, de coupes et de dénudages

Cette partie suivante est beaucoup plus facile à dire qu'à faire. Mon conseil serait de le précipiter. essayez de trouver un système et entrez dans un rythme.

Chacune des LED a besoin de 5 volts en entrée, 5 volts en sortie, entrée de données, sortie de données, entrée de terre et sortie de terre. y compris l'alimentation du microcontrôleur et du RTC, ses plus de 400 fils, tous dénudés et soudés aux deux extrémités.

Une substance bleue collante est très utile pour cette étape.

• J'ai commencé par placer 2 LED dans leurs trous l'une à côté de l'autre pour déterminer la longueur de fil nécessaire pour se connecter l'une à l'autre.
• En utilisant le 1er morceau de fil comme guide, j'ai ensuite coupé 60 fils de chaque couleur.
• Dénudez 2 mm de gaine aux extrémités de chaque fil et étamez-les avec de la soudure.
• Soudez une petite goutte de soudure sur chacun des plots LED.
• Soudez les fils aux LED pour former deux chaînes de 60 pour les minutes et secondes et une chaîne de 12 pour les heures. J'ai utilisé du fil rouge pour 5V, jaune pour les données et bleu pour la masse.
• Prenez soin de connecter chaque Data Out (DOUT) au Data In (DIN) de la LED suivante
• La dernière led de chaque chaîne ne nécessite pas de fil de sortie de données.

Une fois que toutes les chaînes sont terminées, c'est une bonne idée de les tester avant de les installer. J'ai utilisé mon Arduino UNO et le test Adafruit NeoPixel Strand pour confirmer que chaque LED fonctionnait.

Soudez des fils plus longs sur chacune des chaînes pour 5V, masse et entrée de données.

À ce stade, il devrait y avoir cinq fils 5v, trois fils de données connectés à l'Arduino Pro Mini et 5 fils de terre.

Dénudez 5 mm des extrémités des fils 5v et soudez-les tous ensemble et répétez pour les fils de terre.

Après avoir terminé les trois chaînes, soudez un fil 5V sur la broche RAW de l'Arduino Pro Mini et également sur la broche VCC pour le RTC. Un fil de terre vers GND sur l'Arduino Pro Mini et le RTC, puis 2 autres fils:

SCL du RTC au A5 sur le Pro Mini

SDA du RTC au A4 sur le Pro Mini

Les lignes de données des LED doivent se connecter à:

• Secondes - Broche numérique 3.
• Minutes - DigitalPin 4
• Heures - DigitalPin 5

Étape 4: Installation

Une fois soudés, l'installation des LED dans leurs trous doit être simple. Les LED doivent être installées de manière à ce que les données circulent dans le sens inverse des aiguilles d'une montre lorsque vous les regardez de l'arrière, car le code est configuré vers l'avant.

J'ai utilisé une petite quantité de colle chaude pour les maintenir en place car je veux pouvoir remplacer une seule LED si elle tombe en panne à l'avenir.

J'ai également utilisé de la colle chaude pour garder tous les fils propres et bien rangés et pour fixer le connecteur cylindrique à la carte.

Il existe un certain nombre de guides de programmation arduino pro mini disponibles. J'utilise la méthode de conversion externe USB vers série pour charger ce code sur l'Arduino:

Ce code définira également l'heure sur le RTC à l'heure à laquelle il a été compilé. il est donc important de simplement fermer le bouton de téléchargement pour qu'il se conforme et se télécharge le plus rapidement possible.

Une grande partie de ce code a été empruntée à l'horloge annulaire NeoPixel d'Andy Doro. Certains proviennent du test Adafruit NeoPixel Strand et d'autres que j'ai rassemblés.

Vous aurez besoin d'avoir installé quelques bibliothèques. Ils sont disponibles à partir du gestionnaire de bibliothèques sur le logiciel Arduino.

Le NeoPixel Adafruit pour les LED ws2812b

Fil pour parler au RTC via I2C (ceci est intégré en standard)

et RTClib pour savoir quoi demander au RTC

/****************************************************** ************************* * * Horloge Anneau NeoPixel par Andy Doro ([email protected]) https://andydoro.com/ringclock/ * * ****************************************************** **************************

Historique des révisions

Date par quoi

20140320 AFD Première ébauche 20160105 AFD Arcs fondus 20160916 AFD Compatible Trinket 20170727 AFD a ajouté STARTPIXEL pour boîtier 3D, point de départ variable, ajout du support DST automatique 20180424 AFD utilisant la bibliothèque DST https://github.com/andydoro/DST_RTC *

/ inclure le code de la bibliothèque:

#include #include

#comprendre

// définir les broches

#définir SECPIN 3 #définir MINPIN 4 #définir HOUPIN 5

#define BRIGHTNESS 20 // définir la luminosité maximale

#définir r 10

#définir g 10 #définir b 10 RTC_DS3231 rtc; // Etablir l'objet horloge

Adafruit_NeoPixel stripS = Adafruit_NeoPixel (60, SECPIN, NEO_GRB + NEO_KHZ800); // supprimer l'objet

Adafruit_NeoPixel stripM = Adafruit_NeoPixel (60, MINPIN, NEO_GRB + NEO_KHZ800); // supprimer l'objet Adafruit_NeoPixel stripH = Adafruit_NeoPixel(24, HOUPIN, NEO_GRB + NEO_KHZ800); // supprime l'octet de l'objet pixelColorRed, pixelColorGreen, pixelColorBlue; // contient les valeurs de couleur

void setup () {

Fil.begin(); // Commencer I2C rtc.begin(); // commencer l'horloge

Serial.begin(9600);

// définit les pinmodes pinMode(SECPIN, OUTPUT); pinMode(MINPIN, SORTIE); pinMode(HOUPIN, SORTIE);

if (rtc.lostPower()) {

Serial.println("RTC a perdu l'alimentation, réglons l'heure !"); // la ligne suivante définit le RTC sur la date et l'heure à laquelle ce croquis a été compilé rtc.adjust(DateTime(F(_DATE_), F(_TIME_))); // Cette ligne définit le RTC avec une date et une heure explicites, par exemple pour définir // le 21 janvier 2014 à 3 heures du matin, vous appelleriez: // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0)); }

stripS.begin();

stripM.begin(); stripH.begin(); //strip.show(); // Initialise tous les pixels sur 'off'

// séquence de démarrage

retard (500);

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

retard(1000);

DateHeure l'Heure = rtc.now(); // prend en compte l'octet DST secondval = theTime.second(); // récupère l'octet des secondes minuteval = theTime.minute(); // récupère les minutes int hourval = theTime.hour(); valeurheure = valeurheure % 12; // Cette horloge est de 12 heures, si 13-23, convertie en 0-11`

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

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

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

}

boucle vide () {

// obtenir du temps

DateHeure l'Heure = rtc.now(); // prend en compte l'heure d'été

octet secondeval = theTime.second(); // récupère les secondes

octet minuteval = theTime.minute(); // récupère les minutes int hourval = theTime.hour(); // récupère les heures hourval = hourval % 12; // Cette horloge est de 12 heures, si 13-23, convertie en 0-11`

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

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

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

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

stripH.show(); retard(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);} } // pour le débogage en série Serial.print(hourval, DEC); Serial.print(':'); Serial.print(minuteval, DEC); Serial.print(':'); Serial.println(secondval, DEC); }

// Remplir les points les uns après les autres avec une couleur

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

void colorWipeM(uint32_t c, uint8_t wait) {

pour (uint16_t i = 0; i < stripM.numPixels(); i++) { stripM.setPixelColor(i, c); stripM.show(); retarder (attendre); } }

void colorWipeH(uint32_t c, uint8_t wait) {

pour (uint16_t i = 0; i < stripH.numPixels(); i++) { stripH.setPixelColor(i, c); stripH.show(); retarder (attendre); } }

Étape 5: Touches finales

Il ne reste plus qu'à fixer le RTC et le microcontrôleur dans le renfoncement.

J'ai installé la batterie RTC vers le haut afin que je puisse facilement changer la batterie si nécessaire.

Connectez les fils 5v au côté + du connecteur et la terre au côté -

Allumez-le!

J'ai le mien connecté à une banque de batteries USB, mais un chargeur de téléphone USB fonctionnerait tout aussi bien.

Noter:

La luminosité des LED est définie dans le code. Il a été réglé bas pour maintenir la consommation de courant faible. À pleine luminosité avec toutes les LED allumées, il pourrait consommer près de 8 ampères. Avec la configuration actuelle, il est inférieur à 1.

Finaliste du concours d'horloges