1978 "Heathkit" D&D Digital Dice Tower

Resto-Mod Dungeons and Dragons Digital Dice Tower based on a 1975 Bell & Howell IMD-202 Digital Multimeter

Public Chat
Similar projects worth following
Resto-mod Dungeons and Dragons digital dice tower based on a 1975 Bell & Howell IMD-202 Digital Multi-meter. It re-uses the original nixie tube display, power supply, and case. To implement the new functionality, a hand wired AVR based controller board is integrated with the original PCB, a two digit thumbwheel switch, 8 way rotary switch and panel mount button are installed in the case, and new graphics are applied to the face plate.

This project has been completed. If you are interested to read about additional features I am adding with subsequent builds of this concept, like and follow the latest project: 1979 "Heathkit" D&D Digital Dice Tower

This project implements the function of a Dungeons and Dragons dice tower and dice using a retro digital multimeter with nixie tube display. The user selects a number of dice using the two digit thumb-wheel switches, then selects the dice type (2 sided, 4 sided, 6 sided, 8 sided, 10 sided, 12 sided, 20 sided, or 100 sided) using a rotary switch, and finally presses the roll button to get a result. The device applies the GNU AVR lib C pseudo random rand() function, calculates the result, and displays it on the nixie tube display. The user can then re-roll by pressing the roll button again, or change the count and/or dice and roll a different set of die. It's that simple to use.

This project represents several things l love. 

  1. It's Dungeon & Dragons: I've been playing D&D since 1978. Thus 1978 is in the project name and it's a resto-mod build based on user interface technology from that same time frame. 
  2. It recycles: It's fun reusing old parts and technology. Besides being "the right thing to do" for reasons we already know, "Recycling" requires disassembly and reverse engineering. It's fun to take things apart and figure how they work. I often learn things applicable to other projects in the process. "Recycling" also requires a different approach to design and implementation. It defines the space you are working in and presents challenges that force you to look at projects from a different perspective. If you do it right, you can even avoid the boring parts of a project like designing a 170V power supply from scratch. I have a CS degree, not a EE :-)
  3. There's a microcontroller: A project just isn't fun unless there's a microcontroller and some software to write, download, debug, and iterate. I have a CS degree, not a EE :-)
  4. It's retro-cool without the retro software development: I love the old display technologies, the classic panel mount switches/dials/buttons, wrinkle paint, "lab equipment" blue, and sheet metal cases. I appreciate the 74xx series logic IC's and big through hole parts on the PCBs. They simplify reverse engineering, hardware prototyping, and the tools/skills required to do it. I even dig the old 8 bit processors (z80, 8051, 8088, 6502, 6805, 68hc11, 68K). In the past, I've written C and assembly code for all of those processors. However, I'm not a big fan of antiquated software development environments and code libraries, or spending hours integrating old tool chains with modern IDE's. I prefer to stay current with my software development and keep it applicable to the current job market. Thus the resto-mod approach using the AVR microcontroller.
  5. It's nixie tubes in an application that doesn't tell you the time of day: I saw someone post a comment the other day that nixie tubes are "boring now". I disagree. Nixie tubes are still cool. We just need to find new applications other than displaying the time of day.

I'll add some project logs with more detail on how this project was built. For now, here's an overview of the pieces required to make this work and how they roughly fit together.

This project "recycles" a Bell & Howell IMD-202-2 Multi-meter. These devices were part of the DeVry University electronics curriculum back in the mid-70's. If I understand it correctly, this multi-meter was a project that students built. The design is based on a Heathkit IM-1212 multi-meter. Bell & Howell apparently acquired the rights to recreate that design in a different form factor and enclosure. These multi-meters were produced in fairly large numbers. You might have one in your attic right now. Or, you can easily find functional examples on eBay. If you have a little patience, you can even buy them cheap. By cheap, I mean cheap for a project case, a couple nixie tubes, a couple...

Read more »


C source code for project. It was compiled and tested with the Atmel Studio 7.0 GNU toolchain

