Watchy Smartwatch

SQFMI Watchy v2 · ESP32-PICO-D4 · 200×200 e-paper · Chronos Watchy firmware · Project parked

What is Watchy?

Watchy is an open-source smartwatch designed by SQFMI and funded via Crowd Supply. Unlike most smartwatches the entire firmware is user-replaceable — the watchface, features, and connectivity are fully determined by what code you flash. The e-paper display draws no power while showing a static image, making it viable on a small 200 mAh LiPo battery. This unit is the v2 hardware revision, using an ESP32-PICO-D4 with 802.11 b/g/n WiFi and BLE 4.2 — confirmed by esptool at first flash.

The device was purchased from AliExpress (listing 1005008618027792). It originally shipped with the watchy-starfield watchface and was reflashed to stock Chronos Watchy v1.2.0 during architecture research. The project is currently parked — see Research Findings below.

Current Setup

Device	SQFMI Watchy v2 (ESP32-PICO-D4)
Chip	ESP32-PICO-D4 · confirmed by esptool
Flash	4 MB
MAC	`a4:f0:0f:38:48:9c`
Display	200×200 e-paper (monochrome)
Firmware	running Chronos Watchy v1.2.0 (stock)
Purchased from	AliExpress ↗
OTA	parked requires custom companion app
Phone sync	parked requires custom companion app

Resources

Official project	watchy.sqfmi.com ↗
Official firmware	github.com/sqfmi/Watchy ↗
Current watchface	Prokuon/watchy-starfield ↗
AliExpress listing	Item 1005008618027792 ↗
XiaoZhi (sibling)	ESP32-S3 AI assistant on this server ↗

Target Architecture parked

Research concluded that WiFi on the watch is unnecessary. The phone is always nearby, always has internet, and BLE is purpose-built for this relay pattern — the same approach used by Fitbit, Garmin, and Whoop. The target architecture is BLE-only on the watch, with a custom Android companion app as the internet bridge.

BLE-only watch firmware

Chronos Watchy base — no WiFi code. Phone pushes time, weather, and notifications over BLE. Watch never connects to the internet directly.

→

Custom Android companion app

Sits alongside the Chronos app. Handles OTA — downloads firmware from this server and pushes the binary to the watch over BLE. Also writes step data into Android Health Connect.

→

Health Connect + server bridge

Steps and activity from the watch flow into Android Health Connect (the standard health hub used by all major fitness apps). Custom alerts from danscodellaro.com pushed to watch as notifications.

Research Findings

BLE vs WiFi power

BLE is the dominant battery drain by a factor of ~100×. WiFi OTA once per hour costs ~0.07 mAh; BLE advertising during every 40-second wake window costs ~8 mAh/hr. Eliminating WiFi from the watch saves almost nothing — the real power budget is BLE.

BLE active (40 s/min)	~8 mAh/hr
WiFi OTA (5 s/hr)	~0.07 mAh/hr

BLE as internet gateway

The phone already handles all internet for the watch in the Chronos model — weather, time sync, and notifications all flow over BLE with the phone fetching data on the watch's behalf. Extending this to OTA and Health Connect requires no new WiFi infrastructure on the watch, only a companion app.

Chronos app gaps

The Chronos Android app has no Google Fit or Health Connect integration. Step data received from the watch stays siloed in the Chronos app — it does not flow into the standard Android health ecosystem. A custom companion app is required to bridge to Health Connect.

Time sync	Yes
Notifications	Yes
Weather	Yes
Health Connect	No
OTA firmware	No

Google Fit / Health Connect

The Google Fit REST API can accept step data from any HTTP client including an ESP32, but requires OAuth 2.0 — awkward to manage on embedded hardware. More importantly, the Fit REST API is deprecated in favour of Health Connect, which has no remote API — it is Android-local only. The correct path is watch → BLE → companion app → Health Connect.

