Building A WiFi Enabled Nixie Counter

wifi-nixie-counter

[Kevin Ballard] built this Nixie counter on the company dime. Tubes like this are getting more and more difficult to find since they’re no longer being manufactured. But when the Bossman hands you a corporate credit card those kinds of concerns take a back seat to your parts-shopping impulses. Start to finished this WiFi enabled counter took six weeks to build.

Connecting the board to the internet was very easy thanks to the Electric Imp that drives it. The difficult part comes in building a driver board and sockets for the tubes. We don’t see a lot of detail on how he’s generating the high voltage. But you can get a good feel for the tube connectors from the picture. He’s using an adapter PCB from Kosbo which breaks the tube pins out to two rows of 0.1″ pitch pin headers. The acrylic base has a port for each made of pin sockets spaced by a thick chunk of acrylic. Wiring harnesses wrap around the back side of the base to mate with the driver hardware. It’s programmed to count some type of company metric (it was funded by the corporation after all). They must be fairly successful because those numbers are flying by in the demo video.

Continue reading “Building A WiFi Enabled Nixie Counter” →

Automated Programming And Testing Jig Built With Raspberry Pi

[Doug Jackson] makes word clocks, and he must be doing quite a bit of business. We say that because he put together a programming and test bed for the clock circuit boards.

This is a great example to follow if you’re doing any kind of volume assembly. The jig lets the populated PCB snap into place, making all the necessary electrical connections. This was made possible by a package of goods he picked up on eBay which included rubber spacers to separate the board from the acrylic mounting plate, pogo pins to make the electrical connections, and a spring-loaded board clamp seen to the left in this image.

The switch in the lower right connects power to the board and pulls a Raspberry Pi GPIO pin high. The Python script running on the RPi polls that pin, executing a bash script which programs the ATmega169 microcontroller using the GPIO version of AVRdude. We looked through his Python script and didn’t see code for testing the boards. But the image above shows a “Passed” message on the screen that isn’t in his script. We would wager he has another version that takes the hardware through a self test routine.

We first saw one of [Doug’s] word clocks back in 2009 and then again a few months later. The look of the clock is fantastic and it’s nice to see the project is still going strong.

Wireless Unread Email Counter Tells You How Busy You’re Not

counter

One of the marks of how busy you are – or how well your spam filters are set up – is how many unread emails you have in your inbox. [trumpkin] over on Instructables posted a great tutorial for making a wireless counter that displays the number of unread emails in your Gmail account.

[trumpkin] used a tiny and inexpensive 419 MHz transmitter and receiver combo to make this project work. On his desktop, he wired up a USB to UART bridge attached to the transmitter. For the receiver side, an ATMega328 reads the data coming off the receiver and displays the number of unread emails on two seven-segment displays.

The wireless device runs off of two AA batteries and should provide enough power to keep the email monitor running for a long time. More than enough time for your inbox to fill up and for you to become overwhelmed with the work you should be doing.

USB Infrared Receiver Looks Good Sitting In Your Livingroom

usb-ir-receiver

The problem with building your own electronics for the living room is that the final product may not fit your decorating style. This was true with [Itay’s] prototype of a universal USB IR receiver. So after testing it out for a few weeks he decided to build a final version that started by selecting an enclosure he could be proud of.

He came across an LED flash light at the dollar store which has an aluminum body. When we read about this we envisioned a cheap version of a Mag Light from which he removed the cylinder that holds the batteries. But actually, the pod seen above is the entire flashlight (with an added base). It forced him to design a tiny surface mount PCB to fit everything inside.

It’s not too much of a stretch since IR receivers tend to be small anyway. [Itay’s] design put a PIC 18F2553 on one side of the board. The other side hosted the through hole components: an IR receiver, LED for feedback, and the connections for the USB cable that exit through the rubber button cover that used to switch the flashlight on. He had a problem with one of the resistor values which took a while to figure out. But eventually he got it working. It’s been in use now for six months.

Benchmarking USB Transfer Speeds

boards

[Paul Stoffregen], creator of the Teensy series of microcontroller dev boards, noticed a lot of project driving huge LED arrays recently and decided to look into how fast microcontroller dev boards can receive data from a computer. More bits per second means more glowey LEDs, of course, so his benchmarking efforts are sure to be a hit with anyone planning some large-scale microcontroller projects.

The microcontrollers [Paul] tested included the Teensy 2.0, Teensy 3.0, the Leonardo and Due Arduinos, and the Fubarino Mini and Leaflabs Maple. These were tested in Linux ( Ubuntu 12.04 live CD ), OSX Lion, and Windows 7, all running on a 2012 MacBook Pro. When not considering the Teensy 2.0 and 3.0, the results of the tests were what you would expect: faster devices were able to receive more bytes per second.  When the Teensys were thrown into the mix, though, the results changed drastically. The Teensy 2.0, with the same microcontroller as the Arduino Leonardo, was able to outperform every board except for the Teensy 3.0.

[Paul] also took the effort to benchmark the different operating systems he used. Bottom line, if you’re transferring a lot of bytes at once, it really doesn’t matter which OS you’re using. For transferring small amounts of data, you may want to go with OS X. Windows is terrible for transferring single bytes; at one byte per transfer, Windows only manages 4kBps. With the same task, Linux and OS X manage about 53 and 860 (!) kBps, respectively.

So there you go. If you’re building a huge LED array, use a Teensy 3.0 with a MacBook. Of course [Paul] made all the code for his benchmarks open source, so feel free to replicate this experiment.

Programming Microcontrollers With A Raspi

rasduino

The advent of the Arduino brought the world of microcontrollers to hobbyists, students, and artist the world over. Right now we’re in the midst of a new expansion in hobbyist electronics with the Raspberry Pi, but we can’t expect everyone to stay in the comfortable, complex, and power-hungry world of Linux forever, can we? Eventually all those tinkerers will want to program a microcontroller, and if they already have a Raspberry Pi, why not use that?

[Kevin] wanted to turn his Raspi into an AVR development workstation, without using any external programmers. He decided to use the Raspi’s SPI port to talk to an AVR microcontroller and was able to make the electrical connections with just a few bits of wire an a handful of resistors.

For the software, [Kevin] added support for SPI to avrdude, available on his git. Theoretically, this should work with any AVR microcontroller with the most popular ATMegas and ATtinys we’ve come to love. It doesn’t support the very weird chips that use TPI programming, but it’s still extremely useful.

Tamagotchi ROM Dump And Reverse Engineering

tamagotchi-rom-dump-and-reverse engineering

Often the true key to success is persistence and that holds true for this project which dumped the ROM from the current generation of Tamagotchi toys. If you’re a fan of learning the secrets built into consumer electronics — and you know we are — you’ll want to go back and watch the 24-minute lecture on Tamagotchi hacking which [Natalie Silvanovich] gave a 29C3 last year. She had made quite a bit of headway hacking the playable pods, but wasn’t able to get her hands on a full ROM dump from the General Plus chip on board processor. This update heralds her success and shares the details of how it was done.

As we learned form the video lecture it was a huge chore just to figure out what processor this uses. It turned out to be a 6502 core with a few other things built in. After prowling the manufacturer’s website she found example code for writing to Port A. She was then able to execute her own code which was designed to dump one byte of ROM at a time using the SPI protocol.

[Natalie] posted her code dump if you’re interested in digging through it. But as usual we think the journey is the most interesting part.

[Thanks Itay]