Introduction: ArClock - a Smart Display Wrapped in Real Wood
ArClock is my updating of the "LED clock inside a block of wood" idea. It's a pretty simple build and the result is eye-catching but tasteful (depending on how it's configured!).
It's built around a WiFi-enabled microcontroller driving a matrix of addressable RGB LEDs, inside a 3D printed case covered in wood veneer. It uses a NTP to display accurate time, and can also display local weather and ping times. The configuration is all via a built-in web interface.
Check out the video for a quick intro on how to build and configure it:
The parts required are:
- An 8x32 WS2812B LED Matrix, such as this one https://www.aliexpress.com/item/-/32944813367.html... (approximately $12). I used the "ECO" type which cuts down the power consumption a little.
- A Wemos D1 mini v3 (or clone), such as this one https://www.aliexpress.com/item/4001291931302.html... (approximately $2). Make sure you get the v3 model which has two mounting holes.
- Unglued maple wood veneer of at least 330mm x 200mm (I used this https://www.ebay.co.uk/itm/283404577831), approximately $17. Note that an A4 sheet will not be big enough (unless you want to try joining two pieces, which I wouldn't recommend unless you have some experience).
- 2.5mm panel mount power socket, like this https://www.ebay.co.uk/itm/281955435581 (<$1).
- Power diode rated ~1A, such as a 1N4001.
A couple of 3-pin JST connectors, like these https://www.aliexpress.com/item/32920898043.html
Total parts cost is around $32. You'll also need:
- Access to a 3D printer with a sufficiently large bed. I designed this to support common printers such as Prusa i3 and Creality Ender 3, but if you have something smaller please do check before going any further.
- Some hookup wire rated for at least 4A (e.g. 22 AWG).
- A 5V power supply with 2.5mm jack. I'd suggest a good quality 4A supply with over-current protection, but it depends on how bright you want the display. 2A is probably adequate in practice, but I prototyped with an 8A supply (after my original one blew up when the brightness went too high!).
- Contact adhesive such as Thixofix.
- Polyurethane wood varnish (I used one coat of Yacht varnish and two of clear).
- Sandpaper of a couple of different grits (around 120 and 200).
- Soldering iron & solder.
Step 1: Printing
The design prints in just two halves. The STLs and the OpenSCAD source code are available here:
The slicer and printer settings don't matter too much, but I went with:
- 100% infill
- 0.2mm layer height
- Brim for bed adhesion
- White PLA
- 210° nozzle
- 60° bed
- 40 mm/s
This is a relatively large design, so at these settings it will take over a day to print.
You should use whatever settings print cleanly on your machine. The surface finish doesn't matter very much (we'll be covering it up later), but you want to avoid significant blobbing or stringing as this can make it difficult to insert the LED matrix.
Step 2: Electronics
The circuit is relatively straightforward.
We wire power from the DC jack directly into the matrix. Because the matrix is quite large I supply power at all three of the available points (input, output and middle of the matrix).
Power is also supplied from the jack to the ESP8266 board via the diode. This allows the final design to be powered from a single jack, but means that when programming the ESP8266 over USB we don't pass power from USB to the matrix (which can easily draw >4A, far beyond the limit of the USB connection).
The only other connection is the single wire control signal from the ESP8266 to the matrix.
I used 90 degree headers on the ESP8266 to make soldering it together easier, with heatshrink to keep everything neat.
There is some advice on the internet (e.g. https://learn.adafruit.com/adafruit-neopixel-uberg...) that suggests using a decoupling capacitor on the matrix, and adding a resistor between the ESP8266 and the matrix control wire. I haven't used them here, but would suggest at least using the decoupling capacitor.
At this point I'd would skip ahead and program the ESP8266 to check that everything works as expected, before continuing with the assembly.
Step 3: Assembly
To assemble, start by screwing the ESP8266 board onto the base. You'll need a couple of small self tapping screws - I scavanged mine from some defunct equipment; they're quite common for mounting PCBs in things like kids toys. Check that the Micro-USB connection is accessible from the bottom of the case.
Now slide the LED matrix into the main part of the case. It's something of a tight fit (perhaps I should have allowed a little more space!) but it will fit with a little gentle persuasion. If you're struggling, try curving the short ends of the matrix very slightly. As you slide it in you might find it catches - often this is because one of more LEDs has wedged itself in one of the case holes. Gently poke it with a screwdriver whilst applying pressure to the matrix and you should find it slides in okay.
Now insert the DC jack. The lugs on the jack should be bent at right angles, and you may need to gently open the case up a little to fit the jack in. If you struggle to get it through the hole, just open it up a little with a knife.
Once that's in, make sure the connections to the matrix are secure, place a thin line of superglue along the fin of the base, then slide the base into the main body. Hold it securely for a few seconds and you're done.
Step 4: Applying the Veneer
Cut the veneer into pieces large enough to cover each of the front, back, top and sides of the case, with a decent margin around the edge (say, 1cm). In the rear piece, make a hole just big enough for the power connector to fit through in roughly the right place. You may also choose to add veneer to the bottom edge.
Proceed in stages, applying first the rear layer, then the two sides, then the top, and finally the front. You'll need to allow the glue to dry after each stage, then trim and sand, so this will take a while.
For each stage, apply a thin coat of contact adhesive to both the case and the "inner" (paler) side of the veneer. This can be a messy process, so wear gloves and ensure you have excellent ventilation. Wait ten minutes until the adhesive is touch dry, then bring the veneer and case together and press firmly all over to ensure good contact, particularly around the edges. You might choose to clamp the veneer whilst the glue dries (I didn't), but take care not to use too much pressure as the veneer can be easily damaged.
Allow a couple of hours for the glue to dry, then trim the veneer with a sharp knife. Don't try to trim it exactly, leave around 1mm margin. Then, use a medium grit sandpaper (e.g. 120 grit) to sand the veneer flush along the edge.
Once you've applied veneer to each (visible) side, it's time for the finishing touches.
Step 5: Varnishing
Before varnishing, remove any excess adhesive around the edges, rub down the body with a fine (200 grit) sandpaper and clean off any dust or marks with a little white spirit.
The choice of varnish is very much a matter of taste - it's worth experimenting on veneer off-cuts to find a combination you like.
I found the maple too pale by itself, so I applied a single coat of yacht varnish which has a orange tinge to it, bringing it closer to oak in shade. I then applied two coats of clear satin polyeurethane varnish to get a nice finish, rubbing down with a fine (200 grit) sandpaper in between coats. Follow the instructions on your chosen varnish for drying and re-coating times, and remember to work in a well ventilated area.
Allow the final coat to dry fully then fit the nut on the power connector to secure it in place.
Step 6: Programming
First, install the Arduino IDE and add the ESP8266 package as described here: https://github.com/esp8266/Arduino
Select the "LOLIN(WEMOS) D1 R2 & mini" board.
Add the following libraries in the Library Manager:
- Adafruit GFX Library
- NeoPixelBus by Makuna
Then compile the sketch from GitHub (in the ArClock subdirectory):
If you've never used an ESP8266-based board before, you will need to install the CH340G driver, e.g. from here https://sparks.gogo.co.nz/ch340.html.
Plug the board into your computer. Select the port in the IDE, and download the code to the board.
Now connect 5V power via the DC jack.
Step 7: Configuration
Once plugged in, ArClock will briefly show a blue animated WiFi logo, which indicates that it has created a temporary WiFi network.
Connect to this network on your phone - after a few seconds you should see a page which lets you enter your network name and password. Make sure you click done, then click the reboot button to restart the clock.
If all has gone well, you'll see the WiFi logo turn green and after a second or so the clock should display the current time (in UTC). If there's a problem, the clock will give up after 30 seconds and create it's own network again.
Assuming it's succeeded, point your browser to http://arclock.local to connect to the clock. From here you can try out various presets and tweak the appearance of the clock.
In order to get weather data, you'll need to enter your location and get a free key from https://openweathermap.org/.
You can automate changes to the display via webhooks. For example, to display a message you can use:
curl http://arclock.local/show -d message="Your Message Here"
Or to change the brightness:
curl http://arclock.local/update -d brightness=10
Step 8: Closing Thoughts
Thanks for reading this far! I hope you're tempted to build an ArClock, please let me know how you get on in the comments below - I'm happy to answer any questions!
A few thoughts on the design:
- The OpenSCAD code can be tweaked with various parameters - it should be possible to modify it to support other boards or vary the curve of the display.
- I tried a few different wood veneers before settling on maple. I'd strongly suggest going with a pale wood with only light figuring, otherwise it will block much of the light. Even oak gives a strong cast which filters out almost all the blue light.
- The code is reasonably well commented so it should be easy to tweak the behaviour and add new features. But note that RAM is very short on the ESP8266 and the code already uses most of it.
- Note there's no authentication whatsoever, so ArClock should only be used on trusted networks!