C Source File - 6.09 kB - 01/07/2020 at 06:43


  • 1 × Bell & Howell IMD-202-2 multi-meter Provides case, power supply, nixie tubes, and 7441 drivers for the project
  • 1 × Microchip ATtiny88 AVR microcontroller 28 pin DIP, 8K Flash, 512 bytes of RAM
  • 1 × 2 Pin Female Header Connector
  • 1 × 80 pin dual row IDC header Cut to size for connectors on the controller board and the daughter board of the rotary switch
  • 8 × 10K Ohm resistor 1/4 Watt

View all 15 components

  • Yet another revision...

    John Anderson02/10/2021 at 10:04 0 comments

  • New features in the new project...

    John Anderson02/10/2020 at 19:33 0 comments

    I've posted an updated video of the new features in the latest Digital Dice Tower I built. It's based on the same Bell & Howell Digital Multi-meter. 

    You can learn more about these features in the new project; 1979 Heathkit D&D Digital Dice Tower

  • That's a wrap

    John Anderson01/23/2020 at 22:17 0 comments

    This project has been completed. If you are interested to read about additional features I am adding with subsequent builds of this concept, like and follow the latest project: 1979 "Heathkit" D&D Digital Dice Tower

  • The final details...

    John Anderson01/23/2020 at 07:22 0 comments

    Now that the case has been modified, a controller board has been wired up and connected to the power supply / nixies, new switches installed, and code loaded and debugged. The only thing remaining is to update the graphics on the faceplate to match the functions of the new switches and button.

    This starts with removing the old graphics. 100% acetone and a rag is all you need to do that. Simply soak some acetone into the rag and rub the graphics you wish to remove. It takes a few minutes of wiping to get each section clean. Avoid getting acetone on any graphics you wish to keep. In my case, I left the graphic "bezel" around the nixie display window.

    When you're done the base silver paint will still be there but the black lettering will come off completely.

    As shown in a previous log, I laid out a new set of graphics to scale using Inkscape in my PC.

    I printed this to a water slide decal paper and transferred it to the faceplate before installing the switches.

    The water slide decals were very easy to apply and look pretty good in the pics I've posted. But in person you can make out the outer edges of the transparent backing. So if you use it, trim it very close to the graphics and/or trim to align the edges of the decal with the edges of the faceplate. For my next revision of this hardware, I'll try some old school embossed labels for a 70's home-built look.

    Speaking of the next revision of this hardware, I'll be wrapping up this project and marking it completed. I'll create a new project, "1979 Heathkit D&D Digital Dice Tower", to cover the next iteration. It'll be based on a the same Bell & Howell multi-meter, but it will have some new features, components, and software. So look for it and "follow" if you want to checkout some of the new features like sound/voice.

  • Just a Matter Of Software (JMOS technology)

    John Anderson01/22/2020 at 01:58 2 comments

    The last piece required to make all this old and new hardware useful is the software. The software for this application simply collects the input from the switches/buttons, determines the user's intent, and displays appropriate values on the nixie displays. The source for this application can be found in the main.c file attached to this project.

    For code development, image loads, and debugging, I use Atmel Studio 7.0 running on an old Windows 7 laptop connected to an Atmel ICE via USB. I am very impressed with Atmel Studio's IDE, project management, editor, and JTAG interface. I haven't written code in 15-20 years and I learned how to use it to create projects, edit code, manage files in a project, load images to microcontroller flash, and debug (breakpoints, single step, set watch tables, etc) in no time flat without reading through loads of documentation. This is by far the best free software that I have ever used. My one ding on it is the lack of Linux support. But, I can live without that.

    I'm also very impressed with the Atmel-ICE. I paid $90 for the basic kit and I got a full featured JTAG programmer/debugger that integrates with completely with Atmel Studio. It supports both AVR (ATtiny, ATmega, and ATxmega) and SAM ARM microcontrollers. And, it supports ISP, AVR JTAG, DebugWire, PDI, and SAM ARM JTAG. That's enough for years of projects I have in my queue. BTW, I have used a couple of the cheap AVR/Auduino USB ISP and JTAG programmers and they range from ok to non-functional. None of them provide the wealth of device/interface support the Atmel-ICE does. Or at least, I can't figure out if they do or not. Documentation is always sketchy at best.

    The application program can be broken down into 3 parts; hardware initialization, hardware interface, and application state machine.

    First is the hardware initialization. This is a single function that is called once in main() at start up. It sets up the I/O pins for the functions used by this application. In this case, port B pins 0-7 are connected to the 2 digit thumbwheel input, port C pins 0-2 are connected to the three outputs from the 74HC148 encoding the rotary switch setting, Port C pin 7 is connected to the momentary contact button, and Port D pins 0-7 are connected to the two 7441's driving the nixie displays. So the data direction registers and pull ups (enabled on all digital inputs) are configured as necessary.

    // Setup the IO pins **********************************************************
    void initIO()
        // Set Port B pins to input
        DDRB = 0b00000000;
        // Enable pull ups on port B
        PORTB = 0b11111111;
        // Set Port C pins to input
        DDRC = 0b00000000;
        // Enable pull ups on Port C
        PORTC = 0b11111111;
        // Set Port D pins to output
        DDRD = 0xff;
        PCICR = 0x00;
        PCMSK2 = 0x00;
        EIMSK = 0x00;

    Note, there is some extra setup of the PCICR, PCMSK2, and EIMSK config registers. These represent the alternative functions for the port D pins. The code is setting them to their default cold boot values. So, they aren't necessary. They were added while debugging what turned out to be an unrelated problem. I never bothered to take them out.

    The next part is the hardware interface functions. These functions read the status of the switches/button and output values to the nixie tubes.

    The first function outputs the provided integer value to the two digit nixie display connected to Port D.

    // Output a two digit decimal number on the Nixie Tube display ****************
    void output(int out)
        int outputByte = out%10;
        out /= 10;
        outputByte |= (out%10)<<4;
        PORTD = outputByte;

    The next function returns the current setting of the thumbwheel switch as an integer value.

    // Get the dice count from the thumbwheel input *******************************
    int getCount()
        uint8_t rawCount = ~PINB;
        // Bad wiring on both the thumbwheel and the board
        int count = (rawCount&0b00000011) | ((rawCount&0b00010000)>>2) | ((rawCount&0b00000100)<<1);
        count += (((rawCount&0b00100000...
    Read more »

  • User Interface Circa 1978

    John Anderson01/21/2020 at 00:11 0 comments

    To keep this project looking the part, I selected input hardware technology that dates back to the period. This includes a panel mount momentary push button to roll the dice, a 8 way rotary switch to select the die type, and a 2 digit 10 position decimal thumbwheel switch to select the number of dice. I covered how these were physically installed into the case in a previous log. In this log, I'll describe how they were wired up to the AVR microcontroller.

    The button is a simple connection to one of the AVR pins configured as an digital input with the pull up enabled. The other side of the switch is connected to a common ground with the AVR. It connects to the controller board via a keyed 2 pin single row IDC connector.

    The 2 digit decimal thumbwheel switch is a Hampolt TF31 2-Digit Thumbwheel Switch (BCD encoded). These can be found on E-bay for a reasonable price. They ship from Taiwan so plan for a lead time of a week or two. If you substitute another thumbwheel switch, be sure to get a BCD encoded style switch to minimize the number of processor inputs or external logic IC's required. I soldered a short piece of multi-color 10 conductor flat ribbon cable directly to the pads and crimped on a 10 pin dual row female IDC connector on the other end to connect to the controller board. Like the button, the 8 AVR pins are configured as digital inputs with the pull-ups enabled. The cable to the switch includes ground which is connected to the common pad on both digits.

    The rotary switch is an 8 position single deck unit. 

    To reduce the conductors required for the internal connector cable and the input pins on AVR controller, I soldered up a small piece of proto-board with a 74HC148 8 Line to 3 Line Priority Encoder IC and 10K pull-up resistors on the inputs. Like the BCD encoded thumbwheel switch, this reduced the AVR input pins from 8 to 3. The little board screwed to the back of the switch and provided the 6 pin dual row IDC header for the cable connection to the controller board. The cable provides +5v, gnd, and the three conductors for the BCD encoded selected value.

    The three cables routed back to the controller board like so.

  • Let there be light...

    John Anderson01/17/2020 at 03:28 0 comments

    Since demonstrating the first version of this project, a couple of my friends have requested that I build one for them. So I've been scanning my usual sources for one or two more of these old meters at the right price. I found and purchased one just last week that happened to include the original assembly manuals. I'm a tinkerer and not much of a collector. So, I'm not looking for complete sets of anything or factory originals. And, as I posted in a previous log, I already have enough information to tinker at will with these meters. But once it arrived with manuals included, I couldn't help but dig through them.

    I'm impressed with the detailed BOM, instructions, drawings, diagrams, waveforms, specifications, and troubleshooting steps provided.

    Some of the drawings are beautiful and there's even errata included.

    Here's the full system schematic from the manual.

    Here's the Power Supply section in more detail.

    And lastly here's the Binary Decoder and Output section in detail.

    Quickly scanning these, I don't see any changes from the IM-1212 schematics I shared in a previous post. But, I thought I would include these here for completeness sake. If you are playing with one of the meters and have a request for a specific diagram, waveform, or x-ray view, post a comment to the project and I can post something here. Don't get greedy though. I'm not going to scan major sections of the document :-)

  • In with the new...

    John Anderson01/12/2020 at 00:43 0 comments

    Now I needed to figure out how to install the new input switches and button. I started by laying out a faceplate design to scale using the open source drawing software Inkscape on my PC. I set it up to use mm for the scale.

    I then printed this to paper and cut it out. Using it as a template, I cut a piece of 1/16th inch aluminum. Note, I put painter's tape on the face of the aluminum plate before working with it. This prevents it from getting scratched up while cutting, filing, and drilling on it.

    I then taped the paper cutout I printed earlier to the front of the aluminum plate. It'll be the template to drill the holes to mount the button, rotary switch, and thumbwheel.

    Then I drilled the six holes as they were marked in the template. To get the square hole to mount the thumbwheel, I used one of the small square files pictured and squared the sides of the drilled holes. I then took a jigsaw with a metal cutting blade and connected the four holes along the outer lines marked by the template. I was very careful not to cut or file beyond the thin line marking the rectangle. If I didn't cut enough with the jig saw, I cleaned up with the files until the switch fit nicely.

    Notice that the switch has a small 1 mm bezel around it. This will hid the small imperfections of the square hole I made with the drill, files, and jigsaw. Unfortunately, I don't have a picture of it.

    Lastly, I took the drill and jigsaw and cut the larger rectangular hole in the front faceplate of the case there the original switched and connectors were located. This rectangle was roughly 10 mm smaller than the faceplate I just made. I then positioned the new faceplate on the front of the case and drilled four 1/16" holes in the corners through the case and riveted it to the case. Here's how it looks installed with the new switches.

  • Out with the old...

    John Anderson01/11/2020 at 23:54 0 comments

    Now that I had the control board proven and integrated with the nixie displays and power supply, I needed to figure out how to install the input switches and button required. To do so, I first needed to remove the old rotary switches and banana style connectors.

    The wires connecting these to the PCB are soldered to the board. I cut them at the board so I didn't have loose wires shorting to things they shouldn't. The exception was the two wires that switch the 110V AC on/off. These two wires originate at the power transformer and fuse at the rear of the PCB. They pass under the PCB and pop out under the left rotary switch and connect to the back of it. I clipped the wires there to leave plenty of slack so I could run them to a new on/off switch. The red arrow in the picture below points to these two wires where they connect to the rotary switch. The blue arrow points to a fuse you can remove along with the banana style connectors.

     Once the the switches and connectors were removed from the faceplate and the cut from the PCB, I removed the PCB from the case. At this point, it looked like this.

    Next, I drilled out a 3/4" hole in the rear faceplate of the case to mount the power rocker switch. Using a step bit made this easy. Then I used a small square file to notch one side of the hole for the key that prevents the rocker switch from rotating in the hole.

    It looked like this when I pressed the switch into the new hole.

     Next I crimped a couple blade connectors to the AC on/off wires I trimmed for the rotary switch earlier.

    At this point, I was ready to start laying out the new switch interface and figure out how to make it work with the existing faceplate.

  • Getting started...

    John Anderson01/09/2020 at 00:50 0 comments

    As mentioned in the details of the project, this mutlimeter was originally a kit that DeVry students assembled during their course work. So, there is some design documentation and even a schematic available for it if you do a little searching on the inter-webs. I couldn't find any original Bell & Howell or DeVry documentation of this actual device. But, I quickly discovered it's based on a Heathkit IM-1212 digital multimeter with nixie tube display. A brief search turned up a pdf version of the original Heathkit assembly manual. The same search also turned up some confusion around who owns the Heathkit intellectual property and their intentions. So, I won't post the full assembly manual here. But, I will provide a couple relevant excerpts. If you want more detail, you can easily find the same IM-1212 Assembly Manual. There's also a good overview and description of the circuit design for this meter on Mr ModemHead's blog. You can find it here:

    For dice tower application, I wanted to reuse the case, 7441 decoder/drivers, and nixie tube display.  But, after a little research and reverse engineering, I realized it could also reuse the power supply as well. Doing so would require hacking up the single large PCB, or just leaving it in place and adding my simple protoboard with AVR.  There's plenty of room, so I left the PCB as it was.

    Now I just needed to figure out how to connect the new stuff to the old stuff. Glancing at the schematics, BOM, and part details it quickly became obvious that this could be simple.

    That's the whole schematic. It's not very useful at full view, the scan quality is low. But if you zoom into the upper right quadrant, you can see the detail needed.

    IC6 and IC7 are 7490 decade counters. They count the clock cycles generated by the single-slope voltage-to-time ADC (see the Theory of Operation as it's described in the link above). Since I'm ditching all the analog multimeter functionality, I don't need those. Conveniently, they are directly connected to the 7441 decoder/drivers that I do want to interface. In addition, the 7490's require Vcc (5V) and GND, and they are socketed on the board. So, those sockets have everything I need to interface my controller board with the nixie displays and power supply.

    I located the parts on the board (labeled 1 and 2).

    Popped them out of the sockets, trimmed a couple socket (female) headers to length, and installed in the sockets to give clearance for the controller board. Note: I also removed the old rotary switches in this picture. I'll document that in another upcoming log.

    I decided to test this approach before warming up the soldering iron. I pulled out my breadboard, jumpers, and ATtiny88 and wired up Vcc, GND, and 4 pins of one of the ports, configured them as outputs, and wrote some values to it. It worked. 

    Now confident the approach would work, I trimmed a couple single row headers to fit, placed my empty proto-board on the headers, and positioned it as I wanted it. I soldered the headers right there in place so they lined up with sockets perfectly.

    The next step was to pull the proto-board out of the sockets, put it on the workbench, solder down a 28 pin DIP socket for the ATtiny88, wire up/solder Vcc and GND, and then solder the connectors, wire them up, and solder some more.

    It looks like this when completed.

    It's ugly. But, it works :-)

    I glossed over some detail there and I'm not going to provide a schematic for the controller board. It's just some wires connecting the processor pins to Vcc, GND, an ISP port, and 5 connectors. I soldered it up looking at a pinout diagram for the ATtiny88. If you need some help wiring up a 6 pin ISP port for the AVR, checkout this Atmel document for more information: AVR ISP User Guide

    I'll document which ports connect to which IO functions in the log covering the project software later this week.

View all 10 project logs

Enjoy this project?



Ken Yap wrote 01/09/2020 at 19:47 point

👍 I like your recyling elevator pitch. More ideas to digest.

  Are you sure? yes | no

Dan Maloney wrote 01/08/2020 at 16:56 point

I love the look of this, really brings me back. That turquoise crinkle-finish paint! I can practically smell what the inside of the was like before modding. Nice job!

  Are you sure? yes | no

John Anderson wrote 01/08/2020 at 23:16 point


That's exactly what I was trying to capture. The patina is even better in person.

Stay tuned. I've got lots more retro donor devices and several project ideas in the same vein.

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates