RFC Model 1

For a long time, I have wanted to develop a simple Android-based gaming console capable of running retro system emulators in a native hardware environment.

The initial inspiration came from the C64X, which was a replica of the Commodore 64 case with a modern ASCII keyboard and a mini-ITX motherboard slot, but with no internal components. While I liked the core concept, I saw it as more of a cash grab. On the other end of the spectrum, there was the Raspberry Pi 800, which is a true modern keyboard computer, but to me, it feels more like a screenless laptop.

So, I decided to take a different approach and create something that would better cater to retro gaming enthusiasts—a new and exciting home computer prototype.

+++This is an early prototype, there can be imperfections in the overall design.+++

About the development

My main design principles were:

It should resemble 1980s Japanese computer design but with a neo-cyberpunk aesthetic.
It must have a high-quality mechanical keyboard similar to the MSX2.
It should include a low-cost integrated hardware system capable of running Android or Linux and supporting PlayStation 1 emulation.
It must feature a mini-ITX slot, allowing a PC motherboard to be installed easily, extending the case’s economic lifespan and enabling more advanced emulation.
If it ever goes into production, it should be as affordable and simple to manufacture as possible.

Since the keyboard’s circuit board would need to be adjusted to fit the case later, it made the most sense to design the case first.

As I frequently use the Midjourney AI image generator for visual brainstorming, I generated dozens of concept renders with it.

I am attaching the original concept render and the final 3D model:

futuristic msx af7ea882-283e-46fd-8fb5-76a3394ab1bd.jpg

I initially created the 3D model of the case in 3ds Max, but later I started over in Fusion 360 because it was important to use a CAD-CAM software for potential future metal mold milling.

Since I occasionally work on injection molding machines, I knew what aspects to focus on during the design process.

The design considerations included:

The surfaces should not be too thin.
The shape should not be concave to avoid molding issues.
The case should consist of two main large components and possibly several smaller plastic parts.
Screw mounting points should be sturdy and not prone to breaking.
Good ventilation must be ensured for the components.
The keyboard PCB should not collide with a potential ITX motherboard, ensuring efficient space utilization.

Fortunately, I found highly accurate reference models on GRABCAD, which I virtually positioned in advance to streamline the design process.

The case design took about a week since I ran into a few dead ends. As it turned out, this was a fairly complex 3D model, but most importantly, it was now ready for mass production.

At the time, my 3D printer wasn’t working, so I had the prototype manufactured by PCBWAY.

With the final case design completed, I moved on to the hardware components. Since keeping the cost low was a priority, I performed preliminary calculations and decided that the system should have two PCBs:

A larger one for the keyboard
A smaller one for the cursor keys, which would also house the low-cost hardware system

Keyboard Layout Design

My first task was to create the keyboard layout, for which I used keyboard-layout-editor.com. It required a GitHub registration, but within half an hour, I was able to create the QWERTY layout.

I kept the key count minimal, ensuring that keys were slightly offset for better ergonomics, especially placing WASD keys in a comfortable position. Once the layout was finalized, I exported it to KiCad.

PCB Design

Using KiCad was an obvious choice, as it provided an easily downloadable Cherry MX keyboard library.

To save space and simplify manufacturing, I decided not to use a separate Raspberry Pi but instead integrate it directly into the board.

Since the keyboard matrix consists of 14 columns and 6 rows, I chose to integrate an RP2040 microcontroller, which has 28 GPIO pins. This left me with 8 free pins, so I added extra connections for future expansions, such as a top LCD display or an RGB LED controller.

The PCB is a simple double-sided board, meaning traces are present on both the top and bottom layers.

I placed all circuit components on the opposite side of the keys to prevent them from falling off due to intense typing and to make soldering easier.