A server-mediated approach (watch → server → Fit API) also works but inherits the same deprecation problem and adds server complexity for no benefit.

Device Specifications

Model	SQFMI Watchy v2 this device
Chip	ESP32-PICO-D4 · confirmed by esptool
CPU	240 MHz dual-core Xtensa LX6
SRAM	520 KB
Flash	4 MB (PICO-D4 package)
MAC	`a4:f0:0f:38:48:9c`
Dimensions	46 × 35.5 × 9.5 mm
Weight	~13 g (without strap)
Programming	Arduino, ESP-IDF

Display

Type	E-paper (electrophoretic ink)
Panel	GDEY0154D67 (Good Display)
Resolution	200 × 200 px
Colors	1-bit monochrome (black / white)
Full refresh	~2 s (flicker cycle)
Partial refresh	Supported — used for clock updates
Sunlight	Fully readable in direct sun
Static power	Zero (holds image with no power)

Connectivity

WiFi	802.11 b/g/n, 2.4 GHz
Bluetooth	BLE 5.0 (integrated in ESP32-S3)
USB	USB-C via CP2104 USB-UART bridge (v2)
Serial	115200 baud via USB-C → CP2104 → UART

WiFi and BLE cannot run simultaneously at full power — most firmwares alternate between them or use WiFi only for time sync and OTA.

Sensors & Peripherals

Accelerometer	BMA423 — 3-axis, step counter, gesture detection, activity recognition
RTC	PCF8563 (v3.0) · DS3231 (v1.0)
Vibration	Small vibration motor (v3.0)
Buttons	4 × physical push buttons (SW1–SW4)

Power

Battery	200 mAh LiPo 3.7 V
Charging	USB-C, onboard charger IC
Deep sleep	ESP32-S3 deep sleep: ~10 µA
Typical life	5–7 days (clock-only, WiFi off); ~1–2 days (WiFi active)

E-paper holds its last image indefinitely with zero power draw, making deep sleep + timed wakes the dominant power strategy.

Buttons (SW1–SW4)

Watchy has four physical buttons. Their function is entirely defined by firmware — there is no fixed mapping. Different firmwares assign them differently.

Button	Physical position	Stock SQFMI	WatchyGSR	Chronos Watchy
SW1	Top right	Up / Back	Up / Back	Menu
SW2	Bottom right	Down	Down	Back
SW3	Bottom left	Select	Select / Confirm	Down
SW4	Top left	Menu	Menu	Select

Custom firmware can remap all buttons freely. Long-press and double-tap detection is firmware-dependent.

Firmware Comparison

Watchy has an unusually rich community firmware ecosystem. The table below covers all known active and notable projects. The current firmware (watchy-starfield) is highlighted.

Firmware	OTA	BLE / Phone	WiFi	Key Features	Status
Stock SQFMI Official reference firmware	HTTP WiFi	None	Yes	Weather (OpenWeatherMap), watchface system, reference implementation	Active
watchy-starfield current Based on Stock SQFMI	Manual	None	Limited	Step count, sunrise/sunset, moon phase, dark/light mode, 12/24h toggle, configurable location	Active
Chronos Watchy fbiego — NimBLE-Arduino	Manual	Full sync	No	Phone notifications, time sync, weather push, navigation, music control, step upload, QR pairing, multiple watchfaces (BLE-installed)	Active
ESPHome-for-Watchy multipolygon — ESPHome	HTTP WiFi	None	Yes	Home Assistant integration, CalDAV calendar, weather (16-day), dual alarms, timers, QR vCard, Improv WiFi provisioning, v2 + v3 support	Active
WatchyGSR GuruSR — AsyncElegantOTA	Browser UI	None	Yes	Browser OTA at http://esp32.local, addon/watchface system, 10 WiFi APs, alarms, timers, NTP + auto timezone, power-save modes, NVS backup	Very active
InkWatchy Szybet — modular, Rust components	Partial HTTP	BLE keyboard	Yes	Most watchfaces, 16-day weather + air quality, calendar (ICS), e-book reader (EPUB/PDF), games (Tetris, Snake in Rust), Bitcoin ticker, Pomodoro	Active
WatchyFlow jtolio — declarative UI	Manual	None	Yes	Calendar sync (iCal / Google Calendar via proxy), declarative LVGL-style layout system, hourly/daily views, multi-day battery life, v2 + v3	Active
Smart-Watchy SvenKoos — WiFi notifications	Manual	WiFi (not BLE)	Yes	Phone notifications via WiFi (companion Android app), MAC filtering, last 20 messages stored	Unmaintained
TinyWatchy Michal-Szczepaniak — minimal	Manual	None	No	Ultra-minimal, heavily power-optimised. v1/v2 only — does not support v3 (ESP32-S3).	Active
NovWatchy novhack — v2.0 focused	Manual	None	Yes	Temperature sensor calibration (BMA423 curve correction), based on official firmware, inspired by My-TTGO-Watch	Unknown
CircuitPython Adafruit — official support	Manual	None	Yes	Full CircuitPython module ecosystem, Python-based development, alternative to Arduino/C++	Maintained

