NeoClock: 7 stappen (met afbeeldingen)

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Dit gaat over het bouwen van een klok met de fantastische neopixelringen van Adafruit. Het leuke van deze klok is dat hij eigenlijk twee ringen van neopixels heeft, één voor het aangeven van de uren en één voor de minuten, seconden en milliseconden. De klok houdt perfect de tijd met behulp van de DS3234 DeadOn Real Time Clock-chip van Sparkfun. Eenvoudig te bouwen en leuk om aan te passen. Ik hoop dat het anderen zal inspireren om klokken of andere kunst te bouwen met behulp van de neopixel-ringen.

Voor degenen onder jullie die al mijn bestanden in een eenvoudig te beheren formaat willen hebben, voel je vrij om ze te downloaden van mijn github-repository voor dit project op

Stap 1: De klok ontwerpen

Ik wist vanaf het begin dat ik ten minste twee ringen neopixels wilde gebruiken. Na wat werk besloot ik dat het beste ontwerp zou zijn om de ene ring in de andere te hebben, die de oorspronkelijke vorm van een klok behoudt. De kleinere ring zou de uren zijn en de resterende tijd zou op de grotere ring worden gehouden. Enkele ontwerpoverwegingen waren de kosten van de neopixels, de stroombehoefte, de grootte van de lasergesneden stukken en wat voor soort kunst ik erop wilde zetten.

Toen deze stap voltooid was, besloot ik dat ik de elektronica moest begrijpen voordat ik de plannen maakte voor het lasersnijden van het klokhuis.

Stap 2: De elektronica ontwerpen

Het ontwerpen van de elektronica kwam neer op het vooraf kennen van de elementen die ik in de klok wilde:

