Embed With Elliot: Practical State Machines

September 4, 2015 by Elliot Williams 41 Comments

Raindrops on roses, and whiskers on kittens. They’re ok, but state machines are absolutely on our short list of favorite things.

There are probably as many ways to implement a state machine as there are programmers. These range from the terribly complex, one-size-fits-all frameworks down to simply writing a single switch...case block. The frameworks end up being a little bit of a black box, especially if you’re just starting out, while the switch...case versions are very easy to grok, but they don’t really help you write clear, structured code.

In this extra-long edition of Embed with Elliot, we’ll try to bridge the middle ground, demonstrating a couple of state machines with an emphasis on practical coding. We’ll work through a couple of examples of the different ways that they can be implemented in code. Along the way, we’ll Goldilocks solution for a particular application I had, controlling a popcorn popper that had been hacked into a coffee roaster. Hope you enjoy.

Continue reading “Embed With Elliot: Practical State Machines” →

Core Memory For The Hard Core

August 31, 2015 by Elliot Williams 58 Comments

[Brek] needed to store 64 bits of data from his GPS to serve as a last-known-position function. This memory must be non-volatile, sticking around when the GPS and power are off. Solutions like using a backup battery or employing a $0.25 EEPROM chip were obviously too pedestrian. [Brek] wanted to store his 64 bits in style and that means hand-wired core memory.

OK, we’re pretty sure that the solution came first, and then [Brek] found a fitting problem that could be solved, but you gotta give him props for a project well executed and well documented.

Continue reading “Core Memory For The Hard Core” →

CO2 Laser Decapping To Fix Soldering Mistake

August 29, 2015 by Elliot Williams 59 Comments

[Carsten] messed up. He was soldering an ARM CPU onto a quadcopter board in haste, failed to notice that the soldering iron was turned up to eleven, and pulled some of the traces up off the PCB. In the process of trying to fix that, he broke three pins off of the 100-pin CPU. The situation was going from bad to worse.

Instead of admitting defeat, or maybe reflowing the CPU off of the board, [Carsten] lasered the epoxy case off of the chip down to the lead frame and worked a little magic with some magnet wire. A sweet piece of work, to be sure!

Continue reading “CO2 Laser Decapping To Fix Soldering Mistake” →

Hilarious DARPA Robots Falling Video

August 23, 2015 by Elliot Williams 46 Comments

If you’re worried about Skynet, take a quick gander at the outtakes reel (YouTube, inlined below the break) from the DARPA Robotics Challenge (DRC) and you’ll feel a lot better. The IEEE Spectrum reporters assigned to the DRC took a break from their otherwise serious coverage and made this funny compilation of all the multi-million dollar robotic fails to go along with this article.

It’s hard not to empathize with the robots, and we’ll admit that we winced a little bit with the first couple falls. (But after three or four, started breaking out in maniacal laughter.)

Continue reading “Hilarious DARPA Robots Falling Video” →

Spectrum Painting On 2.4 GHz

August 22, 2015 by Elliot Williams 15 Comments

Give a software-defined radio (SDR) platform to a few thousand geeks, and it’s pretty predictable what will happen: hackers gotta hack. We’re only surprised that it’s happening so soon. Spectrum Painter is one of the first cool hacks to come out of the rad1o badge given out at the CCCamp 2015. It makes it dead-simple to send images in Hellschreiber mode on a few different SDR hardware platforms.

What we especially like about the project is its simplicity. Don’t get us wrong, we’re tremendous fans of GNURadio and the GNURadio Companion software radio hacking environment. But if you just want to do something simple, like send a picture of a smiley-face, the all-capable GNURadio suite is overkill.

Continue reading “Spectrum Painting On 2.4 GHz” →

CCC 2015: Moon Robots, Data Destruction, And An Epic Thunderstorm

August 19, 2015 by Elliot Williams 9 Comments

Chaos Communication Camp 2015 is over, and most everyone’s returned home to warmer showers and slower Internet. In this last transmission from Camp 2015, we’ll cover the final two days of talks, the epic thunderstorm, and give a brief rundown of the challenges of networking up a rural park in Brandenburg.

Continue reading “CCC 2015: Moon Robots, Data Destruction, And An Epic Thunderstorm” →

Embed With Elliot: The Volatile Keyword

August 18, 2015 by Elliot Williams 59 Comments

Last time on Embed with Elliot we covered the static keyword, which you can use while declaring a variable or function to increase the duration of the variable without enlarging the scope as you would with a global variable. This piqued the curiosity of a couple of our readers, and we thought we’d run over another (sometimes misunderstood) variable declaration option, namely the volatile keyword.

On its face, volatile is very simple. You use it to tell the compiler that the declared variable can change without notice, and this changes the way that the compiler optimizes with respect to this variable. In big-computer programming, you almost never end up using volatile in C. But in the embedded world, we end up using volatile in one trivial and two very important circumstances, so it’s worth taking a look.

Continue reading “Embed With Elliot: The Volatile Keyword” →