BLE "Full sync" = Chronos phone app (notifications, time, weather, navigation, music). BLE "BLE keyboard" = HID keyboard mode only. WiFi (not BLE) = phone connectivity over local WiFi network rather than Bluetooth.

Best for BLE Phone Sync

Chronos Watchy — fbiego/chronos-watchy ↗

The only firmware with full BLE phone integration. Uses the ChronosESP32 library (NimBLE-Arduino) to connect to the Chronos companion app (Android). Pushes time sync, all app notifications, weather, turn-by-turn navigation, music remote, and step count. Watchfaces can be installed over BLE at runtime. Actively maintained as of 2025. Downside: no WiFi OTA — firmware updates require a USB cable flash.

Best for WiFi OTA

WatchyGSR — GuruSR/Watchy_GSR ↗

Most mature OTA story: the watch hosts a web interface at http://esp32.local and accepts firmware uploads from any browser on the same WiFi network (AsyncElegantOTA). Also supports up to 10 saved WiFi networks, auto timezone via NTP, an addon/watchface plugin system, and NVS backup/restore. Very actively maintained and considered the most stable community alternative. No BLE phone sync.

ESPHome-for-Watchy — multipolygon ↗

Complete firmware replacement using the ESPHome framework. OTA updates pushed directly from ESPHome or Home Assistant over WiFi — ideal if already running an HA instance. Supports Improv for WiFi credential provisioning (scan a QR code on the watch face). Fully configurable via YAML. No BLE phone sync.

Most Features

InkWatchy — Szybet/InkWatchy ↗

The most feature-packed firmware: e-book reader (convert EPUB/PDF at build time), Tetris and Snake (Rust-compiled), 16-day weather forecast, air quality index, Bitcoin ticker, Pomodoro timer, ICS calendar sync. Modular architecture — features are loaded as separate modules. BLE keyboard HID mode is supported but there's no phone notification push. Requires recompilation to change WiFi credentials.

Approach

The firmware base is Chronos Watchy by Felix Biego, using the ChronosESP32 library (NimBLE-Arduino) for BLE phone connectivity. This gives full phone notification push, automatic time sync, weather, navigation, music remote, and step upload — all without WiFi on the watch.

Research confirmed that WiFi is unnecessary on the watch entirely. The Chronos app handles all internet relay over BLE. The remaining gap is a custom companion app for OTA firmware delivery and Health Connect step sync — the two things Chronos does not provide.

BLE Phone Capabilities (ChronosESP32)

🕐

Time Sync

Phone pushes current time + timezone on connect. Watch sets its RTC automatically — no NTP required.

🔔

Notifications

All Android app notifications forwarded to watch over BLE. Filterable by app. Vibrates on receive.

🌤

Weather