• Neopixel-ringen (60 tellen en 24 tellen)
• Arduino (de hersenen)
• Klokregeling (arduino's houden de tijd niet bij)
• Stroombeheer

De grootte en stroomvereisten van de neopixels zijn goed gedocumenteerd. Omdat ze op 5V DC werken, besloot ik om met een 5V Arduino te gaan en dingen voor mezelf eenvoudiger te maken. Omdat ruimte een overweging was, besloot ik een prototype te maken op een gewone Arduino Uno, maar voor de laatste elektronica koos ik een Arduino Mini.

De eerste iteratie van dit project kwam rechtstreeks van Adafruit's NeoPixel Basic Connections-pagina. Ik heb het diagram van de website toegevoegd om het gemakkelijker te maken. Hierbij zijn twee zaken van belang:

1. Er is een condensator van 1000 uF nodig om te voorkomen dat de initiële stroomstoot de pixels beschadigt.
2. Een weerstand van 470 ohm is nodig op de eerste pixel van de 60-telring (deze weerstand is ingebouwd in de 24-telring)

Adafruit heeft ook een set NeoPixel Best Practices die u moet lezen voordat u verder gaat met het ontwerp.

De tijd op de klok houden is een ander probleem. De ingebouwde klok op de arduino is niet voldoende om de tijd goed bij te houden. Een erger probleem is dat de tijd op de Arduino elke keer opnieuw moet worden ingesteld. Computers lossen dit probleem op door een kleine batterij op de klokchip te gebruiken om de tijd tussen stroomonderbrekingen te houden. Vroeger gebruikte ik zoiets als de ChronoDot van Adafruit. Maar in dit geval wilde ik een excuus om de DS3234 (DeadOn RTC) van SparkFun te gebruiken. U kunt ook datuminformatie op de DeadOn RTC bijhouden als u die in de klok wilt integreren.

Ten slotte had het energiebeheer wat aandacht nodig. Ik wist al dat alles 5V moest zijn, maar de hoeveelheid stroom die nodig was, leek een mysterie. Een veelgebruikte spanningsregelaar in de meeste projecten is de L7805. Dit duurt spanningen tot 24V en een maximale stroom tot 1,5A. Ik wist dat ik een 12V 1.5A muurwort had liggen, dus besloot ik dat dit de perfecte (en goedkope!) spanningsregelaar voor het project zou zijn.

De overige stukken zouden uit mijn onderdelendoos of Radio Shack komen. Ze omvatten de draden, schakelaars en gelijkstroomaansluiting.

Stap 3: De elektronica bouwen

Een volledige lijst van de elektronica die ik heb gekocht om dit project te bouwen, is te vinden in mijn github-repository hier: Electronics Parts List. Het heeft links naar de productpagina voor elk stuk en bevat wat aanvullende informatie, waaronder de product-SKU. Ik maakte hier snel een prototype van op een breadboard en ging verder met lasersnijden en bouwen voordat ik foto's nam. Ik heb het echter wel zo gebouwd dat het gemakkelijk uit elkaar te halen is, dus ik heb de stukjes in de bovenstaande foto's voor je afgebroken.

Kijk goed naar de afbeeldingen, want de draden zijn opzettelijk gebogen zodat ze gemakkelijk te volgen zijn en om het hele profiel van de elektronica dun te houden. Door dit eerste prototype te maken vóór het lasersnijden, kon ik de dikte van de onderdelen controleren, zodat ik de uiteindelijke afmetingen voor het klokhuis kon achterhalen.

Je zult merken dat ik een paar aangepaste breadboards heb gemaakt. Ik heb geprobeerd foto's te maken van de achterkant van die planken, zodat je ze kunt herhalen. Je kunt een assortiment van dergelijke breadboards voor een paar dollar kopen en ze aanpassen aan je project.

De bedrading is eenvoudig, maar de belangrijkste dingen om te onthouden van de afbeeldingen zijn deze:

• De Mode- en Set-schakelaars hebben pull-down-weerstanden nodig. Ik gebruikte weerstanden van 2.21Ohm die ik had liggen, maar elke kleine weerstand zal werken (bij voorkeur niet minder dan 1kOhm). Dit stabiliseert de aangesloten Arduino-ingangspinnen, zodat ze te onderscheiden zijn van de ruis wanneer ze hoog gaan.
• De blokgolf (SQW) op de DS3234 is geaard omdat deze niet in gebruik is.
• De stroom van de L7805 wordt in de RAW-pin in de Arduino Mini gestopt. Zet de stroom die in de Arduino komt altijd in RAW.
• De eerste pixel van de 60 neopixel-ring heeft een weerstand van 470 Ohm om eventuele schade aan de eerste pixel door datapieken te verminderen. Dit zou geen probleem moeten zijn aangezien de 24 count neopixel hier al een ingebouwde weerstand voor heeft, maar better safe than sorry.
• De Mode en Set schakelaars zijn SPST momentele drukknop schakelaars

Draadkleuren zijn:

• Rood: +5VDC
• Zwart: grond
• Groen: gegevens
• Geel, Blauw, Wit: Speciale draden voor DS3234

Als dit de eerste keer is dat u neopixels gebruikt, moet u er rekening mee houden dat ze kunnen worden gezien als een lange keten. Dus het lijkt misschien vreemd om te praten over een "eerste pixel" in een ring, maar in feite is er een begin en een einde aan elke ketting in de ringen. In dit project komen de 24 pixels van de kleine ring eerst en daarna de 60 pixels van de grotere ring. Dit betekent echt dat ik een ketting van 84 neopixels heb.

Voor bedrading op de Arduino Mini:

• DS3234 wordt aangesloten op pinnen 10 - 13
• De schakelaars Mode en Set bevinden zich op pinnen 2 en 3
• De neopixelgegevens komen van pin 6.

Ik raad ook aan om de 6 headers aan de onderkant van de Arduino Mini te plaatsen, zodat je deze via een FTDI-kabel kunt programmeren.

Een belangrijke opmerking over stroom: deze klok vereist veel. Ik weet zeker dat ik het zou kunnen oplossen, maar mijn praktische ervaring is dat alles wat gelijk is aan of minder dan 500mA uiteindelijk tot brown-outs zal leiden. Dit manifesteert zich als de klok die gekke kleuren knippert en de tijd niet bijhoudt. Mijn laatste muurwort is 12V en 1.5A en ik heb er nog nooit een bruine uit mee gehad. 1.5A is echter de limiet die de spanningsregelaar (en andere onderdelen) zal nemen. Overschrijd dit bedrag dus niet.

Stap 4: De klok coderen

De volledige code voor de klok is te vinden in de NeoClock Code op GitHub. Ik heb het bestand hier toegevoegd, maar eventuele wijzigingen zullen in de repository plaatsvinden.

Ik vind dat het schrijven van code ontmoedigend kan zijn als je alles tegelijk probeert te doen. In plaats van daarvoor te gaan, probeer ik uit te gaan van een werkend voorbeeld en functies uit te bouwen als ik ze nodig heb. Voordat ik daarop inga, wil ik erop wijzen dat mijn code afkomstig is van het combineren van een groot aantal voorbeelden uit de volgende repositories en het Arduino CC-forum. Geef altijd krediet waar het verschuldigd is!

• https://github.com/adafruit/Adafruit_NeoPixel
• https://github.com/zeroeth/time_loop
• https://github.com/sparkfun/DeadOn_RTC

Enkele voorbeeldcodes uit deze repositories zijn te vinden in mijn Code Voorbeelden Directory

De volgorde van bewerkingen die ik gebruikte om de code uit te werken, ging ongeveer als volgt:

• Bevestig dat neopixels werken met het Strandtestvoorbeeld
• Poging om een klok te laten lopen met de tijdluscode
• Pas de klok aan om op twee ringen te werken in plaats van slechts één
• Voeg de DS3234 toe om de tijd bij te houden via het DeadOn RTC-voorbeeld
• Voeg de modus toe en stel schakelaars in
• Debounce-code toevoegen met behulp van de Arduion Debounce-zelfstudie
• Voeg wat kleurthema's toe voor de klok-LED's
• Voeg wat animaties toe voor de markeringen van 0, 15, 30 en 45 minuten
• Voeg kompaspunten toe aan de klok om de markeringen van 0, 15, 30 en 45 minuten te oriënteren

Als je wilt zien hoe ik deze code heb opgebouwd, kun je GitHub gebruiken om naar elke code-commit te kijken. De geschiedenis van de klok staat in de Commit History.

Kleurenschema's waren leuk om toe te voegen, maar uiteindelijk heb ik er maar vier in het menu opgenomen. Elk thema stelt een specifieke kleur in op de uur-, minuut-, seconde- en milliseconde-wijzers. De opties zijn hier echt eindeloos, maar ik heb de thema's opgenomen (de namen van de methoden vermeld):

• setKleurBlauw
• setKleurRood
• setKleurCyaan
• setKleurOranje

U kunt deze aanvullende methoden echter in de code vinden:

• setKleurPrimair
• setKleurRoyal
• setKleurTequila

Animaties werden toegevoegd omdat ik het idee leuk vond dat oude klokken op de vier vijftien minuten durende punten op de klok sloegen. Voor deze klok heb ik de volgende animaties gemaakt:

• 15 minuten: Kleur de ringen Rood
• 30 minuten: Kleur de ringen Groen
• 45 minuten: Kleur de ringen Blauw
• Top of the Hour: maak een regenboog over de twee ringen

Gebruiksvriendelijkheid bleek een probleem met de klok omdat niemand de klok kon oriënteren. Het zijn tenslotte maar twee ringen LED's. Dus om het probleem op te lossen heb ik de kompaspunten aan de klok toegevoegd. Dit verbeterde het vermogen om de tijd te vertellen veel. Als ik dit had geweten voordat ik de lasergesneden stukken opstuurde, had ik in plaats daarvan misschien iets aan de kunst toegevoegd. Maar het blijkt dat je de kunst niet zo goed kunt zien in het donker, dus het helpt echt om de kompaspunten te hebben. Een overweging hierbij is dat wanneer u besluit een pixel te kleuren, u eerst de huidige kleur moet vastleggen en een nieuwe overvloeikleur moet maken. Dit geeft het een natuurlijker gevoel.

Een laatste weetje gaat over de milliseconden. Milliseconden op de Arduino komen van het interne Arduino-kristal en niet van de DS3234. Het is aan jou of je milliseconden wilt weergeven of niet, maar ik deed het dus de klok leek altijd iets te doen. Het zal je misschien dwars zitten dat de milliseconden en seconden niet altijd op één lijn liggen, maar in de praktijk heeft niemand het me ooit verteld als ik naar de klok kijk en ik vind het er mooi uitzien.

Stap 5: De lasergesneden bestanden ontwerpen

Er zijn twee overwegingen die ik moest maken bij het ontwerpen van de lasergesneden bestanden. Het eerste was het materiaal waaruit ik het wilde bouwen en het tweede was hoe het zou worden gebouwd. Ik wist dat ik een houtafwerking wilde met acryl om de neopixels te verspreiden. Om het materiaal te achterhalen heb ik eerst wat samples besteld bij Ponoko:

• 1x Fineer MDF - Walnoot
• 1x Fineer MDF - Kers
• 1x Acryl - Lichtgrijs
• 1x Acryl - Opaal

De houtselecties lieten me zien hoe de rastering eruit zou zien en hoe de verbranding eruit zou zien aan de zijkant van de klok. Met het acryl kon ik de diffusie van de neopixels testen en vergelijken hoe het eruit zou zien tegen het hout. Uiteindelijk heb ik gekozen voor kersenhout met Opal acrylaat.

De afmetingen van de klok werden voornamelijk bepaald door de grootte van de neopixelringen. Wat ik niet wist, was hoe dik het moest zijn om in de elektronica te passen. Nadat ik de elektronica had gebouwd en wist dat het hout ongeveer 5,5 mm dik was, besloot ik dat ik ongeveer 15 mm ruimte in de klok nodig had. Dat betekende drie lagen hout. Maar omdat de voor- en achterkant al het grootste deel van de ruimte in mijn ontwerp innemen, moest ik die ringen opbreken in "ribben" die ik later aan elkaar kon lijmen.

Ik heb InkScape gebruikt om te tekenen op de sjabloon van Ponoko. Nadat ik het kloklichaam had uitgetekend, begon ik de boom met de hand te tekenen. Ik kon de originele afbeelding die me inspireerde niet importeren, maar het was niet erg om uit te zoeken hoe ik zelf iets soortgelijks kon doen.

De kosten van de materialen waren slechts ongeveer $ 20, maar de kosten van het snijden kwamen uit op ongeveer $ 100 meer. Twee zaken hebben hieraan bijgedragen:

• Bochten en cirkels kosten meer omdat de machine in twee assen beweegt en dit ontwerp veel bochten heeft
• Rasteren vereist veel passen heen en weer over het stuk. Als ik dit zou laten vallen, had ik het meeste geld bespaard, maar ik vond het leuk.

Nadat ik het ontwerp had afgerond, stuurde ik de EPS-bestanden naar Ponoko en ongeveer een week later waren mijn stukken klaar.

Merk op dat ik de Mode- en Set-schakelaars of de DC Power Jack niet in het ontwerp heb opgenomen. Toen ik dit opstuurde, had ik nog steeds geen beslissing genomen over die onderdelen. Om mezelf meer flexibiliteit te geven liet ik ze weg en besloot ik ze later met de hand te boren.

Stap 6: De klok bouwen

Toen alle stukken arriveerden, bouwde ik de klok. De eerste stap was het klokhuis, waarvoor ik de ribben moest uitponsen en aan de voor- en achterkant moest lijmen. Ik heb twee lagen ribben op de achterkant en één laag op de voorkant gezet en deze met houtlijm vastgezet. Voor de voorkant heb ik houtlijm gebruikt om de acrylringen en de houten cirkels aan elkaar te plakken. Ik had een extra centraal stuk dat ik als een blanco had gesneden, wat handig was tijdens de bouw. Ik plakte het aan de achterkant van het stuk boom en dat gaf me een plek waar ik later de neopixels kon lijmen.

Met het lichaam gebouwd heb ik besloten om gaten te boren voor de schakelaars en power jack. Een beetje geometrie (zoals te zien op de foto) hielp me alles uit te lijnen. Met behulp van een apart stuk hout aan de buitenkant terwijl ik (heel voorzichtig!) boorde, maakte ik de gaten en lijmde ik de schakelaars en de krik vast.

Daarna ging de elektronica er allemaal in. Ik heb eerst de neopixels vastgelijmd, gevolgd door de condensator. Deze heb ik aangesloten op het neopixel power breakout board. Dan voor de achterkant leg ik de draden op de schakelaars en de stroomaansluiting. Ik heb ook de L7805 spanningsregelaar meegeleverd.

Een korte opmerking over het oriënteren van de ringen. Voor de grote ring van 60 pixels moet je de klok zo richten dat een van de pixels precies bovenaan staat om de nul minuten te markeren. Welke pixel maakt niet uit en ik kom er zo op waarom. Voor de kleine ring van 24 pixels moet je de klok zo richten dat de bovenkant zich tussen twee pixels bevindt. De reden hiervoor is dat als je 12 uur wilt markeren, je uiteindelijk twee pixels oplicht in plaats van één. Door de offset, en met de diffusie van het plastic, lijkt het alsof je echt 12 brede pixels hebt.

Wat betreft welke pixel de code aanduidt als de "top" voor elke ring, moet u de code een beetje aanpassen. Ik heb twee waarden in mijn code met de naam "inner_top_led" en "outer_top_led". In mijn klokken was de "inner_top_led" 11 pixels vanaf het begin van de kleine ring en de "outer_top_led" was 36 pixels vanaf het begin van de grote ring. Als u de ringen toevallig anders oriënteert, zou u deze waarden veranderen in die van uw oriëntatie. Een beetje experimenteren en je zult vrij snel de juiste waarde vinden.

Op dit punt heb ik getest of alles werkte zoals verwacht.

Maar zoals bij alle projecten liep ik tegen een probleem aan omdat ik me realiseerde dat ik niet had bedacht hoe het zou blijven zitten. Ik merkte dat ik ongeveer 3/8 inch ruimte had tussen de neopixels en de ribben, dus ging ik naar Home Depot en kreeg een 3/8 inch plug en een aantal neodymium-magneten. Ik heb op drie plaatsen houten standaards gebouwd en ze geschuurd zodat ik twee magneten op elke standaard kon plaatsen (met superlijm). Ik eindigde met 3 paar van elk 2 stands. Daarna heb ik deze in het frame gelijmd en alles op zijn plaats gehouden met een klem. Ik deed dit terwijl de lijm op de standaards nat was, zodat alles zou worden uitgelijnd en vervolgens op de juiste plaats zou drogen. Dit werkte perfect en ik vind het geweldig dat de release helemaal verborgen is.

Ten slotte kwam ik erachter dat ik het aan de muur moest hangen, dus ik boorde een kleine hangar aan de achterkant zodat ik het aan de muur kon hangen.

Stap 7: Laatste gedachten

Dit project was erg leuk om te bouwen en ik heb genoten van het leren over neopixels en de DS3234. Ik vond het vooral leuk om eindelijk een project te bouwen dat er van begin tot eind mooi uitzag. Er zijn een paar dingen die ik zou updaten als ik dit opnieuw zou doen, maar ze zijn van ondergeschikt belang:

• Ik koos twee knoppen in plaats van drie voor de eenvoud. Maar een knop waarmee ik zowel naar beneden als naar boven kon gaan, zou leuk geweest zijn om de klok in te stellen
• De modusknop en de instelknop zijn niet van elkaar te onderscheiden. Ik haal ze vaak door elkaar. Misschien zou ik ze in de toekomst aan weerszijden plaatsen.
• Ik heb het houten front nooit afgemaakt. Ik vond het er eerst rauw uitzien en later maakte ik me zorgen dat als ik de afwerking verknoeide, het veel zou kosten om te repareren.
• Het rasteren van de boom zag er goed uit, maar misschien had ik in de toekomst meer details voor de boom getekend.
• Het dimmen van de klok zou ook een leuke functie zijn, omdat het vrij helder is in het donker. Het dimmen is echter gebonden aan de kleur en het uitzoeken dat dat beetje te lang duurde, heb ik laten vallen. Ik zou in de toekomst waarschijnlijk opnieuw in die functie investeren.

Bedankt voor het lezen van dit instructable. Ik hoop dat je je eigen klok- of neopixelproject maakt en met mij deelt. Gelukkig gebouw!