32Blit unboxing and first impressions


Nearly a year ago, I backed a Kickstarter for a retro-focused, handheld gaming console. Now, there are a *lot* of these out there thanks to the ready availability of powerful hardware and just in time manufacturing. It may seem that there's little reason to support this one compared to all the others, but the 32Blit seemed...different.

For one thing, the 32Blit is a project from an established company in the maker space, Pimoroni. I've been a fan of them since I bought a PiBow case for my very first Raspberry Pi. While the Pi itself doesn't get much use, I still very much enjoy the small, colorful case. It's a joy a take apart and reassemble, with clear numbers on each case layer so you don't get lost.

I turned to Pimoroni for the Cardboard Pi's display. Despite a calibration and noise setback, Pimoroni was happy to mail me a replacement. Later on, I discovered the problem was due to an X.org issue, and not the hardware itself. ....whoops.

So, when they announced the 32Blit it immediately caught my interest.

One thing that sets the 32Blit apart from other similar efforts on Kickstarter and other crowdfunding platforms is the fact that the games themselves are not the primary goal for the device.

The 32Blit is intended as a learning platform. It helps you to learn coding, game programming, and interacting with microcontrollers. The software library -- still in development -- will include tutorials, asset libraries, and other material to make learning game programming more accessible. There's nothing about the hardware itself that will blow you away, but the combination of playfulness, ease of use, and learning focus is rare in this space.

I signed up to be a Beta Backer for the 32Blit. While this was a cheaper but limited availability tier, it had the advantage that it would arrive far sooner than the final, completed product. It also came with a hefty warning: This wasn't for anybody. From the description, it was possible that what would arrive would be anything from a bare PCB to a nearly final product. Soldering was to be expected.

The warnings made the beta unit more attractive to me, rather than less. I know my way around a soldering iron, and I'm fine with it being buggy or incomplete. I wanted to learn, even if that came with frustration. Furthermore, I felt I had missed out on an opportunity with the PocketCHiP and didn't want to miss out this time.

The Beta Backer kit is indeed plain. The box itself is matte, off-black, with a white and green sticker on the top. On opening, you're greeted with a brief introductory letter reading "AHOY". Pimoroni has a bit of a pirate theme, which adds to the fun. The letter offers thanks, and gives you links to resources. This includes a forum, Github repository, and a chatroom. It's fairly spare, but it's enough to get started and a nice touch.

The Beta Blit is spare for a piece of consumer electronics, but lavish for a prerelease development platform. All the parts are already installed save for a battery. This makes the device functional out of the box. It's essentially four PCBs layered together into a single unit. To protect the circuits on the opposite side of the PCB, an acrylic panel is provided with standoffs.

Instead of being blank copper or exposed epoxy board, the Beta Blit's front is embellished with a Zelda-esque top-down RPG scene printed on the solder mask. Metal tracings make occasional accents. The overall effect is really rather charming. It still feels grabbable, even though the hardware is very much exposed.

After peeling off the opaque protector sheet on the acyrlic back, you're presented with the 32Blit's business end. All the components are neatly laid out, without a single "bodge wire" to be found. Furthermore, it's broken down into functional blocks and clearly labeled on the solder mask. They even provided a few solder pads for you to add your own external controls! This was an unexpected treat, and one I really appreciated.

The beta unit is, notably, sold without a battery. This means you need to either plug in the device to use it with the provided USB cable, or supply your own battery. Fortunately, the Blit supports standard Lithium Ion batteries with standard JST connectors. Ample space is provided on the board for this very purpose. There's even an on-board temperature sensor for battery safety. While you can get a compatible battery nearly anywhere, other beta testers suggested a 1200 mAh battery from Adafruit, which is a perfect fit. Installing the battery only requires a screwdriver to remove the acrylic back.

Once installed, the 32Blit does feel a little unbalanced, but only barely. The battery compensates for the components and speaker on the opposite side of the board well, giving the device a good feel.

Contrary to my expectations, the 32Blit was already loaded with a firmware out of the box. It powered up, displayed the firmware version, and provided a system overlay menu displaying the battery level, brightness, volume, as well as two modes, "DFU" and "Shipping".

Without the battery installed, the level indicator behaved erratically. Often it would bounce between fully charged to empty multiple times a second. Eventually, the indicator calms and reads as no battery installed. I suspect this is only a problem to be seen in the beta units, as they don't come with batteries out of the box. Stray capacitance between the pins might be enough to confuse the charging circuitry. Once the battery is installed, however, the problem vanished and the level indicator behaved as expected.

The default "OS" seemed very spare, but as I later found out, this wasn't an OS in the sense we're familiar with it today.

Today we think of every portable device, game console or otherwise, as having some kind of managerial interface separate from applications. It helps us to load games, manage their storage, and so on. The 32Blit, however, is more like a cartridge system from the early 2000s. There is no separate OS from the game the device plays, it's all one program.

To load a game on the 32Blit isn't as simple as copying a binary onto an SDCard, you need to compile and flash the program yourself. For many embedded devices, this often requires an additional "programmer". This device acts as a USB gateway from a laptop or desktop to the underlying hardware of the Blit. A multi pin port on the top of the console is where you would plug in this programmer. While there are forum posts recommending which programmer to use, I was relieved to discover that they were no longer necessary with the preloaded firmware. Now you only need the correct software on your workstation, and a USB cable!

