OTA Updates in the Settings App

The Set­tings app now in­cludes a Sys­tem sec­tion with:

• Cur­rent firmware ver­sion dis­play
• Up­date check ac­tion
• Firmware up­date ac­tion

This will down­load the lat­est firmware and in­stall it. Al­ter­na­tive­ly you can down­load a firmware to /sys­tem/­firmware.bin in the SD card and re­boot.

App Management

Al­so, there is now a "App­s" tag in the set­tings ap­p. Cur­rent­ly you can on­ly use it to unin­stall app­s, but more is planned.

Reader App

Bet­ter progress saves! More re­li­able and con­sis­ten­t.

Shell App: A Command Line for Esposito

The latest addition to the app roster is a shell — a simple command-line environment running in text mode on the 320x240 display. It supports ls, cd, cp, and mv as builtins, and any two-token command that isn't a builtin is treated as <app> <file>, launching Esposito apps directly from the command line.

It fea­tures in­line line edit­ing with cur­sor move­ment (Fn+A/D), his­to­ry nav­i­ga­tion (Fn+W/S), Ctr­l+U to clear the line, and Ctr­l+L to clear the screen. The cur­rent work­ing di­rec­to­ry is dis­played in a sta­tus bar and per­sist­ed across ses­sions through the con­fig API, along with up to 20 his­to­ry en­tries.

The shell is de­lib­er­ate­ly bare­bones — no pipeli­nes, no redi­rec­tion, no tab com­ple­tion, no vari­able ex­pan­sion. What it does pro­vide is the right foun­da­tion to add those things lat­er.

When you are start­ing a new elec­tron­ics pro­jec­t, you of­ten need a bunch of con­trols to trig­ger things. Like, you want to have 4 or 6 or 10 but­tons to do things.

This puts you in a com­pli­cat­ed po­si­tion be­cause it means you need to build a thing be­fore you know if the thing is worth build­ing. Wiring 10 but­tons is a lot of work! so let's not do that.

Us­ing bt2i2c then any­thing that can talk I2C (and that is a very low bar!) can use a full wire­less key­board, as long as you con­nect three pin­s!

The ba­sic con­cept is:

• Get a Pi­co W
• Get a Screen (op­tion­al, but use­ful)
• Get a cheap BT key­board (clas­sic or BLE, both work)
• Get the bt2i2c firmware on­to the Pi­co W
• Con­nect your project to the Pi­co W via I2C

Then, on your project side, use the client for the BBQ20 or BBQ10 key­boards from sol­der par­ty.This is (sup­posed to be) 100% com­pat­i­ble!

And that's it, you get keys via I2C, and can con­trol your new project at will.

The screen will show you when it's scan­ning, or con­nect­ed, or if you need to type a PIN. If you don't have a screen, use the pi­co's USB se­ri­al port.

Peanut-GB: Game Boy Emulation on ESP32

Yes, re­al­ly. The ES­P32 CYD is now a Game Boy. Peanut-GB is a DMG em­u­la­tor run­ning as an Es­pos­i­to ap­p, achiev­ing 40-60 FPS at 240MHz with no PSRAM.

ROMs are load­ed from the SD card in­to flash mem­o­ry and mem­o­ry-mapped for fast ac­cess. The 160x144 Game Boy dis­play is cen­tered on the 320x240 screen with black bor­der­s, just like the re­al thing.

Controls

Action	Key
D-Pad	W/A/S/D
A Button	L
B Button	M
Select	O
Start	P
Save State	K
Load State	J
Exit	ESC

ROMs go in /sdcard/roms/ on the SD card. For legal homebrew Game Boy games, check out Homebrew Hub.

Sprite API and Flash ROM Loading

To make the em­u­la­tor pos­si­ble, the firmware gained two new sys­tem­s:

• Sprite API: Palet­ted sprites for ef­fi­cient pix­el-lev­el ren­der­ing. The Game Boy dis­play us­es a 2bpp sprite (5.7KB on sys­tem heap in­stead of a 23KB RG­B565 buffer­), with one sprite_write_row call per scan­line.

• Flash ROM load­­ing: ROMs are copied from SD card in­­­to the ap­p_­­code flash par­ti­­tion and mem­o­ry-mapped. This gives ze­ro-over­­head point­er dere­f­er­ence in­­stead of slow SD card I/O dur­ing em­u­la­­tion.

Improved Event Handling

The OS event loop now drains all pend­ing events in­stead of pro­cess­ing one per it­er­a­tion. This elim­i­nates the in­put lag that was es­pe­cial­ly no­tice­able in fast-­paced apps like the em­u­la­tor. The event queue was al­so dou­bled from 32 to 64 slot­s.

CPU at 240MHz

The CPU fre­quen­cy was bumped from 160MHz to 240MHz, which — com­bined with com­pil­er op­ti­miza­tions and bank 0 RAM caching — is what makes Game Boy em­u­la­tion vi­able on this hard­ware.

Credits

The em­u­la­tor core is Peanut-GB by Mah­yar Koshk­ouei, a re­mark­ably fast sin­gle-­head­er C99 Game Boy DMG em­u­la­tor li­brary. Li­censed un­der the MIT Li­cense.