Circuit board, meet skateboard. Using a Hex Bug remote control skateboard and an Arduino, I attempt to build a programmable tool for physics and computer science exploration. In hacking, as in skateboarding, you rarely land a trick the first time, but there’s plenty to learn with each attempt.
Though I dabbled with Java and Visual Basic as a kid, what always held me back from making programming a lifelong hobby was the lack of tangible, physical results. LEGO Mindstorms came closest to quickly physicalizing programming, but never held more appeal than the physics-defying stunts of Hot Wheels cars or doing my own tricks on a skateboard, snowboard, or hockey skates. If there was one thing that could’ve made computer science stick for me, it would have been something like a programmable skateboard.
As anyone who skates will tell you, making a skateboard move the way you see on Tony Hawk Pro Skater is not an easy feat, requiring a much deeper understanding of physics than initially meets the eye. But as shown by games like this (and through the foot movements of real skaters), it theoretically can be separated into a series of specific movements that produce the desired outcome. Without a tool to experiment and break these down on a small scale, it is very difficult to learn the physics and mechanics taking place, but if a toy could expose these elements and allow for experimentation, the learning opportunities would be endless.
With this in mind, I wondered how hard it would actually be to build a programmable toy skateboard. The first step was to see what already existed. The easiest, cheapest method would be finding something halfway there that I could hack.
Luckily, the makers of Hex Bugs (and Tony Hawk himself), were already on top of this with their product “Circuit Boards”. Each set contained a “power axel” with a remote that could be attached to a series of decks, as shown below.
Based on EEG Hacker’s tutorial of how to hack a Hex Bug remote control, if the manufacturer was using a similar circuit board in all their remotes, it appeared that hooking the Circuit Board remote to an Arduino would be doable. Thank you to EEG Hacker for this, as without this tutorial, this experiment would have been a near-impossible endeavor for an amateur maker like myself.
Upon opening up the remote control’s circuit board (Figure 2), I realized I had a slightly different animal on my hands than the Hex Bug. The board was not labeled and had no test points (as shown in the Hex Bug example in Figure 4).
Though the controls were easy enough to find (on the left side of the circuit board left wheel forward and back, on the right side right wheel forward and back), figuring out how I could use a soldered wire to impede or create a current flow was more difficult.
I saw that when I pressed down on the plastic remote buttons, I was actually pressing down on a metal button that touched the center of the board. This metal button was also touching the board at three other points through the legs that kept it attached to the board, which was allowing the current to flow. When I tried pressing the button without these legs attached, the skateboard’s wheels didn’t move, so they were all essential to completing the circuit.
Next, I used the multimeter to test little indents that looked like mini test points, as they seemed like good places to solder my wires onto if I was following the Hex Bug model.
With one lead on the small indents visually connected to each button and the other on the wire at the top where the remote control signal was sent to the skateboard wheels, I saw that current was flowing through these indents, but not elsewhere on the board. This was a good sign that if I followed the Hex Bug hack model of impeding the circuit, I could solder wires here to the same effect.
I also located a similar point to attach my ground wire as had been done in the Hex Bug model.
Then I got ready to solder. This is when I hit some snags. With less than surgical motor skills and a wobbly circuit board once disconnected from the battery pack, achieving accuracy in my soldering was incredibly difficult. The solder seemed to also be attracted to the areas where it wasn’t needed (e.g., the level of power slider at the bottom, which I had left out of this exercise for simplicity).
Three painful hours later, I had almost gotten the wires where I needed them to go, or at least created some kind of connection to each directional control’s circuit (shown in Figure 5). This was all very messy, but in doing so I tried to make the buttons obsolete by using solder to connect the circular areas where the metal of the button would have closed the circuit. Then, I would have my wire act as the impeding member of the circuit, which would reconnect the circuit when I programmed it to do so.
This is when things began to go wrong. First, the inconsistent and messy nature of my soldering meant that the wire was playing a slightly different role in the circuit of each button. However, with the indents that I was calling “mini test points” being so minuscule, it was nearly impossible to accurately pursue the strategy that worked in the Hex Bug hack. If I had been able to grow the circuit board to about a foot wide, I would have instead used my wire to connect the center of the button area to the ring around it, making the same connection that was made when the original button was pressed. Alas, by the time I had this insight, the board was beyond repair, so I pushed full steam ahead with plan A (or something like it).
Despite the inconsistency of the connections, I hoped maybe that it could still work. So I hooked the wires up to my Arduino, matching the Hex Bug hack configuration so I wouldn’t have to edit the code (shown in Figure 6). I also had to reconnect the circuit board to its battery pack, which was easy enough once I got some of the excess solder off of one of the holes where the battery connected in to the circuit.
Just to test it, I compiled and loaded the program from the Hex Bug hack onto my Arduino and opened up the serial monitor.
The good news? Current was flowing to the Arduino, things were happening. The bad news? I could tell because with every key I pressed to try to control the skateboard from my computer, the serial monitor was spitting out gibberish.
After Googling this problem, I tried editing some names and instances in the program that I thought might not align with my board, as well as various suggestions from across the web. Unfortunately none of these efforts were successful.
To be fair, earlier in the process, I had also dropped the skateboard while examining its inner workings and had somehow split open its plastic, dislodging a few wires and rendering it not responsive to the manual remote unless the board was in the right position. I used duct tape to try to set everything back in place (Figure 7), but it may have been permanently damaged. I could no longer test this, however, since the metal buttons on the remote were now useless with the solder in place.
Though this first experiment was a failure, I learned a number of things:
1) Understand the code before you start messing with the physical circuits. To debug the issues, I needed a better understanding of impedance, how this was happening in the code, and how the circuit needed to look for the code to work correctly. In retrospect, was this the right strategy for the Circuit Board circuit board?
2) Soldering small things is very hard, especially for those of us without surgical precision. Make sure you have the tools you need to set yourself up for success (e.g., a clamp or stand to hold the circuit board and the wires in place).
3) Start simple and build up to the goal. Hacking a Hex Bug before the Circuit Board would have been a good test run.
4) Whenever possible, buy two in case you break one (or for use as the control group). Also, take pictures of the raw materials before you start breaking them!
5) Don’t drop small plastic electronics from heights above 4 ft.
6) The fact that this model was difficult to hack means that the opportunity is even greater for a programmable skateboard that is already operational. The quest continues!