# Sensor Watch: a Casio F-91W board replacement with a SAM L22 MCU and UF2 bootloader > Sensor Watch replaces the PCB inside a Casio F-91W wristwatch with a Microchip SAM L22 ARM Cortex M0+ board, keeping the original case and LCD while adding a USB bootloader, a nine-pin expansion connector, and full C programmability. The hardware design is complete; the watch library is described as work-in-progress in the README. **joeycastillo/Sensor-Watch** — A board replacement for the classic Casio F-91W wristwatch - Repository: https://github.com/joeycastillo/Sensor-Watch - Stars: 2,090 · Forks: 312 - Language: C - License: NOASSERTION - Published: 2026-10-11 · Updated: 2026-10-11 · Language: en - Canonical page: https://hysenlabs.com/projects/joeycastillo-sensor-watch ## A PCB that replaces the stock Casio F-91W board while keeping the original case Sensor Watch is a hardware project: a custom circuit board designed to drop into the case of a Casio F-91W watch and replace the original electronics. The case, the watch glass and the LCD remain. What changes is the brains. The original Casio controller is replaced by a Microchip SAM L22 microcontroller, the same chip that drives the segment LCD directly through its built-in LCD controller. This is for engineers who want to run their own software on a wrist-worn device without starting from scratch with an enclosure. The F-91W case is the enclosure. Everything else, from the firmware to the sensor expansion, is programmable. You write C, build with the GNU Arm Embedded Toolchain, and flash over USB through a UF2 bootloader that acts like a USB mass storage device. ## The SAM L22 board: ten LCD segments, three buttons, and an optional buzzer The main board carries an ARM Cortex M0+ processor and a 32KHz crystal for real-time clock and alarm functions. The LCD it drives has ten digit segments and five indicator segments. Three buttons are interrupt-capable, meaning firmware can respond to button presses without polling. The backlight is a red and green LED, both PWM-capable. One hardware feature requires assembly work: the piezo buzzer is optional and, according to the README, requires some light soldering. It is not installed by default. The board has a USB Micro B connector for both power and programming, and a Reset button whose double-tap sequence enters the UF2 bootloader. The final connector is a nine-pin flex PCB port for sensor expansion, described in its own section below. ## The nine-pin connector: what the five GPIO pins can and cannot do at once The nine-pin flex PCB connector is how sensor boards attach. Power from the connector is 3V nominal, drawn from a CR2016 coin cell, which can drop to approximately 2.7V. One dedicated I2C bus with built-in pull-up resistors occupies two of the nine pins (SCL and SDA). These two pins have no alternate functions; the pin table shows dashes for every column other than I2C on those rows, meaning they cannot be reassigned as GPIO, analog inputs or anything else. The remaining five pins (labeled A0 through A4) are multifunctional: each can serve as an analog input, a digital I/O, or an interrupt-capable input. Across those five, you can configure a full SPI controller, a single UART TX/RX pair, or up to four PWM outputs across two independent timer/counter instances. Pins A2 and A4 add external wake capability that can bring the chip out of its ultra-low-power BACKUP mode. The physical constraint for a sensor board is tight: the available area is 5.7 x 5.7 x 1 mm. SOIC packages are too large for this footprint, and even SSOP packages are generally too thick. QFN and LGA parts are the practical choices. PCB/Sensor Boards in the repository holds reference designs for expansion boards. ## Building and flashing firmware over USB with make and make install The GNU Arm Embedded Toolchain is required. The README notes the library has been tested with two versions: 9-2019-q4-major and 10.3-2021.07. On Debian or Ubuntu, the toolchain can be installed with: ```bash apt install gcc-arm-none-eabi ``` To start a new project, copy the starter-project folder from the apps/ directory and write code in the app.c file. Build by navigating to the project's make folder and running make. To install onto the board, plug the watch into a USB port, double-tap the Reset button, and wait for the LED to pulse red. When a drive named WATCHBOOT appears, run: ```bash make install ``` This converts the compiled binary to a UF2 file and copies it to the watch. If the LED does not pulse red after double-tapping Reset, the README advises checking that the board was not inserted upside down into the USB port. ## The Movement framework and the emscripten-based browser emulator For anyone starting from existing watch faces rather than a blank app.c, the movement/ directory is the starting point. Building the default firmware uses: ```bash cd movement/make make ``` The output file is movement/make/build/watch.uf2, which you copy to the watch using the same UF2 procedure as above. To change which watch faces are compiled in, the file to edit is movement_config.h. The project also ships with an emulator. It requires emscripten. After installing emscripten, build the simulator version and serve it locally: ```bash cd movement/make emmake make python3 -m http.server -d build-sim ``` Visit http://localhost:8000/watch.html to see the emulated watch. Testing in the emulator before flashing physical hardware is the documented way to iterate without reflashing the board repeatedly. ## Three hardware variants, with Sensorwatch Pro listed but not yet published The README's hardware table lists three variants. Sensorwatch Lite is the red board, with Gerbers in PCB/Main Boards/OSO-SWAT-B1 available for fabrication. The original Sensorwatch is the green board, with an Eagle-format schematic at PCB/Main Boards/OSO-SWAT-A1/OSO-SWAT-A1-05.sch; its Gerbers column shows a question mark. Sensorwatch Pro appears in the table but both the schematic and Gerbers columns show TBD, meaning no design files have been published for it. Anyone planning to order PCBs for the Pro variant will find nothing to send to a board house. For fabrication, only Sensorwatch Lite has a complete publicly available file set. The original Sensorwatch has a schematic for reference but no confirmed Gerbers. The Pro is announced but absent from the repository. ## Before writing firmware: what getting started actually requires Sensor Watch is a hardware project before it is a software one. Getting to the first firmware flash requires a board, a USB cable, a working ARM toolchain, and a Casio F-91W watch case to install the board into. None of these ship as a download. For anyone who needs hardware debugging beyond the UF2 bootloader path, an openocd.cfg file sits at the repository root. The .devcontainer/ directory provides a containerized development setup for VS Code users who want to avoid manual toolchain installation. Both files are present in the repository without documentation in the README. One important caveat from the README itself: the watch library is described as 'very work-in-progress.' Movement is the more stable starting point for most development, but Movement also depends on the same underlying watch library. For anyone evaluating this against a more mature embedded wearable SDK, that characterization is the realistic baseline. Code in the repository carries a custom license; LICENSE.md documents which terms apply to which components. The last push was on 2026-04-08. ## Conclusion Use Sensor Watch if you're comfortable with embedded C and want a watch face running your own code inside a watch you already own. The hardware is complete and the UF2 bootloader makes flashing straightforward. Skip it if you need a ready-to-wear smartwatch, because this project requires sourcing or building the board and setting up an ARM toolchain. Before ordering a board, verify which variant you need: Sensorwatch Lite has Gerbers available, the original Sensorwatch has an Eagle schematic, and Sensorwatch Pro lists no design files in the repository. ## FAQ ### What is Sensor Watch? Sensor Watch is an open hardware board replacement for the Casio F-91W wristwatch. It replaces the original PCB with a Microchip SAM L22 microcontroller, adds a USB UF2 bootloader and a nine-pin expansion connector for custom sensor boards, and keeps the original case and LCD. ### How do I flash firmware to a Sensor Watch board? Plug the board into USB, double-tap the Reset button on the back, and wait for the LED to pulse red and a WATCHBOOT drive to appear. Then run make install from the project's make folder to copy the compiled UF2 file to the watch. ### What sensors can I connect to Sensor Watch? Sensors attach through the nine-pin flex PCB connector, which provides 3V power, one I2C bus, and five configurable GPIO pins. The sensor board area is 5.7 x 5.7 x 1 mm, which limits parts to QFN and LGA packages. Reference designs are in the PCB/Sensor Boards directory. ### What is the Movement framework in Sensor Watch? Movement is a prebuilt firmware framework in the movement/ directory that provides ready-made watch faces and a structure for adding new ones. Build it with make in movement/make and copy the resulting watch.uf2 to the board. Which faces are compiled is controlled by movement_config.h. ### Does Sensor Watch have a software emulator? Yes. The project includes an emscripten-based emulator. After building with emmake make in movement/make and serving the build-sim directory with python3 -m http.server, you can test watch faces in a browser at http://localhost:8000/watch.html before flashing to hardware. ## Sources - [Issues](https://github.com/joeycastillo/Sensor-Watch/issues) - [joeycastillo/Sensor-Watch on GitHub](https://github.com/joeycastillo/Sensor-Watch) - [README](https://github.com/joeycastillo/Sensor-Watch/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/joeycastillo-sensor-watch