# PicoCalc: a keyboard and screen kit built around a Raspberry Pi Pico > PicoCalc is a ClockworkPi hardware project that turns a Raspberry Pi Pico module into a portable terminal with a display and a physical keypad, with prebuilt firmware in the repository and full source for building your own. It suits makers who want a self-contained microcontroller terminal with a real keyboard rather than a phone or a laptop, and the repository ships the mainboard schematic, the LCD controller datasheet and an assembly guide, so building one is a documented exercise rather than a reverse engineering project. **clockworkpi/PicoCalc** — A calculator like nothing you've ever seen before, right? - Repository: https://github.com/clockworkpi/PicoCalc - Stars: 742 · Forks: 94 - Language: C - License: not declared - Published: 2026-10-21 · Updated: 2026-10-21 · Language: en - Canonical page: https://hysenlabs.com/projects/clockworkpi-picocalc ## The hardware, not just the firmware PicoCalc is described in the README as a cost-effective portable MCU terminal, and the repository is organised like a hardware project rather than like a software project. That distinction shows up in the top level listing before you read a line of the documentation. There are three PDFs in the root, and they are the core documentation. `clockwork_Mainboard_V2.0_Schematic.pdf` is the mainboard schematic at version 2.0. `ST7365P_SPEC_V1.0.pdf` is the specification for the ST7365P, which is the display controller the board drives. `AXP2101_Datasheet_V1.4.pdf` is the datasheet for the AXP2101 power management part. Alongside them sit `Clockwork_PicoCalc_Assembly_Guidelines.pdf` for putting the thing together and `PicoMite_User_Manual.pdf` for the software that ships on it. The rest of the tree is equally telling. There is a `PCB/` directory for the board files, a `Pictures/` directory, a `Code/` directory for the source, a `Bin/` directory for prebuilt firmware, and a `wiki/` directory for documentation. The presence of a `.gitmodules` file means at least one dependency is pulled in as a submodule rather than vendored. So this is a full hardware project. You are not just downloading a program for a device you bought; you are dealing with a mainboard, a display, a power management chip and a keypad, and the repository is the reference set of documents for all of it. The primary language of the repository is C, the default branch is master, and the last push was on 2026-10-14. The licence is not classified on GitHub, so the terms are whatever the repository itself states or leaves unstated. ## A Pico module, a keypad and a serial port by default The feature list is short, and each line is a hardware decision rather than a software promise. The board supports the Raspberry Pi Pico H and Pico WH series and various compatible modules. The WH is the wireless variant of the Pico module, and the phrase various compatible modules means the design is not tied to one specific module. The hardware is expandable, with SPI, I2C and UART exposed for external peripherals. That is the line that turns this from a pocket calculator into something you can attach sensors to, and the development section names the use case directly, I2C and SPI communication for interfacing with external sensors. Power comes in over USB Type-C, and the README says the port serves a multifunctional design with its default being the Pico's serial port. That default is worth understanding, because it means the USB connection is a serial console as well as a power supply, which is how you would talk to the device and how you would flash it, rather than the port being dedicated to storage or to a debug interface. The other two feature lines are about software and about the case. The keypad and UI are customizable, allowing users to modify functionalities, and the board is compatible with 3D printed cases, which the README calls out as making it an ideal DIY project. The project description asks rhetorically whether you have ever seen a calculator like this before, and the README's own title calls it a terminal rather than a calculator. That framing is the right one to carry into an evaluation: a PicoCalc is a small general purpose machine with a keyboard and a screen, and the firmware you put on it decides what it does. ## Bin/ for people who will not build, Code/ for people who will The repository structure section divides the project into two halves that serve two different people, and the split is the clearest thing in the README. The `Bin/` directory contains prebuilt binary files and firmware images, ready-to-use firmware in .uf2, .bin and .hex form. It is described as useful for users who want to flash the device directly without building from source, and it may include release builds and test or debug versions. The presence of a .uf2 file is the practical detail, because .uf2 is the file format the Pico bootloader copies onto the device over USB without needing a separate programmer. The `Code/` directory holds the source code for firmware and software components: the main application logic, hardware drivers and low-level interfaces, build configurations and toolchain setup, and possibly experimental features and development branches. The README tells you this is the directory to look at if you want to modify functionality, add features or rebuild firmware, and points at it along with the wiki for sample applications and a quick start. The `wiki/` directory holds project documentation and additional resources, described as usage guides, development notes, design explanations and troubleshooting and FAQs. The README frames it as intended to complement the README itself with more detailed or evolving documentation, which is the usual arrangement for a project whose hardware documentation changes as revisions are made. The three release tags tell you what has actually been shipping. The listed releases are multi_uf2_bootloader_0.6 from 2026-03-01, multi_booter_v0.5 from 2025-06-03 and multi_booter_v0.4 from 2025-05-31. All three are bootloader releases, and the naming suggests the progression from a single bootloader to a multi-UF2 bootloader capable of holding more than one image. That is a firmware delivery concern rather than an application concern, and it matters for anyone who has flashed several firmware versions onto a device and needs a bootloader that can present a menu of them. ## Micropython, C and C++ are all on the table The development story offers two different routes, and the choice between them is a real decision rather than a detail. The feature list states support for Micropython and C/C++ development using the Raspberry Pi Pico SDK. The development section then says PicoCalc supports C/C++ development via Pico SDK, and lists what the firmware can be modified to include: graphing functions and scientific calculations, I2C and SPI communication for interfacing with external sensors, and keyboard remapping and custom UI modifications. Those three examples are worth reading as a description of what people actually want to change. Graphing and scientific calculation are the reason a device with a screen and a keypad is interesting at all, since a microcontroller without floating point graphics is a terminal and a microcontroller with them is an instrument. Sensor interfacing is what makes it a platform rather than a gadget, and it lines up with the expanded SPI, I2C and UART on the board. Keyboard remapping and custom UI work is what the customizable keypad and UI feature exists to support. The presence of `PicoMite_User_Manual.pdf` in the repository root adds a third way in, and it is a significant one. A user manual for PicoMite in the root of a firmware repository means the shipped firmware is or can be PicoMite, which is a BASIC dialect implemented on the Pico. If you take that route, the device becomes programmable in a language where the shortest useful program is a line of BASIC, rather than requiring a C toolchain, a build, and a compiler on the machine you are trying to program. For a hardware project, that is a meaningful choice in build complexity. The C route through the Pico SDK gives you the full runtime and the SDK's drivers. The Micropython route gives you an interpreter on the device. The PicoMite route gives you the same with a more approachable language. The repository ships all three kinds of artefact, in `Bin/` and in `Code/`, and the wiki is where the quick start lives. ## A multi-board kit where revisions matter Two things about the hardware deserve attention before you order parts, and both come from the file listing rather than the prose. The first is the revision marker. The schematic in the repository is `clockwork_Mainboard_V2.0_Schematic.pdf`, so the documented board is mainboard version 2.0. If you are following a guide, a forum post or a marketplace listing for an earlier board, the pinout and the parts may not match what is documented here. The second is the display controller. The presence of `ST7365P_SPEC_V1.0.pdf` tells you the screen is driven by an ST7365P and gives you the document to work from if you are writing a driver or debugging a display problem. Pair that with the AXP2101 datasheet for the power management part, and you have the two specifications you need to understand the board's peripherals, both under version 1.x of their respective documents. The `PCB/` directory is the other half of that. Board files in the repository mean the design is open enough to inspect and to modify, which is what makes the 3D printed case claim possible in the first place, since a case has to match the board's outline and its component heights. There is also a `Pictures/` directory for photographs of the assembled hardware, which is the practical reference for the assembly steps in the guidelines PDF. What the repository does not do is tell you which display panel to buy, what the keyboard flex connector is, or what the list of parts is. Those are the questions the wiki and the community forum are for, and the README points at both, along with the official site at clockworkpi.com, a ClockworkPi Community forum, and GitHub issues for bugs and feature requests. ## Against a cheap microcontroller and against a repurposed phone The comparison worth making is with the two other ways to get a small keyboard-and-screen device you can program. The first is a bare microcontroller board with an add-on display and a USB keyboard, which is what a maker reaches for by default. The PicoCalc differs in the physicality of it. The keypad and the display are part of one designed product, the case fits, and the USB Type-C port doubles as the serial console, so there is one cable and one device rather than a board with two peripherals wired together. The cost is that the design is fixed, and where a bare board lets you pick a different screen or add a different keyboard, here you take what the mainboard V2.0 supports. The second is a repurposed phone, either a phone running a terminal emulator or a device with a termux style setup. A modern phone is far more powerful than a Pico, it has a screen and a keyboard already, and it needs no build at all. The PicoCalc wins on the things a phone cannot easily do: it is built around a microcontroller with exposed SPI, I2C and UART, so talking to a sensor is a wiring job rather than a USB debugging exercise. It also has a physical keypad with keys you can feel and remap, and it runs off a small Type-C supply, which is a different kind of object from a phone. The honest cost of the PicoCalc is assembly. Someone has to solder, connect the display, fit the keypad, and get the firmware onto it, and the assembly guidelines PDF in the repository exists precisely because that is a real step rather than an unboxing. That is a weekend of work and a soldering iron, and it is the reason the repository ships a 3D printed case option and a `Bin/` directory of ready-to-flash firmware, so the assembly and the software setup can be done in either order. For a kit that a maker has to build, having the schematic, the display specification, the power part datasheet, the assembly guide and the board files all in one repository is unusual and is the main reason this project is worth a look. ## Conclusion Adopt PicoCalc if you want a self-contained microcontroller terminal with a physical keypad and a display and you are comfortable with a hardware build, because the schematic, the assembly guide and the display specification are all in the repository and the 3D printed case is a separate consideration. Do not adopt it as a ready-made purchase without reading the assembly guidelines, since the kit is not described as a finished product, and check first which display and power parts your revision needs, because the AXP2101 and ST7365P documents in the repository point at a specific hardware generation. ## FAQ ### What is the PicoCalc project? It is a ClockworkPi hardware project described as a cost-effective portable MCU terminal, built around the Raspberry Pi Pico H and Pico WH series and compatible modules, with a display, a physical keypad, and expandable SPI, I2C and UART for external peripherals. ### Where do I get the PicoCalc firmware without building it? The `Bin/` directory in the repository contains prebuilt firmware images in .uf2, .bin and .hex form, and the README also points at the releases page for the latest firmware and SD card files. The releases listed include multi_uf2_bootloader_0.6 from 2026-03-01. ### Which languages can I use on a PicoCalc? The feature list states support for Micropython and C/C++ development using the Raspberry Pi Pico SDK, and the repository root carries a PicoMite user manual. The firmware can be modified to add graphing and scientific calculation, I2C and SPI sensor interfacing, and keyboard remapping and custom UI work. ### What documentation does the repository include for the hardware? The root holds the mainboard V2.0 schematic, the ST7365P display controller specification, the AXP2101 power management datasheet, an assembly guidelines PDF and a PicoMite user manual, alongside a `PCB/` directory, a `Pictures/` directory, a `Code/` directory and a `wiki/` directory. ### Does the PicoCalc come in a case? The feature list says it is compatible with 3D printed cases, which the README frames as making it an ideal DIY project. The repository includes a `Pictures/` directory and an assembly guidelines PDF, so the build is a documented exercise rather than an unboxing. ### Is PicoCalc still being developed? The repository is not archived and the last push was on 2026-10-14. The listed releases are bootloader releases rather than application ones, with multi_uf2_bootloader_0.6 from 2026-03-01, multi_booter_v0.5 from 2025-06-03 and multi_booter_v0.4 from 2025-05-31. ## Sources - [clockworkpi/PicoCalc on GitHub](https://github.com/clockworkpi/PicoCalc) - [Issues](https://github.com/clockworkpi/PicoCalc/issues) - [README](https://github.com/clockworkpi/PicoCalc/blob/master/README.md) - [Releases](https://github.com/clockworkpi/PicoCalc/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/clockworkpi-picocalc