Base-32 Binary Code Poker Chips

When teaching people about the basic concepts of information science and how computers work, I find that people can struggle with the abstract but fundamental idea of digital data being made up of “zeroes and ones”.

To illustrate how “zero” and “one” are just the two mathematical meanings to represent a binary code in anything that can be in one of two states (such as “heads” or “tails”), I made this set of coins, patterned in the style of poker chips, where each chip stands for a single bit, a binary digit in a five-bit number.

(As seen at Prusa User Group Meetup Seattle 2023!)

Features

Even though there are only five bits, these chips can distinctly represent 32 possible values, enough to represent every written decimal digit and Latin letter (with a little ambiguity around I, O, and U). Around the edge, these values are represented with their corresponding symbol in Douglas Crockford's Base32 encoding: each side of each token stands for a 0 or 1, and has 16 characters around the rim that represent all possible values when the bit is in that state in ascendant clockwise order.

Each chip also has a series of concentric circles representing all five bit values for each character on each side, with the most significant bit in the center, and the least significant bit around the edge. The ring for the chip itself will either be solid (for 1) or missing (for 0), depending on the side: the rings for the other chips alternate to cover the values when the chip is set or unset.

The “ones” side of each chip has a small footnote underneath it to denote how much the bit in that position stands for, as increasing powers of two: a quick way to determine the numeric value of the bits is just to look at the number on the bottom-right of the “1” digit (remembering that “G” is 16), and add all those visible numbers together.

Variations

There are two variant "sizes" of chip in this release:

• The Flat chip models are the same size as conventional poker chips (although you may need to use a height range modifier on the top layer to get an exact 3.5mm thickness). While simpler, these loose chips are also harder to flip and keep straight, which is why I developed the Chainable models. 
• The Chainable chip models are slightly larger (with an even height that will print precisely at 0.2mm), so as to accommodate something like a 2mm rod or ball chain threaded down the middle: this can be used to keep the chips “skewered”, to lift and/or spin them for flipping (deliberately or randomly), and even to wear them as a necklace.

Printing

I haven't had chance to print this revision yet (hence why this model's cover image is a POV-Ray render); the photos attached are of an earlier prototype I printed using my MMU, where each chip's non-zero had the digit it stood for instead of a “1” (which ended up making the “binary” aspect that much harder to follow: you can render that version of the models by downloading the attached SCAD and changing obverse to a value other than "verbose").

If you have an MMU, import the models from the _mat0 and _mat1 3MF files into a new project for each chip, and assign the _mat0 model to whatever color you want to represent 0 (in the rendered example, this is the “accent” color for each chip), and _mat1 to the material for 1 (for example, white).

I haven't yet tried making these models without printing both materials, but I believe it should be possible to cast the second material (and optionally the first) in epoxy resin: just print the _mat1 model for each chip, and then insert that (or a molded cast of it) into a simple cylindrical mold, which you can create either by printing the _inner_vase and _outer_vase vase-mode cylinders in flexible material, or by printing the _positive in a rigid material and making a mold of that (you may wish to remove the negative volume from chainable_chip_positive if you don't plan to run a rod through the mold as it cures to keep the through-hole clear).

Usage

If you pick any specific character within the set, the only way to have that character on the face of all five chips is to flip them to the correct bit. You can use this to do a “mind reading” trick, where you just ask someone “is the letter/initial on this side", and if not you flip the chip (or you keep them all face up/down, and just remember the bits in your head).

Because of the inner circles, you don't need all five chips to encode/decode values: you just flip the token to the side of the chip's corresponding bit, and then follow the circles from the most-significant bit in to find which character it belongs to. (If you only print one chip for this purpose, I recommend chip4, as its two sides being the characters above/below F/G make it the easiest one to find encodings on.)

You can use these as a kind of “encoder/decoder ring”, for writing “messages”: take something like a punchcard and punch out a message (using “0” for the letter “O”, “1” for the letters “I” and “L”, and “V” for “U”). You can then use the chips to look up each character in the message, although you'll still need to come up with some kind of "out-of-band" convention for punctuation (including spaces between words): on a reel of 8-bit-wide punch tape, you can use the last 3 bits for this.

You can also use this for something like a “Simon Says” game, where each player has a token from chip0 to chip4, and needs to determine if the number/letter “saying” each command applies to them (based on whether it's on the “0” or “1” side of their coin).

Customizing

I've included the OpenSCAD source I used to generate these models as pentacle-coins.scad, if you would like to customize the font, characters, or size. To re-render all the models, I use a Bash script that looks something like this:

: ${OUTPUT_DIR:=render}
: ${OUTPUT_FORMAT:=3mf}
: ${EXPORT_FORMAT:=$OUTPUT_FORMAT}

for order in {0..4}; do
  echo "Rendering chip $order"
  for mat in {0..1}; do
    openscad -o "$OUTPUT_DIR/flat_chip${order}_mat$mat.$OUTPUT_FORMAT" \
      -D CHIP_ORDER=$order -D CHIP_MAT=$mat \
      --export-format "$EXPORT_FORMAT" pentacle-coins.scad
    openscad -o "$OUTPUT_DIR/chainable_chip${order}_mat$mat.$OUTPUT_FORMAT" \
      -D CHIP_ORDER=$order -D CHIP_MAT=$mat \
      -D chip_diam=42 -D chip_thickness=4.8 -D through_hole_diam=3 \
      --export-format "$EXPORT_FORMAT" pentacle-coins.scad
  done
done; fi