Realizing that Halloween was only a few days away, I thought to myself “Self, your house has no Halloween decorations, and thus, is Lame.” Being the crafty (and cheap) electrical engineer that I am, I took stock of my…stock…of electronic widgets and bits. After some thought, I decided on a couple of beady little red eyes peeking out of various windows would be appropriately festive, somewhat creepy, and very easy to through together.

Each pair of eyes uses an ATTiny85 chip and two 10mm red LEDs. Since Halloween decorations displayed year-round are frowned upon by my homeowner’s association, I also wanted these to be temporary. Luckily, I had a few protoboards that I could tie up for a few days.


Since this is a simple, temporary project, I made use of the awesome Arduino-Tiny set of “cores” for the Arduino IDE. Arduino-Tiny allows for a variety of ATTiny chips to be programmed directly form the Arduino IDE. There may not be 100% functionality, but it’s darn close. But of course the ability to blink lights is there, hehe. All I had to do was throw together the code and upload using my USBTinyISP.


Speaking of the code, here it is:

int led = 2;
int led2 = 3;

int randblink = 0;

void setup() {
  pinMode(led, OUTPUT);
  pinMode(led2, OUTPUT);  

void loop() {  
  digitalWrite(led, HIGH);
  digitalWrite(led2, HIGH);  
  digitalWrite(led, LOW);
  digitalWrite(led2, LOW);

Note: In the Arduino IDE, under ‘Board’, I selected ‘ATTiny85 @ 1MHz (internal oscillator; BOD disabled)’

Using a little bit of ‘random’ allowed for a little bit of variety in the “blinking.” The effect is simple, but pretty neat. And now my house is less Lame.

Last month, Dan and I went to the Open Source All the Things event in the Research Triangle Park and had the pleasure of meeting Jason Hibbets of both Red Hat Software and Jason gave us a lot of great advice but also asked to considering contributing to – which we, of course, couldn’t turn down!

So, if you’d like a little behind the scenes look at the beginnings of Maniacal Labs, head on over to and check out our article!

Between the three of us, we have expertise in the fields of software, electrical, and mechanical engineering. And we all have day jobs in very much closed and proprietary industries. We would not be where we are today without the wonderful open source community and maker movement. One of the most visible qualities of these communities is their willingness to help beginners and experts alike. We’re not exactly beginners, but we’re certainly not experts. A few searches on the great community uncovered a great deal of the process and pitfalls we went through while designing our first product. We were, are, and will continue to be learning along the way…

We would like to introduce a new product. Okay, not really a new product, but a completely different use for the Binary Epoch Clock Kit that we already sell.

We’ve been hinting at it for a while now but we are proud to finally announce EpochPOV, a custom firmware that turns your Binary Epoch Clock into a fully functional Persistence of Vision – or POV for short – display with a 32 pixel resolution!

Without further ado, some pictures to show off what this great firmware can do – with a some shout-outs to our friends at Adafruit and Hack A Day:

All pictures were a 1.6 second exposure at ISO 800 by simply waving the Epoch Clock in front of the camera during the exposure.

EpochPOV supports images 32 pixel high and up to 128 pixels wide (possibly longer in the future) and has a variable refresh rate that can be configured as described below.

To grab the latest version of EpochPOV just head on over to the GitHub repository, compile the firmware and upload it to your Epoch Clock board with an FTDI cable or AVR ISP.

You can change the displayed image by generating a new Image.h file with the included EpochPOVGen script located in the “Scripts” folder of the code repository. The script is written in python and supports all operating systems (though requires the installation of Pillow as described in the script header) but there is an exe file for use on Windows systems as well since compiling Pillow can be a pain on non-*nix systems.

Usage is as follows:

usage: [-h] [--delay DELAY] [--flip_v] [--flip_h] [--invert] input_img output_header

positional arguments:
  input_img      BMP image to process. Must be 32 pixels high.
  output_header  File to output C image data to.

optional arguments:
  -h, --help     show this help message and exit
  --delay DELAY  Time (ms) between each column refresh.
  --flip_v       Flip image vertically.
  --flip_h       Flip image horizontally.
  --invert       Invert image black/white values (negative)

Typical usage would look like this:

python mylogo.bmp Image.h
EpochPOVGen.exe mylogo.bmp Image.h

The optional arguments can be used to flip or invert the image colors as well as change the refresh delay, which defaults to 4ms between column updates. This default seems to work well for greater than one second exposures and waving the EpochPOV by hand. Slower will make the image wider and faster will make it narrower. By default, the bottom of the image will be the pixel closest to the USB power port but this orientation can be flipped with –flip_v and the default left to right movement can be switched by setting –flip_h.

The script requires that the image be a bitmap (.bmp), 32 pixels high, no more than 128 pixels wide and will convert the image to 1-bit color (black and white) if it’s not already, so there is not currently the ability to display gray-scale images on the EpochPOV.

Once the header file is created, copy it to Image.h in the EpochPOV firmware directory, re-compile and upload the firmware to your Binary Epoch Clock.

Don’t have a Binary Epoch Clock? Buy one and download the EpochPOV firmware now!

As Seen On Adafruit

Last night I got to show off our Binary Epoch Clock kit on Adafruit’s excellent Show-And-Tell weekly Hangout.
There was a great turnout with tons of cool projects and I’d like to thank Adafruit again for letting me join in.

Check out the whole show. There were a ton of great projects (I’m at 2:26):

Towards the end of my time, Limor Fried noted that the only thing it needs now is a 1D pong mode and I am rarely one to pass up such a challenge…
So this morning I came up with this:

It’s not actually playable, but just plays through a random game of (very linear) Pong.
Since there’s no where for the “paddles” to actually move to I decided to pretend that in this world of 1D pong the paddles simply have a binary state. They are either there or they are not.
Internally, those states are randomly chosen on each ball bounce or reset.

After either side scores, the current score is shown for one second by filling either side with the current count. Being that there are only 16 LEDs per side, the first one to 16 points wins! (And then the game resets).

Since I wanted to keep this as a functional clock, I didn’t involve the two buttons and make this playable but it would be very doable. Just make it so the button on either side has to be pressed with in a certain window of time that the ball is near either end.

I took this opportunity to also release to the published firmware a new clock face created by our good old friend, Josh, of the Proton Pack display fame. He thought it would be cool to have a clock face that breaks the 32 LEDs into subsections that show the binary value for seconds, minutes, hours, day, month and year. Amazingly, 32 was the exact number needed. This makes reading the time a little easier to begin with and even easier when coupled with this printable guide he created.


Just print it off, and adhere it to the back of the clock.

To facilitate all of these clock faces, I’ve made a tap of button A cycle through each of the faces in the order: 32 bit Epoch Binary > Normal Binary > 1D Pong

You can grab this new firmware from GitHub and load it up on your clock today!

Don’t have one yet? Grab yours from the store now!*

*Note: Our current shipping kits have the older v1.0 firmware pre-programmed. You will need an FTDI cable and the Arduino IDE to load this v1.1 firmware.



A few days ago, I saw this kit from Evil Mad Scientist (by way of Adafruit). My first reaction was more or less “… That’s brilliant!” I love projects that have a healthy dose of wackiness as part of the recipe. Don’t get me wrong, I appreciate projects that are purpose-built to accomplish a goal. But this kit in particular jumped out at me for two reasons.

But before that, the ‘What.’ This kit takes the internal workings of a 555 IC and, with resistors and transistors, re-creates all the functionality of the humble little chip. Plastic “legs” complete the IC persona, and screw terminals allow for easy hook-up connections to protoboards or “dead bug” style circuits. The PCB is quite hefty, and the silk screening divides the different block components of the 555 circuit. It’s a great piece to look at, and it just happens to be completely functional. Bonus points.

First, the kit is most clever. Kit designer Eric Schlaepfer basically ripped the lid off of a 555 IC and blasted the thing with an Embiggening ray. Sure he could have just thrown the components onto a breadboard, but that’s no fun. The inclusion of the legs and the ‘notch’ on the silkscreen instantly inform anyone familiar with electronics what this is. Of course, the giant ‘555’ printed on it doesn’t hurt either. The giant terminals are a nice functional and aesthetic touch. So were I a judge on Iron Chef: Electronics Edition, I would award full points for creativity and originality.

Second, upon seeing the kit and instantly knowing that I wanted one, I knew that I would need to brush up on my 555 knowledge. I admit, I’ve played with 555s in the past, but I’ve never given much thought to the internal workings. So after having some fun putting the kit together and testing the included (astable configuration) test circuit, I took to the Tubes and sought out some diagrams and videos explaining the design and operation of the small but mighty 555 timer. I’ll include some of my findings below.

In a nutshell, the 555 timer works by using two voltage comparators and a flip-flip to generate pulses on the output pin. The two most common configuration modes are astable, in which the external circuitry causes the 555 to generate a constant pulse waveform, and monostable, where an external trigger causes the 555 to generate a single pulse. One of the key components to these common circuit configurations is the capacitor. When the capacitor reaches a certain fraction of the supply voltage, the flip-flop is “actuated”, the output pin goes high or low, and the capacitor will start discharging or re-charging. Obviously this is a very simplistic explanation, but the rate of capacitor charge and discharge (governed by capacitor and resistor values) are key to the timing applications of the 555 IC.

So to sum up, yay for creative kits that cause you to go out and (re)learn stuff! The cool thing about the 555 chip is that it is very much a building block to bigger things. There are plenty of resources out there for 555 applications and project ideas. I’d like to thank Eric Schlaepfer for his awesome kit idea and Evil Mad Scientist for helping make it available to the masses! I think it quite possible that you might see the 555 creep into future Maniacal Labs projects.


Here are some resources I found while brushing up on the subject:

Of course, Wikipedia has a good synopsis of the 555, as well as some of the more in-depth maths detailing the particulars of how the different configurations function.

The datasheet from Signetics, who developed the 555 in 1971:

From the Sparkfun series “According to Pete”, Pete walks through some 555 basics.

This video is long, but the link takes you to right where he demonstrates the inner workings of a monostable 555 circuit. The whole video is definitely worth a watch.

A few projects featuring one or more 555 timers:

And some more pics from my build: