How to Make (Almost) Anything | Anders Häggman

WEEK 11 // Networking

I had two main ideas for the networking week. The first idea, was to create two pods that sense touch and communicate with each other, without any set-up, through open wifi networks anywhere around the world. They would just have a plug to a wall outlet, but no other external buttons or cables. In their base state, they would be dark. When one of the pods is touched, it would start flashing, and it's counterpart would do the same. If the other pod was also touched, they would both stay lit, until one of the pods was no longer touched. This is pretty much identical to what two of my previous classmates, Andrew and Greg did in their wink project at Stanford. Although if I recall correctly, their pods were not wifi enabled and required connecting to a computer. Making the wifi enabled pods seemed like too much to tackle with my current skills, and I figured I would leave that challenge for a later date, when I had a bit more experience with electronics and coding.

Instead, I decided to create a modular art piece, that has pods which are connected together in a wired network. When any of the pods are pressed, it lights up, and randomly send out a signal to one of the other pods, which in turn lights up, and send out a signal to one of the other randomly chosen pods that it is connected to with a wire. After lighting up and sending out a signal, the initial pod will shut down. In this way, the pods turn on and off, and a light travels through the network of pods.

Level of previous experience:
Time taken:
Tools used:
Eagle PCB Software // Modela MDX-20 // Soldering Equipment // Arduino IDE
Got help from:
Will Langford // Ben Nahill // Eric
Main learnings:
Check the Arduino - ATTiny pin mapping.
Check the cables.

A quick sketch illustrating the setup of the light pods and connecting wires.

To begin with, I first designed a board that would connect three pods together. I figured this was the smallest number of boards with which I could test to see that the light did in fact move randomly around the network. This is the schematic for the board I designed...

...and here is the layout.

I milled out the boards, which did not go completely smoothly. Some of the traces were quite close to each other, so I had to play around with the settings of the fab module a bit to get the modela to mill them out nicely.

Cleaning up some of the traces with a knife.

Here is an example of a board that was destroyed. There were a couple of other ones as well that weren't up to par and had to be discarded.

I cleaned the bed of the modela, and put down a sacrificial layer. However, I did not mill it flat (as it was previously suggested that it was not necessary). However, as one can see from the outline cut, the mill did not cut all the way through. The base seems to be somewhat higher in the middle, and lower towards the edges. This did not matter that much, since I had milled the traces quite deep, and even the outline cut was deep enough that the parts could be snapped out, and just cleaned off with a knife. For more precise work, the bed should probably be re-cleaned, and the sacrificial layer should perhaps be milled flat.

I used a 2.5mm audio cable to connect the pods (3.5mm would have been my preferred choice, since it is more common in my experience), but the IDC only stocks the 2.5mm version, so that's what it would be. Since I wanted the pods to be completely modular and independent, I did not want to worry about providing an extra power source at the pod level, but instead made a quick board that would connect to one of the pods with an audio cable, and provide power to the whole network. This little box would be powered by a regular USB charger. I also added connections for two commonly used power cord types, but there was a mistake with the schematic or components, or something... After having the USB hooked up for a while, I noticed a faint plastic smell, thought it might be coming from the board, and picked it up. The two voltage regulators for the two other power sources were very hot, so I desoldered them, and for the time being decided that in order to light up the network, the only option would be to use a USB charger. I would fix the 9V power option at a later stage.

After soldering all the components on, it was time to start writing code, and testing the boards. This is the spot at which I got stuck for a very long time. I was assuming the problem was with the code, and did not realize to double check the boards, or try and measure if the board was even trying to send a signal when I wanted it to. After hours and hours of debugging code, scratching my head and asking for help, I suddenly realized that I had forgot to solder three wires to the cables (I had made my own). After soldering the third wire things started to improve rapidly, and I was able to send a signal to the other boards to have them light up.

At this point the code had been re-written and modified and reduced to the bare essentials, so I couldn't get the full functionality yet, but at least I was now able to send a signal via the audio cable to another board, have it hear the signal, and light up. In my mind this was already a small victory. Unfortunately, at this point in time, the course was already almost over, and I had to put all my effort into my final project. However, as the course winds down, I will pick up my efforts with the light network, and plan on finishing it over IAP.

This is one of the newer cables that has all three required wires, but as you can see, I had to make it in a hurry. There was some noise in the system causing some of the boards to light up or flash sometimes even if the button had not been pressed, or another board had not sent them a signal. I am not sure, but one problem could be the quickly made wire. I am hoping that with better wires, and perhaps a bit more robust code that ignores short signals, the network will behave more nicely, but that remains to be seen.

And finally, a short video demonstrating that the light pod network (albeit with only two pods in this test), sort of works. The code running in this example does not include commands to turn the lights off, nor does it have any delays in it (so the second light turns on immediately with the first one), but this was just a test to see that the basics work.