(the open source balance board)

HOME            CONTACT

What is it?

This website is intended to hold information regarding the Statera-64 project.
This project is still under development and the goal was to present it to the main public at the Commodore meeting in Maarssen oct 2020, unfortunatley, due to the COVID-19 situation all meetings are cancelled and since there wasn't any clearity on when a new meeting would be possible, development was stalled and focus shifted towards other projects. It is now uncertian when the release data will be. The project isn't cancelled, it simply is too much fun and way to far developed to abandon it.

The word "Statera" is Latin for balance and the number "64" refers to the Commodore 64. So you may draw the conclusion that this project is for retro computing purposes and stop reading there. But that's not the whole story behind the Statera-64. Because this device is based around a microcontroller that has native USB capabillities it means that it can also be connected to your PC or anything else that has a USB port. So this opens up a whole new world of controlling existing games and programs or new programs that are specifically written for use with this board. Now this device can detect how it is connected, if it is connected to an old computer it will go into retro mode and if it detects a USB connection, it will act like a USB HID device, like a mouse or game controller.

Regarding the Statera-64 retro computing:
The idea behind this project is to be a fully open-source balance board that is completely compatible with all sorts of existing games for the Commodore 64 computer. It certainly will enrich the gaming experience of existing games and for some games it will even dramatically improve the playabillity. But most of all... it will be fun. You can connect up to four Statera-64 devices to a Commodore 64 computer, just imagine the fun you'll have on parties.

This project is a combination between the joy board of the 80's and the Wii balance board of the past decade. Meaning that the Statera-64 is a very sophisticated and sensitive measuring device that is able to generate the signals of a joystick, a paddle or even a 1351 mouse. Meaning that it can interface directly to your retro computer like the Commodore VIC-20, C64, C16/+4, C128. But technically speaking, it can connect to any other computer with an Atari compatible joystick connector, although the timing for the paddle signals needs to be adjusted for that specific system). This balance board does not have any switches, so it doesn't make any noise when you use it.