Phone pushes current conditions + forecast. No API key or WiFi needed on watch.

🗺

Navigation

Turn-by-turn from Google Maps or OsmAnd relayed to watch display. Current street + next instruction.

🎵

Music Remote

Play, pause, skip, volume from the watch. Track name + artist shown on display.

📷

Camera Remote

Trigger phone camera shutter from watch. Useful for selfies and group photos.

👣

Activity Sync

Step count, distance, and calories uploaded to phone app. BMA423 accelerometer provides the raw data.

🔋

Battery Status

Watch battery level visible in companion app. Low battery alerts can be pushed to phone.

ChronosESP32 Library

Repo	github.com/fbiego/chronos-esp32 ↗
BLE stack	NimBLE-Arduino
Protocol	Custom GATT services/characteristics (ChronosESP32 UUIDs)
Language	C++ (Arduino)
Dependencies	ESP32Time, NimBLE-Arduino
License	MIT
Releases	18+ releases, actively maintained

Companion App

App name	Chronos
Platform	Android (Play Store)
Developer	Felix Biego (fbiego)
Connection	BLE scan + QR code pairing
Auto-sync	Time, weather, notifications on connect
History	Stores step history, activity charts

Chronos app must be running (or background service active) for live notification push. Time sync happens automatically every time the phone and watch come into BLE range.

The Chronos app has no Health Connect or Google Fit integration — step data stays siloed in the app. A custom companion app is needed to bridge steps into the standard Android health ecosystem.

Implementation Plan: Combining OTA + BLE

The combined firmware strategy uses Chronos Watchy as the base and layers in custom server OTA at boot time:

void setup() {
  initHardware();       // display, RTC, BMA423
  connectWiFi();        // brief WiFi join using saved credentials

  // 1. OTA check (WiFi)
  checkOta("https://www.danscodellaro.com/esp32/watchy/ota");

  // 2. Sync NTP if RTC drift > threshold (WiFi still up)
  if (rtcDriftExceedsThreshold()) syncNtp();

  disconnectWiFi();     // turn off WiFi radio to save battery

  // 3. Start BLE advertising (Chronos profile)
  chronos.begin("My Watchy");
  chronos.setCallbacks(&watchCallbacks);

  showWatchface();
}

WiFi is only active during the ~2-second boot OTA check window, then shut down. BLE runs continuously for phone sync. This keeps battery life acceptable while gaining both capabilities.

Future: Custom Server Integration

Once basic BLE + OTA is working, a custom BLE characteristic (or a WiFi HTTP call during the boot window) can bridge the watch into danscodellaro.com:

Direction	Data	Use case
Watch → Server	Daily step count, battery %, sleep data	Persist activity history on server; display on a dashboard
Server → Watch	Custom notification payload	Push job hunt alerts, server health warnings, or calendar reminders direct to wrist
Watch → Server	Button press event	Trigger server-side actions (log a workout, mark a task done) from watch buttons

The simplest implementation is a single HTTP POST during the OTA boot window — no new BLE infrastructure needed. Push a JSON payload with the previous day's stats while WiFi is already connected.

`POST /esp32/watchy/ota`	Version check — returns latest version + binary URL. Logs every check to `api/watchy_ota_requests.log`.
`GET /esp32/watchy/watchy.bin`	Firmware binary served as a static file. No auth — device fetches directly.

Version constant	Defined as `FIRMWARE_VERSION` in firmware source — e.g. `"1.0.1"`
Server constant	`_WATCHY_OTA_VERSION` in `api/server.py` — must exactly match the binary
Binary path	`frontend/esp32/watchy/watchy.bin`
OTA log	`api/watchy_ota_requests.log`

Template	`include/ota_wifi.h.example`
Actual file	`include/ota_wifi.h`
Used by	`src/main.cpp` via `#if __has_include`
OTA runs on	Full-refresh boots only (hourly RTC alarm + first power-on)