This just left the last problem: getting the software. My primary system is Arch Linux. It's not the friendliest of distros to work with, and sometimes getting firmware for embedded devices to compile is an adventure in of itself. I fully expected to need a few days to sort that out. In the end, however, I started uploading firmware in about an hour.

The 32Blit is built around an ARM based, STM32 microprocessor. As such, you'll need to find STM programming tools.

First, we need to install some libraries to support the Blit's CPU, including compellation support:

sudo pacman -S arm-none-eabi-gcc arm-none-eabi-newlib

While the above was all I needed on my system, it's possible that my previous work setting up the QMK firmware environment resulted in some of the needed packages being installed. Don't consider the about comprehensive.

Then, we need to install some additional utilities which are used to transfer any compiled firmware to the 32Blit:

sudo pacman -S stlink openocd

While working with the Blit, I also found out I needed to install some additional Python libraries from AUR, the Arch User Repository. It's possible this is not required, but it seemed to help me:

yay -S python-bitstring python-construct

Finally, we need to clone the git repo:

git clone git@github.com:pimoroni/32blit-beta.git

With that done, the development environment is ready to build games!

The Github repository includes an examples/ directory which show's off the devices functionality, although none of them are really "games", at least, not yet. Probably the best one to start with is the hardware-test example, which gives you some idea of the Blit's capabilities.

To compile the example from the command line, you need to change to the example's directory, create a new build.stm32/ directory, then run the build:

cd path/to/32blit-beta/examples/hardware-test
mkdir build.stm32
cd build.stm32
cmake .. -DCMAKE_TOOLCHAIN_FILE=../../../32blit.toolchain

The above procedure is the same for any of the examples, not just hardware-test. Just change to the appropriate directory, and then do the remaining steps.

Also, the name of the build directory is significant! The name build.stm32/ indicates that this build is targeted to the 32Blit hardware. If you were to use just build/, the development environment will assume you want to build the example to run on your laptop instead. This is confusing at first, but it's actually wonderful. All 32Blit examples can either run on the hardware, or as an application on your laptop using the Simple DirectMedia Layer (SDL). This means you can test your games repeatedly without needing to run them on actual hardware. It also means you can start writing games for the 32Blit right now, even if you don't have any hardware! Neat!

Loading compiled games onto the Blit is more complex than you might expect. Again, you can't just copy something to an SDcard. You need to re-flash the Blit's hardware itself. As mentioned above, we no longer need a special programmer board to flash the hardware, only USB.

I was hoping that like the QMK firmware, the make command would prompt me about what to do next. For QMK, that usually involves connecting the keyboard via USB and pressing a hardware reset switch on the device. Unfortunately, the 32Blit gives you no such prompt, leaving you only with a compiled binary. For hardware-test, the binary is hardware-test.bin.

After doing some more digging, I eventually found the procedure to flash the firmware:

  1. Connect the Blit via USB to your computer.
  2. Hold down the X and Y buttons and then press the reset switch on the top.
  3. Alternatively: Press the menu key, use the D-Pad to select "DFU", and press A.
  4. Either way, the screen will go dark instantly. That's okay! Now we're ready to load.
  5. Enter the following command, replacing the hardware-test.bin file with one for your example:
    sudo dfu-util -a 0 -s 0x08000000 -D hardware-test.bin
  6. When the terminal returns control to you, hit the reset switch on the Blit.

Once that's done, your 32Blit will have a new example loaded on it:

Video file

While hardware-test is what I'd recommend you start with, it's by no means the only example in the Github repository. There are several others, in various states of functionality:

Again, all of the examples are pretty basic given the unfinished state of the 32Blit library. The platformer example also seems to be buggy. The character doesn't jump or respond to obstacles, and has a green overlay for some reason. This may not be a bug, but simply unfinished code.

The raycaster example, however, is a standout. Again, like the original DOOM, this is a raycaster where you can explore a 3D environment. It comes complete with a weapon overlay (a spraycan) and it's own "doomguy". When I start looking at code, this one will be at the top of my list along with platformer.

Video file

So far, the 32Blit Beta Backer Kit shows a lot of promise. It's a fun, enjoyable little piece of hardware that works surprisingly well. While I did experience some issues, most of them were related to either incomplete software or documentation. Both of which are completed expected at this point in the project. What does work is superb. About the only complaint I have about the hardware is the speaker is a bit quiet, and there's no headphone jack.

While the beta unit is intentionally spare in a lot of ways, I hope that Pimoroni will consider continuing to sell similar units as the "hacker edition". It's much more fun without a complete case in the way, and it showcases the hardware design extraordinarily well. While I love the idea, I admit it may not be feasible from a manufacturing or product support perspective. The worry being that cash-strapped organizations may be the hacker edition despite the additional delicacy it has.

While that's the end of this unboxing, we're not finished with the Blit yet. Next we'll start to look at the software.

All parts and materials to make this project were paid for my supporters. If you like this post, consider becoming a supporter at:

Thank you!!!