Regarding the Statera-64 modern computing:
(this is still under development, I'm concentratingon the retro computing part first)

Why this project?

A long time ago, visiting the local thrift store, I found three wii balance boards. And instantly the tinkerer in me was inspired, because these boards were cheap and looked clean enough to be functional, I bought them all. I thought that this was a good idea because I'm already familiar with the ESP32, which has bluetooth, so at that time it seemed to be good idea to use this controller for connecting these balance boards the C64. To simulate paddles, so that I could play pong using balance boards.

History of this project (how I wanted to make it... but didn't)

Unfortunatley... I had "some" trouble in connecting/pairing the Wii balance board. And not knowing any technical detail about bluetooth didn't help. Also the limmited options available in the Arduino environment for the ESP32 core at that time didn't help either. So, I had a problem, because I really wanted to use the ESP32 or at least the Arduino development infrastructure to keep the whole design very simple/attractive for all members of the tinkerer/maker community to pickup. So, this all turned out to be rather dissappointing.

Sure, there are some experimental libraries being written by some very clever people. And they claim they can read data from a Wii-mote and since the balance board reports itself as an Wii-mote extension this is very interesting development. But... the Wii-motes that I seemed to have didn't seem to work reliable and if the system isn't reliable on my desk, then how will I be sure if I get it to work reliable for everyone who want to use this project. I certainly wasn't looking forward to emails with all sorts of "it doesn't work" related questions. And according some forum comments found, I didn't seem to be the only one.

But that's not all, how about pairing multiple boards to the same ESP. Or how about the fact that wireless systems always have a tendency to go wrong when being used at crowded places or during presentations when everybody is looking at you. Like, for example, retro computer meetings. And then there is the power supply problem, the ESP32 can be power hungry and I want to connect it to the joystick port of the C64. Which (thanks to some current limitting resistors in the 5V line of those ports) is only rated for 50mA. Now this doesn't have to be a problem, but it can cause all sorts of strange problems. And finally, the balance board requires batteries and these are always empty when you don't want them to be... especially at meetings when you realise that you forgot to bring the extra batteries.

So to make a long story short... I decided that it perhaps was better to throw in the towel and stop pursuing goals that will generate a lot of work to do it right while offering not guarantees to work 100% during the first public demonstration.

After a few months of inactivity on this project, I started to think about it in a slightly different way. Why attempt to make a wireless Wii balance board adapter for the C64? Perhaps I can modify the Wii balance board, rip out the internals and work my way from there? Then again... if I want this project to be made by anyone (who can hold a srewdriver), then perhaps the use of a Wii balance board isn't such a smart idea anyway. Sure these days (2020) Wii balance boards are found in thriftstores , ebay, etc. but never really when you need them. So that doesn't really invite people to build this project, especially a few years from now, when they become rare collector items). And, regarding the people who already (or eventually) own a Wii balance board, they may not feel comfortable modifying it. So why bother using the Wii balance board anyway! How hard can it be to make my own balance board... from scratch! Or to be more precise, from cheap and widely available parts mostly to be found in bulk on the internet.

Again, to make a long story short, building a balance board from scratch isn't that difficult at all. Or at least, it doesn't need to be difficult.

How I eventually made it...

By building every thing around an Sparkfun Pro Micro (clones are sold as Arduino Pro Micro and act like a Leonardo, so this can be confusing, but in the end it doesn't really matter) this can all be made to be very low power, all wired and with full control. The system will be created in such a ways that you can daisy-chain it, allowing you to add up to 4 boards to one C64 computer. And regarding the costs and availabliity, it can be made using currently widely available and cheap components.

The Statera-64 balance board can sense weight and weight distribution by the use of four loadcells/sensors placed on the corners of a board of a size of 50x30cm. Having multiple sensors allows the system to detect if you lean to the left, right, front or rear (or a combination). It can even detect when you make a little hop (you could call that jump detection, but jumping is not really required (a small "hop" is enough). Always keep in mind that jumping can be dangerous an such a small platform.

To measure the applied force to the board (the persons weight) it requires the use of four loadcells (although three is the absolute minimum, four gives a more stable platform and requires much easier math). Reading the loadcells is done with the HX711 scale sensor. This is widely and cheaply available from various sources and in many cases already soldered on development boards. It's even cheaper to buy these development boards in small quantaties then to buy the HX711 IC seperately. The HX711 is also very easy to connect because it has a build in amplifier and ADC with a two wire digital interface. So all it takes is two wires. One data and one clock. And because we have four sensors, we also require four HX711 boards, meaning that this requires five wires to make them all connect to the Arduino board. Not eight wires, because we can combine the clock which is also required for another reason (more about that further on).
Now some of you might wonder why you would need a single board for each loadcell, because the HX711 has a multiplexer input that allows it to interface to two different loadcells. Well, the problem with multiplexing (as it is implemented on the HX711) is that it reduces the sample rate significantly. Meaning that we cannot reach the maximum  possible samplerate of 80Hz, due to the multiplexer it drops down to 16 Hz... which is effectively 8 Hz per loadcell. This is because switching from one input to another requires some time to let the input voltages stabilize. This even is accounted for in the HX711 (which is very smart, since it is impossible for any programmer to forget it, which otherwise only owuld lead to reading of the wrong results). So by using an HX711 for every loadcell we don't need to use the multiplexing feature which means that we can run the HX711 with the max. possible sample rate of 80Hz. We also (for the best results) need to sample the data on all loadcells at exactly the same time. Otherwise the measurents of the balance board will be inaccurate if the user moves to fast. But by using one clock signal for all HX711 in the system, this is solved. Running all HX711 on the same data-clock, not also allows for some very efficient programming. So you can imagine that the standard HX711 libraries that float around on the internet weren't of much use. Fortunately the HX711 isn't complicated to operate so that wasn't an issue at all. For example, if I was to be using a standard library, it most likely would have resulted in an effective sample rate of perhaps 4 Hz, because of the four independent sequential reads. And all of this because standard libraries aren't suited for reading multiple HX711, because seriously, why would anyone want that? Well... we do now! So connecting all clocks to the same IO-pin isn't only required for save IO-lines, although that is a huge bonus.

Now in order to make the HX711 to sample at a max rate of 80Hz, the HX711 board might need to be modified, because in many cases the jumper (solder dot or 0-Ohm resistor) is placed at the location for using a 10Hz sample rate, just changing that hardware setting is enough. Now 80Hz might seem pretty fast for a scale (and it is). But we don't want to use the balance board as a simple scale, we want to use it as a controller... to play games. So technically, while playing a game, a high sample rate is a matter of "winning" or "game over".

<place photo of loadcell here>

Now the loadcells I'm using are simple halve bridge 50kg loadcells, but the HX711 requires signals from full bridge loadcell, so this is a problem. But easily fixed, by using two additional resistors made to act like the missing halve of the expected loadcell bridge. Now the wire colors can be confusing, in a world where red=+ and black =- you would expect white=signal. Well (for the loadcells I worked with) this wasn't the case, so always check your wires before connecting them! In my situation, white=+, black=-, red=signal. Measuring loadcells is easy, for example, if you have 1k loadcell sensors it will result in a value of 2K when measuring between + and -  and measuring between + and signal (or - and signal) should result in a value of 1k.

How to use it...


This project seems to go very smooth... but it's still under development, so there are lot's of things that can go wrong eventually.


My intention is to put everything on my github page, as soon as this is going live I will post a link to that location.

If you have any questions just send me an email, but make sure that you've read the usermanual first.