A series of 3d printed hexagonal panels outfitted with a number of 24-bit neopixel LEDs provide the backdrop to my invention room.
In between the prototyping and the 3d printing and the sleeping, I've been working on an API to control the lights remotely. I may have gone a tiny bit overboard with the amount of features I ended up supporting, but I think it will be worth it.
You can find all the code here: https://github.com/SharpCoder/wifi-neo-pixels
(I'm working on documenting my code and adding a README. It'll be there eventually).
Here is what that code gets you:
The device I have this running on is an ESP-12E (Node MCU). I picked up a 4-pack for a shocking 19$ USD. I'm pretty shocked at how cheap these things are because they seem to be amazing so far for my needs. (Find them here on Amazon)
Anyway, I'll conclude this update with a brief explanation for how to use my code.
Step 1 - configure the port / SSID / password
This is done in the file webServer.h - at the top, you can tweak the #defines.
Step 2 - That's basically it. Just flash your 8266-compatible arduino (with supported Adafruit NeoPixel and relevant esp8266 libraries included) with my .ino file and the modifications made to the #defines and you should be up and running!
As soon as your board connects to the WiFi, it will stage a server and expose the routes that I have listed above.
I can't wait to see the neo pixels actually mounted to some panels! That's going to happen very soon. Stay tuned!
Here is a silly, uninformative video demonstrating the neopixel lights changing color as I click things on my browser.
After printing a few more hexagonal pieces, I quickly learned that joining them with bolts was simply unsustainable. Aside from physical injuries due to pieces snapping when I can't get them positioned just so, I realized that snap-fits are something I haven't tried before. So this seemed like a great opportunity.
If I wrote a story about this, it would be titled "a bazillion ways not to snap-fit". But that's how we learn, right?
I started firstly by reading everything I could on snap-fit joinery. A lot of it seemed unapproachably complex, and also technically difficult to get right. These are a few of the resources I pored over:
A few things which didn't work
My initial test included trying to create a cantilever snap-fit mechanism. Which appears to be a traditionally accepted approach to joining plastics. Unfortunately, this failed miserably for me. In addition to the tolerances being too multi-dimensional for me to iterate over reasonably, I also discovered a very important side effect of the hexagonal shape...
Hexagons need to be able to seamlessly join along multiple faces at once.
In addition to that fact, I also realized that any extrusion along the outer surface of my parts will add further complexity to the final shape. In order to get the insert and receiver faces to mesh correctly, I found it much easier to design joints that connect inside the wall of the part.
All these findings led to the following rules:
Here is an example of one prototype which does not work. It violates pretty much all the rules. Because the wall thickness is not 100% consistent between the insert and the receiver faces, if I were to connect multiples of these together, there would be a triangular space between each edge which looks really unprofessional.
But that could never happen because it also violates the second rule :-) so connecting too many of these together is physically impossible.
I realized that a rail system like this is nice in theory, and the tolerances did get to "snapping together" stage. But the shape of the faces and the inconsistent extrusion needed to make this work led to an unsuitable prototype. I decided to go back to the drawing board...
Something which did work
With all those findings in mind, I decided to look at how people solve this problem on thingiverse - just to understand the general geometry required.
The design which really helped me understand what a solution might look like came from this particular print: (thingiverse) Hex Stackers
How they solved the geometries problem was to enforce a rule:
That simple rule makes thing so much easier. If you follow that pattern, it's fairly easy to join hexagons provided you have some kind of mechanism for doing so.
After many prints tweaking tolerances (in 0.05mm increments...) and a few iterations on the shape of the inserts, I came up with a working piece! The current prototype looks like this:
And so far it is working quite well! I will continue to iterate a few more times and then I think I'll finally be ready to mass-produce the hexagonal tiles.
(Apologies for not recording in the proper wide-screen orientation :P I always forget to do that...)
This morning, I started the day with a basic vision for what I intended the final faceplate to look like,. My next logical step was to prototype said faceplate and then design a way to mount LEDs to the translucent bits so the light can be diffracted evenly. I really wanted to get a feel for what this thing is going to look like in its final form.
As a courtesy, let me just point out right now that I am deciding to not use my custom LED enclosure as a final solution. Instead, I'll be sourcing the NeoPixel strand from amazon, as they come pre-packaged in a format which is exactly what I was trying to design myself... www.amazon.com/gp/product/B01AG923GI/ref=ppx_yo_dt_b_asin_title_o01__o00_s01
That being said, I did not discover this gem until I had already designed my own solution :) read on for more details about the home-made variety.
My LED enclosure goals were as follows:
With these design constraints in mind, I first set about measuring the LED and coming up with a bare-minimum chamber necessary to enclose a 5mm LED.
(as an aside, after a failed attempt to solder a wire directly to the LED leads, I took this opportunity to agree with myself that the design should be built around the concept of attaching jumpers to the leads and then locking all that stuff in place, probably through friction)
The only remnant I have from that design session is an awful drawing which I won't bother to post. The dimensions that I derived included the following:
The last question I had was what interface I might use to plug this LED into the translucent panel. So for that, I decided I'd just use square pegs at 3mm X 3mm X 5mm , one in each corner. No tolerances. It's... definitely a "one way door". Once this thing is installed, good luck getting it out :-P But we're here to prototype, not dawdle.
The full dimensions for the part ended up being 12mm X 25mm.
Taking all these observations together yielded the following design.
Okay, it didn't immediately yield this design. I had to iterate a few times before I landed on this particular shape. I'm sure it could use further improvement, but shockingly, it actually worked as I intended!
After making a quick modification to the light diffraction panel, I was able to create the reverse interface for these square pegs. The final result? (okay the part in this picture has a little side handle not shown in the design above. It was a further iteration which ended up not being useful, so... disregard that)
Aaaaand then I discovered the pre-built one from Amazon :)
c'est la vie