Capacitors and resistors were designed with a minimum 0603 footprint.
Diodes were placed at each key connection point, as the RP2040 wouldn't detect key presses without them.
Since precise impedance matching wasn’t necessary, I used 0.2-0.3mm trace thickness on a 1.6mm-thick PCB.
For power rails, which generate heat, I used 0.5-0.6mm trace thickness.
Since there is no internal ground plane, I applied the polygon pour technique, ensuring that all grounding connections were properly made with sufficient copper coverage.

In the end, I was very satisfied with the circuit design.

I added:

Breakout connections for the unused GPIO pins
Matrix connection headers for linking the two PCBs
A USB Type-C connector

After exporting the design to Fusion 360, everything aligned perfectly—including space utilization and mounting points.

Finally, I exported the Gerber files, packed them into a .zip, and sent them to JLCPCB for manufacturing. I also ordered the key switches from AliExpress.

Next, I needed to design the PCB for the cursor keys, which had to accommodate a microprocessor, RAM, PMU, SD card reader, DC-DC converters, USB, and HDMI outputs—making it a more challenging task.

Since keeping costs low was a priority, I took the risk of designing it as a simple two-layer board.

Core Hardware Selection

For the heart of the system, I chose the Allwinner H616 SoC, a quad-core processor that had:

Plenty of online documentation, including BGA pinouts, example circuits, and firmware
Good availability for ordering
Low cost, making it a popular choice in TV boxes and gaming consoles

For memory, I selected:

2GB LPDDR3 RAM
16GB Samsung eMMC storage, both well-documented and reliable

Schematic & Layout

The schematic ended up being three pages long, relatively simple.

I followed these design principles:

All components were placed on the opposite side of the cursor keys, not directly underneath them, but slightly higher to prevent mechanical stress during typing.
I designed a custom ergonomic layout for the cursor keys in Fusion 360, taking inspiration from MSX home computers.
Components were arranged to minimize crossing traces, with the LPDDR3 RAM and crystal oscillator placed close to the H616 SoC.
I routed all necessary pins from the H616, then proceeded to wire up the RAM and bypass capacitors.
Differential pairs were given sufficient space, separated by ground polygons when necessary.
The RESET circuit was positioned far from the power rails to avoid interference.
Length matching for differential pairs was ensured, so I was satisfied with the signal integrity.
Vias were simple thru-hole, reducing manufacturing costs.

Impedance Calculations & Final Touches

Since impedance control was crucial:

Signal traces were designed for 50Ω, USB for 75Ω, and HDMI for 100Ω.
I calculated the exact trace thickness using the Saturn PCB Toolkit, entering the necessary parameters.
I also placed test points throughout the PCB for debugging and testing.

Naturally, I used thick traces for the power rails and filled any remaining space with ground polygons.

After completing the design, I exported the Gerber files and sent them for manufacturing, requesting an impedance analysis as well. Since the exact impedance values can only be determined after production, this step was necessary for verification.

I designed custom-shaped cursor keys with RGB lighting, so I 3D-printed them using the Anycubic Photon Max resin printer with transparent glass resin. The result turned out very nice.

Meanwhile, the 3D-printed case arrived from China, so I began the surface finishing process.

Sanding – I used sandpaper to remove as many imperfections as possible, as well as the waxy surface layer left from the 3D printing process.
Smoothing – To achieve a smooth surface, I applied two-component modeling plaster, which adheres well to PLA plastic.
- I quickly mixed 1 part resin with 6 parts plaster and applied it evenly to the treated surfaces.
- I let it cure for a full day.
Final Sanding – On the second day, I used fine sandpaper to carefully smooth the case’s surfaces.

After dust removal, the case received a primer lacquer coat, which revealed a few minor surface imperfections. I carefully refined these areas once more.

Finally, the main part of the case was coated with matte blue lacquer, the bottom was painted black, and the remaining sections were finished in gray.

After that, I machined the missing parts with a CNC, then hand-soldered the components using tweezers and a hot plate.

I have mostly assembled the machine for a quick photo, but there is still a lot of work to be done.

The current result can be seen here: