FirebeetleCarrier is an open-source printed circuit board by JuzzyDee, from the JuzzyDee/oneiro-beacon repository on GitHub, published under the MIT licence. It is a 2-layer board of 94 × 45 mm with 47 parts on 55 nets, routed with 273 tracks and 32 vias.
It is built around the MBR0530, AO3400A and SI2301CDS-T1-E3. Its parts include 12 resistors, 11 capacitors, 6 connectors, 3 diodes and 3 transistors. It belongs with the lEDs and displays boards of this library.
The Beacon is a battery e-paper desk device that wakes once a day, fetches a
single image from a backend you control, paints it onto the glass, and goes back
to sleep. E-paper is bistable, so the image holds at zero power between
refreshes — it just sits there, a picture on your desk that quietly changes once
a day.
It was built as the display end of Oneiro, a memory system for an AI: each
day it surfaces one memory as a dithered illustration. But the Beacon itself
doesn't care where the image comes from. The device is the easy part — the
memory feed is yours to bring.
Built with soldering-optional hardware, so anyone can make one.
What you need (no-solder build)
Part
Notes
DFRobot FireBeetle 2 ESP32-E
The brains. Very low deep-sleep current, built-in LiPo charging.
5" e-paper, 960×552 + driver HAT
The glass — bistable, holds the image on no power. Discontinued panel; see the sourcing note.
A LiPo cell
I run a 2200 mAh 18650 (flat packs were out of stock). It wakes once a day, so runtime is long — exact life yet to be measured.
A Type D cable
Connects the display to the board — see the schematic notes.
Tidies it into one clean object. Not required to try it first on the HAT.
No iron needed for the basic build: the e-paper sits on its HAT, the FireBeetle
plugs into the carrier (or a breadboard), joined by the Type D cable.
Sourcing note: the 960×552 panel (the EPD_5in0 driver's target) appears to
be discontinued — I found mine cheap on AliExpress. Any current Waveshare
e-paper works; just match its resolution and FRAME_BYTES in the firmware and
your backend.
Flash it
Install the Arduino IDE and the ESP32 board package.
Create your secrets file from the template and fill it in:
sh
cd firmware
cp secrets.h.example secrets.h
Edit secrets.h — your WiFi, your backend's BEACON_URL, and a BEACON_KEY
bearer token if your backend wants one. secrets.h is gitignored; it never
leaves your machine.
Board settings in the Arduino IDE:
Board: FireBeetle 2 ESP32-E
Partition Scheme: Default 4MB with SPIFFS
Upload. On boot it joins WiFi, pulls a frame, paints it, and deep-sleeps
until the next refresh.
The Waveshare 5" driver is vendored in firmware/ for convenience (see
NOTICE) — nothing else to install.
Bring your own memory feed
The Beacon fetches exactly one thing: a pre-packed 1-bit display frame, over
HTTP. It does no rendering — your backend owns the pixels. So you can point it at
anything that speaks this contract:
Colour: bit 1 = white, 0 = black (an all-0xFF buffer is a blank white screen)
Auth: the device sends Authorization: Bearer <BEACON_KEY>. Ignore it if your endpoint is open.
Schedule (optional): respond with an X-Beacon-Sleep-Seconds header and the
device sleeps exactly that long before the next fetch — so your server owns
the cadence and the device's RC-timer drift never accumulates. Without it, it
falls back to a 6-hour interval.
Empty shelf: return 503 and the device leaves the current image up and
retries later. (E-paper persistence means a blank fetch never blanks the wall.)
Render however you like — Python + Pillow with Floyd–Steinberg dithering is an
easy start. A homelab box, a serverless function, a Raspberry Pi — anything that
can return 66,240 bytes works. The contract above is all you actually need.
Hardware
hardware/ holds the KiCad source for the FireBeetle carrier
board (Rev 0.1B) — schematic and PCB. It tidies the FireBeetle, the e-paper
connector, power, and the decoupling/bulk caps into one board. You don't need it
to try the Beacon (a HAT on a breadboard works), but if you want the clean desk
object, it's here to fab.
Connection: the display attaches via a Type D cable — the schematic
notes cover it.
Fabrication: no Gerbers or BOM are shipped on purpose. Export your own from
KiCad — File → Fabrication Outputs for Gerbers and drill files, and the
BOM / component-position tools for assembly. That keeps you on current fab-house
requirements and, more importantly, means you can change the board first —
which is the whole point of open hardware. Open the project, tweak what you
want, export, order.
Why
Built because someone wanted an AI's memory to be something you could look at
from across a room — not a database row, but a picture on the glass that changes
with the day. If you build your own, that's the spirit: it isn't a status
display, it's a small daily window into whatever you decide is worth
remembering.
Firmware, hardware, and this guide are MIT — do what you like with them. The
one piece kept private is the specific art-generation prompt behind the original
images; bring your own.
Built by Justin Davis, with Claude — to give a memory a face.
It measures 94 × 45 mm and has 2 copper layers, 1.6 mm thick.
What parts does the FirebeetleCarrier use?
47 parts, built around the MBR0530, AO3400A and SI2301CDS-T1-E3. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.
Where can I download the FirebeetleCarrier KiCad files?
From the JuzzyDee/oneiro-beacon repository on GitHub, at the commit this page was made from: the board is hardware/FirebeetleCarrier.kicad_pcb and its schematic hardware/FirebeetleCarrier.kicad_sch. PCBKit opens the board in the browser, with nothing to install.
Can I use the FirebeetleCarrier design in my own project?
Its repository publishes it under the MIT licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).
JuzzyDee/oneiro-beacon
