Close
0%
0%

BeanDeck

BeanDeck is a portable, self-contained Z80 computer combining keyboard, TFT display, and removable cartridge storage

Similar projects worth following
413 views
0 followers
BeanDeck is a portable, self-contained Z80 computer combining keyboard, TFT display, and removable cartridge storage. Built on the proven BeanZee CPU board (64KB 10MHz Z80 with USB interface) and BeanBoard keyboard/display interface (QWERTY keyboard, 20x4 LCD), it extends these designs with an 800x480 colour TFT display via RA8875 controller and removable EEPROM cartridges for standalone operation, creating a complete computing platform reminiscent of 1980s home computers, but with some modern comforts.

This project is sponsored by PCBWay and I will share my experiences working with them as the project progresses.

Development Roadmap

Phase 1: SPI Display Interface (Current) BeanBoard expansion PCB with 74HCT299 providing multiple hardware SPI interfaces, initially for the RA8875 TFT display controller. This enables text/graphics output on a colour display. The hardware SPI gives improved performance over a software (bit-banged) SPI implementation.

Phase 2: Cartridge Storage Removable EEPROM cartridge system for program and data storage, eliminating dependency on a USB host computer. Enables truly standalone operation - load from cartridge, save data / state to cartridge, swap programs without external tools.

Phase 3: System Redesign* Complete revision of BeanZee, BeanBoard, and SPI interface incorporating lessons learned. Unified design, optimized PCB layouts, and cyberdeck enclosure.

Core Components

  • BeanZee Z80 CPU board
  • BeanBoard QWERTY keyboard
  • BeanBoardSPI SPI interface board
  • 800x480 TFT display with RA8875 controller
  • Cartridge slots for removable EEPROM storage
  • Integrated battery power supply and enclosure

Technical Details

At the heart of the system, the BeanZee CPU board has a 10MHz Z80, 32K ROM, 32K RAM and a UM245R USB module. There is an onboard monitor program (Marvin) which supports multiple consoles for input/output - e.g. USB and BeanBoard keyboard, LCD display and colour TFT display.

The BeanBoard keyboard implements an 8x8 matrix electronically - which is scanned directly by the Z80 - and is physically arranged as 16 columns by 4 rows, providing a sort-of traditional QWERTY layout. It also has a 20x4 character LCD display and includes an 8-bit GPIO for experimentation and interfacing.

The new hardware SPI interface uses a 74HCT299 universal shift register. This dedicated board eliminates GPIO bit-banging, improving performance, and was done specifically to make the TFT display more usable.

An Adafruit RA8875 TFT controller board is connected via the hardware SPI. This provides a 7.0" 800×480 pixel colour text and graphics display.

A cartridge system provides removable EEPROM storage, allowing multiple programs with data on removable media - a key feature making BeanDeck a proper self-contained computer rather than a development board. THis is not banked ROM, but rather programs and data are transferred to and from cartridge to RAM by the Marvin monitor.

Software Support

Marvin monitor provides a basic console, either over USB or the BeanBoard peripherals, and is able to load and execute programs, or inspect memory. It will be extended with RA8875 driver, EEPROM cartridge support, and extending console support to the TFT display.

Related Projects

Evolution from Z80 Breadboard Computer  through BeanZee development board to complete standalone system

Sponsorship

This project is sponsored by https://www.pcbway.com/  who are providing PCB manufacturing for the BeanDeck system boards. I will use this opportunity to evaluate their services and appreciate the support they have offered.

  • Z80 SPI board

    Stephen Willcock02/27/2026 at 08:14 0 comments

    The BeanBoadSPI PCB is now assembled and tested working with a RA8875 controller and TFT display panel. I puzzled over timing for a couple of weeks... turned out to be a design flaw hiding in plain sight...

    PCBs arrived from PCBWay - who have kindly sponsored this build - five copies of a 200x80mm four-layer board, looking clean. Assembly was straightforward: ten DIP sockets, seven SPI connectors, jumpers for clock selection, decoupling caps throughout, and the BeanBoard edge connectors. Nearly done when I discovered I was missing a 74LS02 (NOR gates) - not in my parts box. A few days' wait for an RS order, then it went in and the board was ready.

    First test was a Z80 loopback: read a char from the console, send via SPI, read back, echo. With MOSI and MISO bridged, whatever goes out should come straight back. It didn't work reliably with the clock divider set up as it had been on breadboard: CLK/4, but switching to full speed (CLK/1) worked perfectly - CLK/2 too. I noted it as odd and moved on. That was a mistake.

    Adapting the RA8875 display driver to use hardware SPI in place of bit-banging confirmed the problem. CLK/4 fails with "RA8875 error", CLK/2 works. CLK/1 fails again. Slower is worse - which makes no sense on the surface.

    Debugging was methodical but took longer than it should have. Software delays made no difference. My oscilloscope confirmed all three clock signals were present and correct on the jumpers. A register dump from the RA8875 showed register 0 coming back correctly but everything after it as garbage, in a suspiciously regular repeating pattern.

    I tried resetting the clock divider flip-flop on each write, reasoning that the free-running divider phase might be causing the RA8875 to see unexpected edges. In simulation this appeared to help, but wiring it into the full simulation killed all serial output entirely - resetting the flip-flop on /WR holds the divided clock low throughout the write cycle, so there's no rising edge to trigger the 74HCT299's synchronous load.

    That was the lightbulb moment. The 74HCT299 only captures bus data on a rising clock edge - not when the load signal is asserted. At CLK/2 the Z80 write pulse is long enough that a rising edge always falls within it. At CLK/4 the edges are 400ns apart and the write pulse ends first. The shift register never captures the new data and quietly retransmits whatever was already in it. Because the divider runs freely this is intermittent in general, but becomes a consistent pattern when software loops regularly - hence the repeating garbage in the register dump.

    This is a design flaw. I'd noted the synchronous load but didn't fully think through the timing implications at divided clock speeds. My simulation didn't model the Z80 write pulse width accurately; I was stepping through manually. Real hardware found the problem for me.

    For now CLK/2 works well enough to keep development moving. The design will need a revision before CLK/4 is usable.

    Full write-up on the blog: [link]

  • Hardware SPI design

    Stephen Willcock01/20/2026 at 09:06 0 comments

    Core to the BeanDeck design is to incorporate a 7" colour TFT display using the Adafruit RA8875 controller. This has an SPI interface and having got this working using software controlled (bitbanged) SPI, I have been working on a hardware design in the hope that this will improve the slightly sluggish performance.

    I was pleased to get something working on a breadboard, and now I have spend some time taking on feedback and refining the design: beanboard-spi-interface

    This works in the Digital simulator, and so now I'm ready to get to work on a PCB. I want the interface to plug into the BeanBoard PCB. The BeanZee CPU board and an LCD module already plug into the BeanBoard, which makes it a little challenging - I'm wondering if I can keep the LCD, or if it should be removed to allow for the SPI (and by extension, the TFT display).

    There's now a new GitHub Project for the SPI interface: https://github.com/PainfulDiodes/BeanBoardSPI

View all 2 project logs

Enjoy this project?

Share

Discussions

Similar Projects

Does this project spark your interest?

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