Category: embedded

I've been doing some work recently with a little Silicon Labs EFM8UB3 microcontroller. This is a nice 8051 clone with a bunch of peripherals all in a QFN24 package. I've been using a minimal development board Silicon Labs calls the Thunderboard. It's mostly fine, but it has one failure mode that's pretty annoying. This article is about how to back out of that failure mode if you encounter it.

The Thunderboard has a built-in JLink debugger, and it's unfortunately possible to put the MCU into a state where the debugger can't talk to it. That means that you can't program the board any more, so you might think you're stuck. You're not!

One thing I need to do for my pump monitor is to determine when the pump is running. I'm going to do this by measuring the current flowing in the power cable to the pump. That seems like it ought to be an easy thing to do, but doing it safely (it's a 240V AC mains cable to the pump) and reliably is more complicated than I expected. There might be a simpler way to do things than what I'm trying to do, but this is a good opportunity to do a little bit of analogue electronics and to learn some things. (My analogue electronics skills are negligible, so I'm always on the lookout for small projects or parts of projects that have the right "challenge level" to help me get better!)

We live on the side of a hill where rainwater runs down into our garden, gathering at the lowest point to make a "sumpy" patch. The soil has a high clay content, so the runoff is efficient. We also have a cellar. (You can see where this is going already, right?) We have a shaft next to the house that contains a pump to clear out water draining into the sumpy area. A couple of months ago I took the lid off the shaft and found the pump under two metres of water, not running. Opening up the stairs down to the cellar revealed half a metre of water down there... Not good.

In this final article of three, we're going to make our DMA-based ADC example from the second article run off a timer, and we'll do a small demonstration of how this might be used in a realistic application.

There's a video demonstrating each of the examples covered in this series of articles. It's probably most useful to watch it in conjunction with reading the articles.

In this second article of three, we're going to change our polling ADC example from the first article to use DMA.

DMA is a subject that is unavoidably a little complicated. It's useful to understand what DMA really is to get an idea of where that complexity comes from. That might help to build some enthusiasm to battle your way through the DMA section of the reference manual!

There's a video demonstrating each of the examples covered in this series of articles. It's probably most useful to watch it in conjunction with reading the articles.

I've been doing some STM32 programming recently as part of my Mini-Mapper project (using an STM32F767ZI). I needed to collect samples from several analog inputs at a fixed frequency, for monitoring motor torque. A simple thing to do, right? But the obvious way to do it isn't necessarily the best.

In this series of three articles, I'm going to try to show a better way. Some of this will be quite boring (it's just configuring microcontroller peripherals, after all), so I allowed myself a bit of time for a fun "finisher" at the end.

There's a video demonstrating each of the examples covered in this series of articles. It's probably most useful to watch it in conjunction with reading the articles.

I got hold of a BeagleBone Black a few weeks ago (courtesy of Tom Nielsen, who'd had it for a while, but had no time to play with it). This is a small (credit card sized) Linux machine with an ARM processor, intended for, well, pretty much anything you can use a little computer for. It has 512 Mb of RAM, plus 2 Gb of flash storage, so it's not a completely trivial machine.

Obviously, to do anything really significant with it requires some hardware work (there are lots of general purpose I/O pins to play with, plus UARTs, Ethernet, USB, SPI, a couple of analogue-to-digital converters, PWM drivers for motor control, and even HDMI video output!), but there are a few LEDs on the board itself that lend themselves to a blinkenlights demo...

The BeagleBone comes with some built-in software to let people write code quickly, using JavaScript of all things. There's also a bit of documentation about programming the thing in C. But (of course) I wanted Haskell blinkenlights!

So, the goal was to write a little bit of code to count in binary on the four user-addressable LEDs on the board, first in Javascript, then in C, then (somehow) in Haskell.