B-Side / RPXL Kit PK-01 / Pocket Kit Build manual / Rev 0 Resin print + bought modules

PK-01Pocket music player

A pocket music player you build yourself, 66 by 78 millimetres and 15 thick. It plays FLAC and WAV up to 24 bit / 96 kHz through a 3.5 mm headphone jack, or over Bluetooth to wireless headphones and speakers. Everything inside is a bought module wired by hand: an Adafruit QT Py ESP32 Pico board, a screen module, a DAC board, a charger module and a LiPo cell. The case is printed in resin and painted. Your music library lives on a microSD card in a slot at the port end. Flat record cards, each carrying one album, slide into a slot in the top edge; that reader is optional.

Rev 0, unverified on hardware

This manual follows the CAD model as it stands. Every bought part is modelled at its nominal size from a datasheet or listing, and nothing has been built and measured yet. Measure each module when it arrives (section 04) before you print the parts that wrap it. The firmware in this tree is a draft that does not yet run on the QT Py (section 07).

The finished PK-01 from the front: a paper white body with a colour screen showing a playing track on the right, a column of four round olive keys on the left, a strip of dots between them, the wheel sleeve and hold cap on the right edge, and the jack, USB-C port and microSD slot on the port end
The finished PK-01 with the tall narrow OLED bar screen: the screen band runs down to the key column foot and the mark sits below it
FIG. 0 / RPXL PK-01 from the frontthe picture follows your screen
Size
66 x 7815.0 mm thick
Plays
FLAC, WAVup to 24 bit / 96 kHz
Output
Jack + Bluetoothheadphones and speakers
Screen
2.0 inch240 x 320 colour
Screen
1.9 inch170 x 320 colour
Screen
1.69 inch240 x 280 colour
Screen
1.47 inch172 x 320 colour
Screen
2.08 inch OLED256 x 64 mono bar
Screen
2.25 inch bar76 x 284 colour
Library
microSDin a slot at the port end
Cards
Record cardsflat, in the top edge (optional)
00

Choose your build

Choose onceChange any time, in the contentsOutput a manual for your build only

One body, three sets of choices. The shell, deck, keys, wheel, ports and the top edge slot are the same in every build. Pick a preset, or pick the screen, the card type and the parts tier yourself: the rest of this page then shows your build only.

Or choose each part yourself

Three choices

Screen

Sets the screen module you buy, the band you print and, for the two bars, the deck and a screen carrier. All six fit the one shell.

Record cards

How the cards you make carry their music. Both sit in the same printed card, a plain flat rectangle with eight gold pads flush in its underside, so the one reader reads either.

Parts tier

Which supplier line the parts list shows for each part. The printed parts are the same for all three.
The record card reader is optional

Record cards are not part of any preset. A build without them plays everything from the microSD library slot at the port end. To leave them out, skip the two lines marked Optional in the parts list (the reader's contact strip and the card microSD), the card prints and the rack, and print the slot blank, a card sized block that closes the slot. The shell is the same either way, so you can add the reader later. Leaving it out takes about AUD 9 off the Budget total, AUD 18 off Mid and AUD 59 off Premium (section 03).

A link keeps the choices

Your choices are saved in this browser and written into the address (for example ?preset=premium, or ?screen=19&card=msd&tier=mid), so a link opens the right manual. They are the only thing this page remembers. Without JavaScript, and on paper, every choice shows and each block names the choice it belongs to.

01

What you're building

Read 5 minNeeds nothingOutput the whole kit in your head

A one piece printed shell, a printed deck with four key caps, a screen band and a slot in the top edge for flat record cards, around bought modules that you wire together. Four black screws on the face hold the deck down. There is no circuit board to order for the player itself.

Exploded view of the PK-01 along its thickness: the card reader and a record card drawn out of the top edge slot, the cell and boards in the shell, then the screen module, band, deck, key caps and four screws above
FIG. 1 / Exploded along its thicknessCAD, 2.0 inch build

How it works

Seven ideas

Four screws, no inserts. Four M2 button head screws go down through the deck into four M2 nuts. Each nut sits in a slot trap in the side of a screw boss in the shell, slid in from the inside before anything else goes in. Three screws are M2 x 8; the top left boss hangs over the cell and takes an M2 x 5. One of the four also passes through the band.

Modules sit in printed cradles. The cell lies flat in the left half. The jack, the QT Py board, the charger, the DAC board, the encoder and the hold switch each sit on printed rails, fences and blocks. The screen module rests on four posts with a 0.5 foam pad on each, which presses it up into the band.

The screen is a band. The deck is an L shape round a dark band. Changing the screen means printing a different band (and for the two bars a different deck and a screen carrier).

The keys. Four round caps stand through the deck. Each has a flange under the deck that holds it in, and a stem that presses a tact switch on a printed carrier. The carrier snaps onto four split posts under the deck.

Two card slots. The music library is an ordinary microSD card in a push-push socket at the port end, under the USB-C port. Record cards go in a separate slot in the top edge: a printed channel guides a flat card edge first, and eight small springs on the channel floor press up on eight gold pads in the card's underside (section 10). The back is a plain skin: no door, window or latch.

Sound. The DAC board feeds the 3.5 mm jack. The QT Py is a classic ESP32, so it also streams to Bluetooth headphones and speakers, and plays to a docked SP-01 speaker over Bluetooth (section 11).

You solder by hand. Every module is wired to the QT Py board with thin silicone wire (section 06).

The stack

mm above the back
HeightWhat is there
12.8 to 15.0deck and band, 2.2 thick; the deck stands 0.4 above the rim and the caps 0.8 above the deck
12.2 to 14.2screen glass, under a 0.8 lip of the band
10.6 to 12.2screen module board
9.05 to 12.8key carrier, tact switches and cap flanges (left half)
6.2 to 9.4QT Py and DAC board on rails over the card channel roof; the nuts at 6.2 to 7.8
1.6 to 7.8the cell on its foam, with swell room to 8.5 (left half)
1.7 to 4.3the record card in its channel, resting on the reader's springs (right half)
1.2 to 1.6the reader's base, on the channel floor
0 to 1.4back skin (1.2 under the channel)
Cut-away through the PK-01 across the contact line of the card reader, seen from the port end: the screen under the band, the key caps and carrier, the DAC board, and the record card in its channel on the reader's springs
FIG. 2 / Section across the bodycut 48.1 mm from the port end, through the reader's contact line
What it will not do

No speaker and no headphone amplifier: the DAC board drives in-ear monitors directly, and 32 ohm and higher headphones will be quiet through the jack (use Bluetooth for those). Bluetooth is a transmitter only: it sends to headphones and speakers and does not receive from a phone. No MP3, AAC, ALAC, Ogg or Opus. Files above 96 kHz are refused, not resampled.

The port end face: a round headphone jack opening, a USB-C opening, and under it a long microSD slot
FIG. 2a / The port endjack, USB-C and library microSD

The port end. Three plain openings with small sloped edges and no icons, because the shapes say what they are: the headphone jack, USB-C for charging and flashing, and under it the library microSD slot. The card sits latched about 0.3 inside the end face.

02

Tools and supplies

Gather onceNeeds a benchOutput nothing missing mid-step

What you need besides the parts in section 03. Gather it before you start, so nothing is missing mid-step.

ItemWhat it is for
Printing
An MSLA resin printer with a build area of at least 196 x 122 mm and 210 mm of height (or a print service)every printed part; the shell is about 66 x 78 x 15 and the rack 22.2 x 25.8 x 22
A slicer that lets you add supports by handsupports go only on the face named for each part (section 05)
Plain printer paperlevelling the build plate (not card)
IPA or resin cleaner, two wash containers, UV cure stationwashing (dirty bath, then clean) and post-curing
Digital callipersthe exposure test, the 20 mm cube and measuring every bought module
Finishing
Flush cutters, hobby knife, a thin wedge scraperremoving supports while the part is green; lifting parts off the plate
Wet and dry paper, 400 and 800 grit; a scuff padsupport nubs, fit faces and the finish
Pin vise with small drill bits (1.1 mm and up)clearing screw holes and swabbing small pockets
Filler primer and matte paint (spray cans) and masking tapethe finish, one colour per part
Electronics
Soldering iron with a fine tip, solder, flux, wire strippers, tweezersevery wire in section 06, including the QT Py back pads
Multimeterchecking polarity, the key ladder and continuity before power
Heat shrink or kapton tapeinsulating the cell leads and joints
A steel rulechecking that a card's pads are level (section 10)
Card circuit board: a hot plate or hot air tool, solder paste and fine tweezerssoldering the SD NAND chip onto the card board
Assembly
A 1.5 mm hex keythe four M2 button head screws
Tweezers, a plastic spudgernuts, foam pads and wires
A soft clothworking on the face and the back without marking them
Firmware and cards
A computer with ESP-IDF 5.5 (see firmware/README.md) and a USB-C cableflashing the QT Py board (section 07)
A card reader, and a printer for sticker paperfilling record cards and printing their labels (section 10)
Safety
Nitrile gloves, eye protection, ventilationuncured resin, IPA and flying offcuts
A safe place to handle the LiPo cell: no piercing, bending or shorting its leadsa damaged or shorted cell can overheat
03

Parts

Order the modules firstMeasure each one on arrivalOutput everything on hand

Order the modules first and measure each one before you print the parts that wrap it. Any part matching the spec works; where an example helps it says so. Prices are in Australian dollars for one unit, October 2026, and the list follows your parts tier.

Printed parts

every STL in out/print/, already in its print pose

Print the player set, one screen set and, for a build with the record card reader, your cards and the rack; without it, print the slot blank instead. Each file is posed as listed and never lies flat on the plate. Add supports in the slicer only on the face named here. Settings and finishing are in sections 04 and 05.

FilePartQtyPose (x, y, z)Supports
The player
pk01_shell.stlshell1x -25, y 15, z 0back face toward the plate, tilted 25 and 15 degrees; supports on the back face (it rests on the desk and is sanded) and inside the cavity; two small vents in the back skin and four drains in the slot roof let the pockets drain
pk01_key_cap_back.stlkey cap back1x 35, y 0, z 45dish up, tilted 35 degrees; supports under the flange
pk01_key_cap_prev.stlkey cap prev1x 35, y 0, z 45as the Back cap
pk01_key_cap_play.stlkey cap play1x 35, y 0, z 45as the Back cap
pk01_key_cap_next.stlkey cap next1x 35, y 0, z 45as the Back cap
pk01_key_carrier.stlkey carrier1x 30, y 20, z 0inside part: any face may carry supports; flat side toward the plate, tilted
pk01_wheel_sleeve.stlwheel sleeve1x 35, y 0, z 0on edge, tilted 35 degrees; supports on the lower face (inside the body)
pk01_hold_cap.stlhold cap1x 0, y -60, z 0outer end up, tilted 30 degrees; supports on the inner face of the flange (inside the body)
The screen set
pk01_deck.stldeck1x 30, y 15, z 0face up, tilted 30 and 15 degrees; supports on the underside and the carrier posts only
pk01_band_2.0.stlband 2.01x 30, y 15, z 0face up, tilted; supports on the underside, the flange and inside the glass pocket (hidden by the glass)
pk01_deck_bar.stldeck bar1x 30, y 15, z 0bar screen builds only, in place of the deck: as the deck
pk01_band_oled_bar.stlband oled bar1x 30, y 15, z 02.08 mono OLED bar builds (Budget): as the 2.0 band
pk01_band_225_bar.stlband 225 bar1x 30, y 15, z 02.25 bar builds: as the 2.0 band
pk01_carrier_oled_bar.stlcarrier oled bar1x 30, y 20, z 0OLED bar builds: inside part, any face may carry supports
pk01_carrier_225_bar.stlcarrier 225 bar1x 30, y 20, z 02.25 bar builds: inside part, any face may carry supports
pk01_band_1.9.stlband 1.9 (in out/stl/, with the plain pk01_deck.stl above)1pose as the 2.0 bandas the 2.0 band; the module posts are placed for the 2.0 board, so give a smaller module its own posts before you print
pk01_band_1.69.stlband 1.69 (in out/stl/, with the plain pk01_deck.stl above)1pose as the 2.0 bandas the 2.0 band; the module posts are placed for the 2.0 board, so give a smaller module its own posts before you print
pk01_band_1.47.stlband 1.47 (in out/stl/, with the plain pk01_deck.stl above)1pose as the 2.0 bandas the 2.0 band; the module posts are placed for the 2.0 board, so give a smaller module its own posts before you print
Record cards, the rack and the slot blank
pk01_card_face.stlcard face1 per cardx 210, y 15, z 0per card, Budget or Premium: label face up, tilted; supports on the inner face (taped to the medium)
pk01_card_frame.stlcard frame1 per cardx 30, y 15, z 0per card, Budget or Premium: contact face up, tilted; the pocket is a through window; supports on the inner face (against the face half)
pk01_card_rack.stlcard rack1x 25, y 15, z 0base toward the plate, tilted; supports on the underside of the base only
pk01_slot_blank.stlslot blank1x 210, y 15, z 0builds without the record card reader only: key cut up, tilted; supports on the cut and the frame side (inside the slot)

Parts to buy

follows your parts tier
PartQtyWhereAUDFallbackChecked (2026-11-16)
Resin for the print set (player with the 2.0 screen set, one card and the rack: 31.0 cm3 printed, 35 percent waste, at A$0.044 per cm3)Resin for the print set (player with the 2.0 screen set, one card and the rack: 31.0 cm3 printed, 35 percent waste, at A$0.044 per cm3)JLC3DP print of the same 13 parts, all but the shell at the A$6 minimum, plus a A$30 parcel1home print, any tough opaque paintable resin1.841.84108.88none recordednot individually checked, 2026-11-16
Abrasives only: dark resin, satin by hand (800 grit and a scuff pad)Filler primer, satin black and one colour (shell, deck, band, caps)Filler primer, satin black and one colour (shell, deck, band, caps)1any hardware store (spray cans)3.0021.0021.00none recordednot individually checked, 2026-11-16
Wheel sleeve and hold cap (printed, in the resin line)Wheel sleeve and hold cap (printed, in the resin line)Machined aluminium wheel sleeve and brass hold cap1home print0.000.0015.00none recordednot individually checked, 2026-11-16
Adafruit QT Py ESP32 Pico from Pakronics (AU)Adafruit QT Py ESP32 Pico (#5395, ESP32-PICO-V3-02: Bluetooth Classic and BLE, 8 MB flash, 2 MB PSRAM, USB-C, 22.0 x 17.9)Adafruit QT Py ESP32 Pico (#5395, ESP32-PICO-V3-02: Bluetooth Classic and BLE, 8 MB flash, 2 MB PSRAM, USB-C, 22.0 x 17.9)1Little Bird (AU)30.0731.5531.55Little Bird AF-5395, A$31.55, 28 at supplier (catalogue page read)2026-11-16: Core Electronics in stock, A$28.30 (search page read). Little Bird in stock, A$31.55
USB-C mini Li-ion charger module, 600 mA CC/CV, 10 x 7.5 x 5.2 (its receptacle is not used: it takes 5 V from the QT Py's 5V pad)USB-C mini Li-ion charger module, 600 mA CC/CV, 10 x 7.5 x 5.2 (its receptacle is not used: it takes 5 V from the QT Py's 5V pad)USB-C mini Li-ion charger module, 600 mA CC/CV, 10 x 7.5 x 5.2 (its receptacle is not used: it takes 5 V from the QT Py's 5V pad)1AliExpress (search: type-c mini lithium charger board)1.501.501.50none recordednot individually checked, 2026-11-16
STEMMA QT / Qwiic JST SH 4-pin lead, 100 mm (the wheel's A and B on its two data wires)STEMMA QT / Qwiic JST SH 4-pin lead, 100 mm (the wheel's A and B on its two data wires)STEMMA QT / Qwiic JST SH 4-pin lead, 100 mm (the wheel's A and B on its two data wires)1Little Bird (AU)1.501.501.50Little Bird has the 150, 200, 300 and 400 mm leads too2026-11-16: Little Bird AF-4399 STEMMA QT cable, A$2.15, 16 in Sydney
2.08 mono OLED bar (ER-OLED0208-1W, 256 x 64, BuyDisplay) and a 30 pin 0.5 FPC adapter board: the Budget screen, with the bar deck, band and carrier prints2.0 inch ST7789 240 x 320 IPS SPI module, PCB 35 x 58, no connector fitted (Waveshare 2inch LCD Module)2.0 inch ST7789 240 x 320 IPS SPI module, PCB 35 x 58, no connector fitted (Waveshare 2inch LCD Module)1Waveshare via an AU stockist18.0022.0022.00Not confirmed. Little Bird WS-19888 (A$21.50, in stock) is the Pico version with a different PCB, not a drop-innot stock checked, 2026-11-16
GY-PCM5102 PCM5102A I2S DAC board, 32 x 17 (do not fit its jack or header pins)GY-PCM5102 PCM5102A I2S DAC board, 32 x 17 (do not fit its jack or header pins)GY-PCM5102 PCM5102A I2S DAC board, 32 x 17 (do not fit its jack or header pins)1AliExpress (search: GY-PCM5102)5.005.005.00Adafruit PCM5102 (AF-6250): Little Bird A$9.70, Core A$8.95, in stock (search pages read). Different board size from the GY-PCM5102 (32 x 17), so check the bay2026-11-16: no GY-PCM5102 at an AU source found; AliExpress only
Optional, record card reader: a strip of eight spring contacts at 1.1 pitch that lies flat under the card (about 12.0 x 11.0 x 0.4; the exact part is confirmed by measurement)Optional, record card reader: a strip of eight spring contacts at 1.1 pitch that lies flat under the card (about 12.0 x 11.0 x 0.4; the exact part is confirmed by measurement)Optional, record card reader: a strip of eight spring contacts at 1.1 pitch that lies flat under the card (about 12.0 x 11.0 x 0.4; the exact part is confirmed by measurement)1Mouser AU or element14 AU2.003.503.50none recordednot individually checked, 2026-11-16
Push-push microSD socket (flush latching, Molex 104031-0811 class) on a small breakout, for the library slotPush-push microSD socket (flush latching, Molex 104031-0811 class) on a small breakout, for the library slotPush-push microSD socket (flush latching, Molex 104031-0811 class) on a small breakout, for the library slot1AliExpress (search: push push micro SD breakout)2.002.002.00Adafruit AF-1660 microSD socket, Little Bird A$4.10, 100 at supplier (a different socket, check the footprint)not stock checked, 2026-11-16: AliExpress listing only
microSD card, 32 to 128 GB, for the library slotmicroSD card, 32 to 128 GB, for the library slotmicroSD card, 32 to 128 GB, for the library slot1any electronics store12.0012.0012.00none recordednot individually checked, 2026-11-16
PJ-320 class 3.5 mm panel jack (pack of 10)PJ-320 class 3.5 mm panel jack (pack of 10)PJ-320 class 3.5 mm panel jack (pack of 10)1AliExpress (search: PJ-320A)2.002.002.00none recordednot individually checked, 2026-11-16
SIQ-02FVS3 thumbwheel encoder with pushSIQ-02FVS3 thumbwheel encoder with pushSIQ-02FVS3 thumbwheel encoder with push1AliExpress or LCSC4.004.004.00none recordednot individually checked, 2026-11-16
5.2 x 5.2 SMD tact switch, 1.5 tall (TS-1187A class, pack; 4 used)5.2 x 5.2 SMD tact switch, 1.5 tall (TS-1187A class, pack; 4 used)5.2 x 5.2 SMD tact switch, 1.5 tall (TS-1187A class, pack; 4 used)1AliExpress or Jaycar2.002.002.00none recordednot individually checked, 2026-11-16
MSK12C02 SPDT slide switch (pack)MSK12C02 SPDT slide switch (pack)MSK12C02 SPDT slide switch (pack)1AliExpress (search: MSK12C02)2.002.002.00SparkFun SPDT slide switch SF-COM-09609, Little Bird A$0.80, 1759 in Sydney (different body, check the cut-out)not stock checked, 2026-11-16: AliExpress listing only
Resistors for the key ladder, battery divider and the record card detect (1 M), 30 AWG silicone wire, two coloursResistors for the key ladder, battery divider and the record card detect (1 M), 30 AWG silicone wire, two coloursResistors for the key ladder, battery divider and the record card detect (1 M), 30 AWG silicone wire, two colours1Jaycar or Altronics3.003.003.00none recordednot individually checked, 2026-11-16
602560 LiPo, 1000 mAh, protection board, JST PH 2-pin (6 x 25 x 60, no bigger than 25.5 x 61 x 6.2)602560 LiPo, 1000 mAh, protection board, JST PH 2-pin (6 x 25 x 60, no bigger than 25.5 x 61 x 6.2)AU-stocked 602560 class 1000 mAh LiPo (check the size)1AliExpress (search: 602560 1000mAh)7.007.0018.60Not checked at an AU source. Little Bird LB-00238 (1200 mAh, A$18.60, in stock) is the nearest stocked cell, size unconfirmednot checked at an AU source (AliExpress listing only), 2026-11-16
microSD card, 8 to 32 GB, for the Budget record card (reader builds only)microSD card, 8 to 32 GB, for the Budget record card (reader builds only)Premium record card: 0.4 card PCB 11 x 15, ENIG (JLCPCB, 5 boards) and SD NAND 1 GB LGA-8 (LCSC, 5)1any electronics store6.006.0035.00none recordednot individually checked, 2026-11-16
Plain paper labels under clear tapePrintable matte vinyl sticker paper, A4 (face, spine and back labels)Printable matte vinyl sticker paper, A4 (face, spine and back labels)1Officeworks1.008.008.00none recordednot individually checked, 2026-11-16
M2 ISO 7380 button head, black (three M2 x 8, one M2 x 5 for the top left boss) and M2 DIN 934 nuts (4), packsM2 ISO 7380 button head, black (three M2 x 8, one M2 x 5 for the top left boss) and M2 DIN 934 nuts (4), packsBlack stainless M2 x 8 and M2 x 5 button heads and nuts from an AU fastener shop1AliExpress (search: M2 button head black)4.004.0012.00none recordednot individually checked, 2026-11-16
Foam and tape: 0.5 pads for the screen posts, 0.2 foam under the cell, thin double-sided tapeFoam and tape: 0.5 pads for the screen posts, 0.2 foam under the cell, thin double-sided tapeFoam and tape: 0.5 pads for the screen posts, 0.2 foam under the cell, thin double-sided tape1any hardware store4.004.004.00none recordednot individually checked, 2026-11-16
Shipping, one small AU parcel and the BuyDisplay post (AliExpress free)Shipping, AU parcelsShipping, AU parcels1Core Electronics or DigiKey AU12.0010.0015.00none recordednot individually checked, 2026-11-16
Total123.91153.89329.53
Approximate build cost

Budget preset: AUD 124 for one unit. The mono OLED bar, the cheapest line for each part and a home print.

Mid preset: AUD 154 for one unit. The 2.0 inch colour module, listed suppliers and a home print.

Premium preset: AUD 330 for one unit. A print service casing, machined sleeve and cap, black stainless screws and card circuit boards for the cards.

Approximate cost for one player, the record card reader, one record card and the rack, from supplier listings in October 2026. Without the record card reader the totals are AUD 115, 136 and 271 for Budget, Mid and Premium. The AU parcel line covers the Core Electronics and DigiKey orders; the AliExpress lines ship free but slowly. Resin is counted at AUD 0.044 per cm3 of printed volume plus 35 percent waste; the bottle, IPA, gloves and tools are treated as owned. Several parts ship in packs, so the first unit costs more than later ones.

Order notes

Every module is modelled at a nominal size. Order one of each and measure before a second order: the screen module first (board 35 x 58, panel 2.0 thick), then the QT Py ESP32 Pico (22.0 x 17.9, the height of the parts on both faces, and where its antenna ends), the card reader's contact strip (base thickness and spring height), the push-push library socket and the GY-PCM5102 (32 x 17, with its jack and header pins left off). The DAC is the GY-PCM5102 because nothing smaller with a PCM5102A was found: the Adafruit boards are 20 mm wide and do not fit the 17 wide space beside the slot channel. There is no room for a headphone amplifier, and the PCM5102A drives in-ear monitors directly.

The reader is a strip of eight spring contacts at 1.1 pitch that lies flat under the card and presses on its gold pads. It lies on the channel floor with nothing under it, and its 0.4 base puts the card seat at 1.6. The exact part is being confirmed by measurement: before you order a second one, measure the first one's base thickness and spring height. Solder 30 AWG wires to its eight tails.

The QT Py has no LiPo charger and no native USB (its USB-C goes to a serial chip), so the list adds a small charger module fed from the board's 5V pad and a STEMMA QT lead that carries the wheel's two signals. Record cards are optional (section 00): without the reader, leave out the two lines marked Optional, the record card and the rack, and print the slot blank. Budget cards carry a standard microSD taped into the printed card; Premium cards carry the 0.4 card board, 11 x 15, with an SD NAND (outline and pads in out/card/). Each extra Budget card costs the microSD plus about AUD 0.10 of resin; each extra Premium card about AUD 7. The two bar screens are bare glass with a flex tail: they also need a flex to pin adapter board (30 pin for the OLED, 12 pin for the 2.25 bar) and a printed screen carrier.

04

Print setup: calibrate first

Time an eveningNeeds printer, callipersOutput a printer that prints true

Every fit in this kit depends on your printer printing true. Do this list before you print a single part: each item, skipped, can stop a part from fitting.

  • Level the build plate with plain printer paper, not card. Loosen the plate, lay the paper on the screen, press the plate down evenly, tighten it, then set Z = 0.
  • Use 0.05 mm layers. The engraving is 0.4 deep and the dot strip is 0.6 deep, so thicker layers lose them.
  • Calibrate the exposure for your resin and room temperature with an exposure test print. Choose the time at which 0.8 mm features print crisp, a 0.8 gap stays a gap, and a 1.0 mm post fits a 1.2 mm hole.
  • Check the size. Print a 20 mm cube and confirm X and Y are within 0.05 mm. Every fit tolerates +/-0.2 mm, but the card in its channel has only 0.3 a side, so keep the cube honest.
  • Keep the resin warm, about 25 C, and stir it before every print.
  • Measure the bought modules (the table below) before you print the parts that wrap them.

The values the model uses

all nominal until measured
WhatValue in the modelWhere it is set
Screen module board, panel and where its active area sits35 x 58 x 1.6; panel 34.6 x 45.8 x 2.0; active area 30.6 x 40.8MOD
Reader contact strip: base, spring height and the card seatbase 12.0 x 11.0 x 0.4; leaves 0.35 above the base; card seat at 1.6 above the back; 8 contacts at 1.1 pitchREADER
Push-push library microSD socket and its breakout14.0 x 15.2 x 1.85; breakout 15.6 x 18.0 x 1.0; card latched 0.3 inside the end facePSD
GY-PCM5102 board and tallest part (jack removed)17 x 32 x 1.6; parts 1.4DAC
QT Py ESP32 Pico: board, USB-C shell and part heights17.9 x 20.7 x 1.0; USB-C stands 1.3 past the edge; top parts 2.2; back parts 1.7MCU
Charger module7.5 x 10.0 x 5.2CHG
602560 cell, the largest size the space takes25.5 x 61.0 x 6.2CELL
Encoder dial and bodydial 11.0 x 2.0; body 8.5 x 10.6 x 2.0WHEEL
Tact switch and plunger5.2 x 5.2 x 1.0; plunger 0.8 x 0.5; travel 0.25TACT
Hold switch body and actuator6.7 x 2.6 x 1.4; actuator 1.6 x 1.5 x 1.0HOLD
Bar screens: glass, view area and flex widthOLED 19.0 x 60.5 x 1.6; 2.25 bar 17.9 x 62.5 x 2.3BAR_SCREENS
M2 button head and nuthead 3.5 x 1.3, length 8 (5 for the top left); nut 4.0 across flats x 1.6M2
If a value differs by more than 0.3 mm

Change it in params.py. Run python print_files.py --dfm to rewrite the print set, then pytest tests (always pytest tests: a bare pytest also collects the firmware's vendored folders). Print the new files only if every test passes; a failing test names the fit that no longer holds.

The values that matter most are the reader's contact strip (the stack under the card closes with only 0.1 to spare), the screen module (its stack margin to the QT Py's top parts is only 0.2) and the DAC (0.4 to the screen module tail).

05

Print and finish the parts

Time two prints, two evenings of finishingNeeds a calibrated printerOutput every printed part, painted

Every STL is already in its print pose, tilted, and never flat on the plate. Add supports by hand only on the face named for the part in section 03: every cosmetic face looks away from the plate. The shell is the big one; print it first and fit it before you print the rest.

Print order

fit as you go
  1. The shell. Print it, wash it, cure it, and fit a nut into each of the four side slots. Check the slots, the QT Py rails, the cell space, the jack saddle and the slot channel against the bought parts. A part that does not fit now is a measuring or exposure problem to fix before you print more.
  2. The screen set, the key caps and the key carrier. With the deck on the shell, check the caps drop into their holes and the band lies in its pocket.
  3. The wheel sleeve and the hold cap. Both are small. Check the sleeve presses onto the encoder dial (a 0.05 a side press fit) and the cap clips over the switch actuator.
  4. A card, then the rack, or the slot blank. Print one card first (section 10) and slide it into the channel to check the fit: it must go the whole way with a light push. Without the record card reader, print the slot blank instead and press it in.

Supports, and what to do about each

only on hidden faces
  • Shell. Its back face goes toward the plate, tilted 25 and 15 degrees. Put supports on the back face (it rests on the desk and is sanded) and inside the cavity. Two small vent holes in the back skin and four drains in the channel roof stop the pockets sealing against the film: keep them open. The slot channel drains through its mouth and the finger notch.
  • Deck, band and the bar decks. Face up, tilted. Supports on the underside, the flange and inside the glass pocket (hidden by the glass). Never on the face.
  • Key caps. Dish up, tilted 35 degrees, supports under the flange only. Never support the dish or its glyph.
  • Card halves, slot blank and rack. The label half has its label face up and the contact half its contact face up, both tilted, with supports on the inner faces that are joined together; the pocket in the contact half is a through window. The slot blank has its key cut up, with supports on the cut and the frame side inside the slot. The rack stands on its base, tilted, with supports on the underside of the base only.
  • Key carrier and screen carriers. Inside parts: any face may carry supports.
  • Wheel sleeve and hold cap. Supports on the faces inside the body only. Peel them gently.
Small leftovers

A few pockets in the shell and the two bar bands hold a few cubic millimetres of resin that cannot vent to a hidden face (each under 10 mm3): the two screw clearance holes under the right nut slots, a corner between the right DAC rail and the reader bay wall, a corner between the bay wall and the stop wall, the top left corner by the cell rib, the space under the shelf by the bottom left boss and, on the bar bands, the top left corner of the glass pocket. Swab them after the first wash.

Finishing

after the fit check
  1. Wash in two baths (dirty, then clean) of IPA or the resin's own cleaner. Blow out the vents, the nut slots and the screw holes.
  2. Take the parts off the plate with a thin wedge scraper and remove supports while the parts are still green. Let them dry fully.
  3. Cure under UV for the resin's stated time, turning each part halfway. Do not over-cure the thin parts: the key carrier and the cards.
  4. Sand the support nubs flat (400, then 800 grit), and keep the sanding off the fit faces: the slot channel, the card pocket walls and edges, the deck holes, the cradles.
  5. Prime with a thin, even coat of grey filler primer, then sand it lightly at 800 grit.
  6. Paint with a flat matte finish, one colour per part, from the list below. Paint after the fit check, never before it, and keep paint off the fit faces: a coat adds a few hundredths of a millimetre.
Never paint the type

The mark and the key glyphs are engraved in the part's own colour and read by shape. Never fill an engraving with another colour. The three port openings carry no icons: their shapes say what they are. If a key cap or the sleeve gets stiff after painting, thin the paint, not the part.

Paint list

flat matte, one colour per part (the example is paper white with olive)
PartExample colour
Shell, deck, slot blank, card rackpaper white
Band (the screen band)charcoal
Key caps, wheel sleeve, hold capolive
Record cardsany single colour per card, so they are easy to tell apart; mask the window and keep paint out of the channel
Key carrier, screen carriernot painted: they are inside
06

Wiring by module pin

Time an eveningNeeds soldering iron, multimeterOutput a wiring harness, checked

Every module is wired to the Adafruit QT Py ESP32 Pico with 30 AWG silicone wire, two colours. The table says which pad each wire goes to, on both ends. Wire the modules in the order of the assembly steps, but read the whole table first.

Pin assignment

The firmware reads its pins from one header, firmware/components/pk_board/include/pk_pins_qtpy.h. The table below is the assignment that header holds: wire exactly this. The QT Py has 14 usable GPIOs and the player uses all 14, so there is no spare pin. Every wire has two ends: do not guess a pad from its colour.

PK-01 wiringThe QT Py ESP32 Pico in the middle, with each module wired to it pad by pad QT Py ESP32 Pico USB-C at the port end SCK GPIO14 SPI clock MO GPIO13 SPI MOSI A0 GPIO26 SPI MISO A3 GPIO15 LCD CS BOOT GPIO0 LCD DC A2 GPIO27 library CS A1 GPIO25 record card CS 3V3 pad GND pad SDA GPIO4 I2S BCK RX GPIO7 I2S LRCK MI GPIO12 I2S DATA SCL1 GPIO19 wheel A (STEMMA) SDA1 GPIO22 wheel B (STEMMA) TX GPIO32 key ladder SCL GPIO33 battery, USB sense 5V pad BAT pads (back) Screen module (2.0 inch, SPI)DIN to MO CLK to SCKCS to A3 DC to BOOT padRST to 3V3 BL to 3V3VCC to 3V3 GND to GND Library microSD (push-push, SPI)CS to A2 CMD to MO CLK to SCKDAT0 to A0 VDD 3V3 VSS GNDDAT1, DAT2: 10 k to 3V3 Record card reader (8 tails)pin 2 (CS) to A1, 1 M to GNDpin 3 (CMD) to MO pin 5 (CLK) to SCKpin 7 (DAT0) to A0pin 4 (VDD) 3V3 pin 6 (VSS) GNDpins 1 and 8: 10 k to 3V3 GY-PCM5102 DAC boardLCK to RX DIN to MIBCK to SDA SCK to GNDVIN to 3V3 GND to GNDL, R, GND pads to the jack SIQ-02FVS3 encoderA to SCL1 (yellow) B to SDA1 (blue)common to GND (STEMMA black)push switch: see the ladder Keys, wheel push, hold3V3 - 22 k - node (to TX)Play 2.2 k, Back 5.6 k, Prev 12 k,Next 22 k, wheel push 39 k,hold slide 62 k; each to GND Charger, LiPo 602560, divider5V pad to charger IN+, GND to IN-charger OUT+ to cell + and BAT+charger OUT- to cell - and BAT-divider: 100 k cell + to node,100 k node to GND, 100 nF, node to SCL,100 k from 5V pad to the node 3V3 and GND feed every module; power wires drawn in red, signals in black
FIG. 3 / The wiring in one picturepower in red, signals in black

Every wire, pad by pad

QT Py pad names are the silkscreen names
FromTo (QT Py)What it carries
Power, charging and ground (one star point: the QT Py 3V3 and GND pads)
Charger module IN+ and IN-5V pad and GND padUSB power for charging. The charger's own USB-C receptacle is not used
Charger OUT+, and the cell + (protection board B+)BAT+ pad (back)the cell, charged by the module and feeding the board; also the top of the sense divider
Charger OUT-, and the cell - (protection board B-)BAT- pad (back)battery return
Divider: 100 k from cell + to a node, 100 k from the node to GND, 100 nF from the node to GND, and 100 k from the 5V pad to the nodeSCL pad (GPIO33)battery and USB sense on one pin: 1.0 to 2.1 V on battery, 2.6 to 3.0 V with USB in. Above 2.35 V the player knows it is on USB
Screen module (SPI) Bar screens: use the flex adapter board's pins of the same names
DINMO pad (GPIO13)data to the screen and both card sockets
CLKSCK pad (GPIO14)clock, shared with both card sockets
CSA3 pad (GPIO15)screen chip select
DCBOOT button pad (GPIO0)data or command. The board holds this pin high at power-up: check the module's DC has no pull-down
RST, BL, VCC3V3reset held high, backlight always on (no dimming), power
GNDGND
Library microSD socket (push-push, on its breakout), SPI mode
CS (DAT3)A2 pad (GPIO27)library card chip select
CMDMO pad (GPIO13)shared with the screen
CLKSCK pad (GPIO14)shared with the screen
DAT0A0 pad (GPIO26)data back from the cards, shared by both sockets. Not on the MI pad: a card holds its DAT0 high, which would set a boot strap
DAT1, DAT23V3 through 10 k eachunused lines held high
VDD / VSS3V3 / GND
Record card reader (the spring contact strip), eight tails, SPI mode. Optional
Pin 2 (CS)A1 pad (GPIO25), and 1 M to GNDrecord card chip select. It is also the card detect: a seated card holds this line high through its own pull-up, the 1 M keeps it low when there is no card
Pin 3 (CMD)MO pad (GPIO13)shared
Pin 5 (CLK)SCK pad (GPIO14)shared
Pin 7 (DAT0)A0 pad (GPIO26)shared
Pin 4 (VDD) / pin 6 (VSS)3V3 / GND
Pin 1 (DAT2), pin 8 (DAT1)3V3 through 10 k eachunused lines held high
GY-PCM5102 DAC board (I2S)
BCKSDA pad (GPIO4)bit clock
LCKRX pad (GPIO7)word clock
DINMI pad (GPIO12)audio data. This pin is a boot strap: the DAC input has no pull-up, so it reads low at reset, which is what the board needs
SCKGNDno master clock: the board makes its own (check the seller's drawing for the solder pad)
VIN, GND3V3, GNDpower (check the board's 3.3 V solder bridge)
Board solder pads L, R, GNDjack: tip, ring, sleeveline out to the headphone jack; find tip and ring with a plug and the multimeter
Wheel encoder (SIQ-02FVS3), through a STEMMA QT lead plugged into the board's socket
Ayellow wire, SCL1 (GPIO19)quadrature A, internal pull-up
Bblue wire, SDA1 (GPIO22)quadrature B, internal pull-up
Commonblack wire, GNDthe red 3V3 wire is cut back and left unconnected
Keys, wheel push and hold: one ADC pin, the TX pad (GPIO32)
22 k from 3V3TX pad (GPIO32)the ladder node; the idle level is 3.3 V
Play key, then 2.2 kto the node, other side to GNDabout 0.30 V when pressed. The lowest level, so Play wakes the player from deep sleep
Back key, then 5.6 kto the node, other side to GNDabout 0.67 V
Prev key, then 12 kto the node, other side to GNDabout 1.16 V
Next key, then 22 kto the node, other side to GNDabout 1.65 V
Encoder push switch, then 39 kto the node, other side to GNDabout 2.11 V
Hold slide: common to GND, one throw then 62 kto the nodeabout 2.43 V while hold is on
Checks before power

With the cell not yet connected, the multimeter should read: 3V3 to GND open (no short); the TX pad to GND about 22 k with no key pressed, and the table's resistance in parallel with 22 k with each key held. If you build without the record card reader, nothing connects to the A1 pad. The QT Py back pads are small: tin the wire first, then touch it to the pad, and check the neighbouring pads for bridges. The cell and BAT pads are polarity sensitive. Reversed, the board and the cell are destroyed. Keep wires away from the end of the board opposite the USB-C: the antenna is there.

07

Firmware: flash the QT Py board

Time 30 minNeeds the QT Py board, a USB-C cableOutput a board known to boot

Flash the QT Py on the bench before you put anything in the shell, so a dead board costs you nothing else. The board takes the firmware over its own USB-C port through its USB to serial chip, with no battery fitted.

A draft: built for this board, never run on it

The firmware in firmware/ now targets the classic ESP32 of the QT Py (idf.py set-target esp32) and takes its pins from pk_pins_qtpy.h. It has both cards on the shared SPI bus, the record card detect on the A1 pad, the key ladder, the wheel on the STEMMA pins, the ST7789 screen, the Bluetooth (A2DP) source and the docked behaviour. It builds and its host tests pass, but nothing has run on this hardware: expect to find and fix things at power-up. The screens are chosen in config.txt (below) and the full-screen layout is drawn for the 2.0 inch 240 x 320 module and scaled for the 1.9, 1.69 and 1.47; there is no USB storage mode (the QT Py's USB-C is a serial chip, not the ESP32's own USB: use a card reader). firmware/README.md lists what is unmeasured and what is not written.

  1. Install ESP-IDF 5.5 as firmware/README.md says.
  2. Set the pins. The firmware takes its pins from pk_pins_qtpy.h, which matches the table in section 06, and the screen settings from the screen you built (config.txt below).
  3. Build and flash with the QT Py on a USB-C cable:
    idf.py set-target esp32
    idf.py build
    idf.py flash monitor
    If the board does not appear as a serial device, hold its BOOT button, tap its reset button, then release BOOT, and run the flash again.
  4. Read the log. It should show the board starting, the library card (size and file system), the screen, the DAC and the Bluetooth stack coming up. A missing library card is reported on the screen, not fatal; a missing record card reader is not reported at all, because it is detected only when a card is pushed in.

config.txt

on the library card, every key optional
# PK-01 settings. Lines are key = value. Delete a line to use the default.
screen = auto            # auto, oled, ips (auto is ips)
ips_size = auto          # ips: auto (2.0), 2.0, 1.9, 1.69, 1.47, 2.25 (the narrow bar)
ips_driver = auto        # 2.25 bar only: auto, st7789p3, nv3023b
volume_limit = -6        # dB, 0 is the loudest
start_volume = -30       # dB at power-on
brightness = 70          # percent
screen_timeout = 15      # seconds while playing
sleep_after = 10         # minutes paused, 0 is never
music_folder = /Music    # / for the whole card
sort_ignore_the = yes
gapless = yes

Bad values and unknown keys are logged and ignored. The volume at power-on is never louder than volume_limit. With the backlight wired to 3V3 the brightness setting has no effect. Set screen = oled for the 2.08 inch mono bar (the Budget screen) and ips_size to match the colour module you fitted; with nothing set the player drives a 2.0 inch 240 x 320 ST7789. The keys audio and hp_mode of the earlier board are accepted and ignored: this build has one DAC.

08

Assembly

Time an eveningNeeds your parts and the printed setOutput a closed, working player

Fourteen steps, in the order the model goes together. Each step has a check: do it before you go on. Step 1 and the card in step 14 belong to the optional record card reader.

Battery first rule

Connect the cell last, with the multimeter checks done, and with its polarity checked twice. Never leave the cell connected while you solder. A shorted LiPo can overheat.

  1. 01

    Fit the card reader (optional)

    Shell, spring contact strip, 8 wires
    The shell cut open above the slot channel with the reader, a small black strip with eight gold springs, lifted out beyond the top edge and an arrow pointing into the slot

    Skip this step if you build without the record card reader: print the slot blank and press it in at step 14. Otherwise solder a 30 AWG wire to each of the eight tails of the contact strip (section 06), about 80 mm long.

    Lay the shell on the cloth, cavity up, port end toward you. The strip lies flat on the floor of the slot channel in the top edge with its springs facing up and its tails toward the inside of the shell. Slide it in through the mouth of the slot, tails first, until its rear edge meets the end of the channel, and lay the wires in the bay behind the two stop shoulders, feeding them out through the wire gate, a 4 mm wide opening in the bay's front wall on the slot's centre line, then on toward the QT Py. The picture shows the shell cut open above the channel so the strip is visible; yours has its roof.

    The reader lies flat and level on the channel floor, its springs stand about 0.35 above the base and none is bent or twisted, and the eight wires lie in the bay behind the shoulders. A card laid on it (step 14) must still slide in freely.

  2. 02

    Slide the nuts into the screw bosses

    Shell, 4 x M2 nut
    The empty shell with four M2 nuts above the four screw bosses, arrows pointing down

    Lay the shell on the cloth, cavity up, port end toward you. Each of the four screw bosses has a slot cut in its side, open toward the inside of the body: three at 6.2 to 7.8 above the back, and the top left one higher, at 9.6, because that boss hangs over the cell. Slide an M2 nut flat into each slot until it stops against the boss.

    Each nut sits flat in its slot with its hole over the boss's screw hole, and cannot fall out when you tip the shell. If a nut will not go in, swab the slot and check the print was not over-exposed.

  3. 03

    Lay the cell on its foam

    Shell, cell, 0.2 foam
    The 602560 cell and a thin foam sheet above the left half of the shell, arrows pointing down

    Lay the 0.2 foam on the floor of the left half of the shell. Set the 602560 cell on it with its protection board and lead at the port end. Tape the lead flat along the wall, away from the jack and the screw holes.

    The cell lies flat between the wall and the slot channel without being forced, and the lead leaves at the port end. The space takes at most 25.5 x 61.0 x 6.2, and the top left boss clears the cell by about 0.1 when the cell swells.

  4. 04

    Fit the library socket, the jack, the hold switch and the encoder

    Library socket and breakout, jack, hold switch, encoder
    The library microSD socket and its breakout board, the headphone jack, the hold switch and the thumb wheel encoder lifted above their places on the shell

    Wire these four first (section 06), then fit them. The library microSD socket sits on its breakout board at the port end, with its card slot toward the end face, in the same column as the USB-C port above it; set the board on the back skin between its fences. The jack sits in its saddle between two cheeks at the port end, with its nose through the round opening. The hold switch sits on its pillar on the right edge with its actuator toward the slot in the right wall. The encoder body sits in its block at the top right with its dial facing the slot in the right wall.

    The jack nose is flush with its opening, the library socket's slot lines up with the long opening at the port end, the switch actuator lines up with its slot in the right wall, and the encoder dial lines up with the slot above it.

  5. 05

    Fit the QT Py, the charger and the DAC board

    QT Py ESP32 Pico, charger module, GY-PCM5102
    The QT Py board, the charger module and the DAC board lifted above their rails in the shell

    The QT Py sits at the port end on two rails with its USB-C port in the opening, held by two small hooks at its far corners, over the library socket. The charger module sits to its right, on a 0.2 foam pad on the back skin, between its fence and the stop behind it. The DAC board sits above them on two rails. Before fitting, solder the wires to the QT Py's back pads (BAT+ and BAT-), because they run under the board, and plug the STEMMA QT lead into its socket.

    The USB-C port is in line with its opening and a cable mates fully. The DAC board lies flat on its rails, about 0.5 from the QT Py's antenna end, and nothing touches the screen's space above (the margin is 0.4).

  6. 06

    Wire everything to the QT Py

    Wires, resistors, 22 k and 100 k
    All the modules in place in the shell, ready to be wired

    Make the connections in section 06, one module at a time, and tick them off as you go. Keep wires flat along the walls and over the channel roof, short and tied back, so nothing is trapped by the deck. Keep them off the antenna end of the QT Py. Insulate every joint. Solder the ladder resistors in a tight bundle at the key carrier side.

    The multimeter checks in section 06 pass. The cell is still not connected.

  7. 07

    Seat the screen

    Screen module, 4 foam pads
    The screen module above the four posts in the shell, with a foam pad above each post
    The bar screen's carrier and glass above the four posts in the shell

    Colour module: Stick a 0.5 foam pad on each of the four posts. Lay the module on the posts with its screen up and its connector tail toward the port end, with the module board over the posts.

    Bar screens: Stick a 0.5 foam pad on each of the four posts. Tape the flex adapter board to the back of the glass, plug the flex into it, and wrap the flex round the end of the carrier through the 18 wide relief in the top end shelf. Seat the screen carrier on the posts, the glass on top of it, the adapter through the carrier window.

    Wire the module as section 06 says before it goes down, with its wires leaving at the tail.

    The module (or the glass) lies level on the four pads, about 0.2 under the QT Py's tallest part. The pads press it up into the band in the next step, so it must rock freely before then.

  8. 08

    Put the key caps into the deck

    Deck, 4 key caps
    The deck turned over, underside up, with the four round key caps lifted above their holes

    Turn the deck over, face down on the cloth. Drop each round cap into its hole from the underside, flange first, stem toward you. The flange holds the cap in the deck, and the cap should move freely by about a quarter millimetre.

    All four caps drop in without force, spin freely and stand about 0.8 above the deck's face when you turn it over.

  9. 09

    Snap the key carrier on

    Key carrier, 4 tact switches
    The deck underside with the key carrier and four tact switches lifted above the four split posts

    Seat a tact switch in each of the four fenced pockets of the carrier, then wire them (section 06) through the slots in the carrier's edge. Press the carrier onto the four split posts under the deck until each barb clicks. The carrier's corner is notched so it clears the jack's tail.

    The carrier is level and does not rock. Press each cap: you feel a click at about a quarter millimetre of travel, and the cap springs back.

  10. 10

    Lay the band over the screen

    Band
    The band above the shell, over the screen module, ready to lie on the shelf

    Lay the band over the screen with its window over the glass, its flange down in the shelf at the left edge. The glass sits in the pocket under the band's 0.8 lip. The band's top right corner has a column for the fourth screw.

    The band lies flat on the shelf with its edge 0.4 below the rim, and the glass shows through its window with no gap at the lip.

  11. 11

    Lower the deck

    Deck, key caps, key carrier
    The deck with its key caps and carrier lowered over the band onto the shell

    Plug the key ladder wires in place if you have not yet (section 06). Connect the cell last: the cell lead to the charger module and the QT Py's BAT pads, with the right polarity. Lower the deck onto the shell with the carrier over the cell, tucking the wires in. The band and the deck close with a 0.8 seam.

    The deck lies flat with no wire under its edge, and the four screw holes line up with the nuts below.

  12. 12

    Fit the four screws

    3 x M2 x 8 and 1 x M2 x 5 button head
    Four button head screws above the four screw holes of the closed body

    Put an M2 x 8 button head screw in each of the three holes at the bottom left, bottom right and top right, and the shorter M2 x 5 in the top left hole, over the cell. Tighten them with the 1.5 mm hex key, a little at a time, in a cross pattern. The top right screw passes through the band. Stop when the heads sit flush.

    All four heads are flush with the deck. The tip of each screw stops in its nut, short of the cell and the boards.

  13. 13

    Fit the wheel sleeve and the hold cap

    Wheel sleeve, hold cap
    The knurled wheel sleeve and the hold cap beside the right edge of the closed body, arrows pointing at their slots

    Press the wheel sleeve onto the encoder dial through the slot in the right wall, evenly, until it stands 1.4 proud of the edge. Press the hold cap onto the switch actuator through its slot in the right wall, below the wheel.

    If either is tight, check the dial and the actuator against section 04. Never hammer.

    The sleeve turns the dial and clicks when you push it. The hold cap slides about 1.5 mm each way, and the switch moves with it.

  14. 14

    Load a record card, or the blank

    Record card or slot blank
    A record card with its label up lifted out beyond the top edge of the closed player, an arrow pointing into the slot

    Hold the card with its label toward the screen and its ribbed end toward you. Line up the other end, the one with the eight gold pads on its underside, with the slot in the top edge, and push the card straight in. A small rib in the channel runs in the cut along one edge of the card, so it only goes in one way round. The card stops against the printed shoulders, and its ribbed end finishes level with the top edge. There is no latch: the springs under the card and the roof above it hold it by friction.

    To take a card out, press the ribbed end with a thumb in the scoop on the front of the end wall, put a fingertip in the notch in the back under it, pinch, and pull the card straight up.

    Without the record card reader, press the slot blank in the same way instead: two small crush bumps on its sides hold it, and it closes the slot against dust.

    The card goes the whole way with a light push and no force, stops, and sits level with the top edge with nothing standing out of it. Pulled out and pushed in a few times it feels the same each time.

Which screw goes where

only one kind
ScrewWhereInto
M2 x 8 ISO 7380 button head, black (3)deck, at (7, 7), (59, 7) and (59, 71) measured from the port end left corner; the (59, 71) one through the bandan M2 nut in the side slot of each boss
M2 x 5 ISO 7380 button head, black (1)deck, at (7, 71): the top left boss hangs over the cellthe M2 nut in the raised slot of that boss
09

First power-up and using the player

Time 30 minNeeds the closed player, a USB-C cableOutput a player that plays

Power it from USB first, with the deck still easy to lift, and look before you listen.

  1. Before the cell goes in, plug the QT Py into USB with no cell connected. The board should start and the screen should light.
  2. Connect the cell and unplug the cable. The player runs from the cell. Plug the cable in again: the charger module charges the cell from USB. Watch the cell for the first charge and stop at once if it warms.
  3. Check each control. Turn the wheel (volume on Now Playing, scroll elsewhere), push it (select), press each key, and slide the hold switch (it locks everything).
  4. Plug in in-ear monitors with the volume at its start level, and play a track from the library card.
  5. Optional: try a record card. Push a card in as in step 14. The player should see it by itself once its pads touch the springs (section 10), mount it, and start playing its album from the first track. Taking the card out stops it and returns to the library.

Using it

controls
ControlWhat it does
Wheel, turnvolume on Now Playing; scrolls a list elsewhere (fast turns step letter by letter in a sorted list)
Wheel, pushselect
Backup one level; held, back to Now Playing
Prev, Nextpress to skip; hold to scrub
Playpress to play or pause; hold 2 seconds to switch off
Hold slidelocks every control
Settingsvolume limit, brightness (no effect with the backlight on 3V3), screen timeout, auto sleep, sort "The", output (jack or Bluetooth), rebuild library, Bluetooth (the device list), About. There is no USB storage mode on this board

On the first boot with a library card the player builds an index in /.pk01/index.bin (the target is 5,000 tracks in under 3 minutes). Back stops it. To update the firmware, copy a new pk01.bin to the library card root and restart: the player offers it, and Play installs it.

Sound out

jack and Bluetooth

The jack. The 3.5 mm jack is the DAC board's output and always works, whatever else is connected.

Bluetooth. The QT Py ESP32 Pico is a classic ESP32, so the player acts as a Bluetooth (A2DP) source and plays to wireless headphones and speakers. It sends audio only; it does not receive from a phone. To pair, put the headphones in pairing mode, then open Settings, Bluetooth: the list scans while it is on screen, strongest device first. Select yours: the player pairs, connects, remembers it and switches the output to Bluetooth. After that the player reconnects to the last device by itself whenever Bluetooth is the chosen output (it tries again for a few minutes if the headphones are off), and playback pauses while the link is down and resumes when it is back. Settings, Output switches between the jack and the remembered device. The audio is resampled to 44.1 kHz and sent as SBC by the stack, so a 24 bit / 96 kHz file loses its extra resolution on this path; the jack stays the bit-perfect output. Streaming costs battery, and decoding 24 bit / 96 kHz FLAC while sending Bluetooth audio has still to be proved on a built unit.

10

Record cards

Time an hour a cardNeeds a printer, a card reader, sticker paperOutput cards, labelled and filed

A record card is a flat printed card that holds one album. It is 22 wide, 34 long and 2.6 thick, and nothing sticks out of it: a square label and a ribbed grip on the face, a narrow label on the spine, and eight gold pads set level into the underside at the other end. The slot in the player's top edge takes one card; the rack files five. Everything in this section is optional: a player without the reader plays from its library card.

Two kinds of card

same printed card, same pads

microSD in a card: Print a label half and a contact half. A stock microSD sits in the window of the contact half with its own gold pads facing down, level with the card's underside, and is taped to the label half. It shows as a small black card with gold pads.

Card circuit board: Print the same two halves, but put a 0.4 mm board in the window instead of the microSD. The board is the microSD's outline, 11 x 15, with black solder mask and eight gold pads at 1.1 pitch on its underside. An SD NAND chip (6 x 8 x 0.75, LGA-8) is soldered on the other side, up inside the label half's pocket.

The printed card, the pads' places and the outside of the card are the same for both, so the one reader reads either. No bare green board shows anywhere on a card.

A microSD record card pulled apart: the label half with its square label and ribbed grip on top, the microSD below it, and the contact half with its window beneath
A card circuit board record card pulled apart: the label half on top, the black card board below it, and the contact half with its window beneath
FIG. 4 / A card pulled apartthe picture follows your card type
Both sides of a record card standing on its leading edge: the underside with the black board and eight gold pads level with the face, and the label side with its art and ribbed grip strip
FIG. 5 / Both sides of a cardunderside with its gold pads on the left, label side on the right

The label side faces the screen when the card is in. The underside faces the back of the player and carries the pads: they sit 0.05 inside the face, so a card lying on a desk never rests on them, and a card in the rack stands on its flat leading edge. A cut along one edge of the card is the key: a small rib in the slot runs in it, so a card turned over or round stops at the mouth.

How the slot reads a card

springs, stops and a key, no latch

The channel. A printed channel runs the full length of the card, 0.3 wider a side and 0.5 deeper than the card, with a 0.8 lead-in at the mouth. A 1.0 rib on its floor runs in the card's key cut.

The springs. A strip of spring contacts lies flat on the channel floor under the card and presses on its gold pads. Its eight springs stand 0.35 proud of the base, touch the pads 1.7 from either end of each pad, and are pressed down 0.2 by the card, which leaves 0.15 before the base stops them. They push the card up against the channel roof, and friction holds it: there is no latch to wear.

The stops. Two printed shoulders stop the card's leading edge 0.3 before the reader's rear edge, so a card pushed hard loads the resin and not the springs. Its ribbed end then finishes level with the top edge.

Card detect. There is no switch. A seated card pulls its own chip select line (microSD pin 2, held up inside the card) high against a 1 M resistor to ground in the player. The player sees a card only when the pads really touch the springs. The firmware does this: every 150 ms, while no card is mounted, it lets go of the line, reads it, and takes three high readings in a row as an insert; it then mounts the card at /rec, scans it and plays its first album from the first track, showing Now Playing. While a card is mounted the line belongs to the card bus, so the firmware asks the card for its status instead, and two missed answers in a row count as removal: the album stops and the player returns to the library. After a removal, or a card it could not read, the line must be seen low once before another insert is accepted, so a card that is half out does not mount again and again. A card with more than one album plays the first. If the Premium board does not have its own 47 k pull-up on that line (check its datasheet), add one, or it will not be seen. This is written but has not run on a built player.

Plan cut through the slot channel: the card seen from above with the card board and memory chip in its window, the channel walls, the key rib and the stop shoulders
FIG. 6 / Inside the slot, cut flat2.75 mm above the back, seen from the front
Section through the slot along a pad column: the channel floor, the reader's base and springs under the card, the card with its board, the roof above, the stop shoulder and the finger notch
FIG. 7 / The slot cut through a pad columntop edge on the right, front of the player up
Close section of the contacts: a gold spring leaf resting on a card pad, with the reader's base below and the card board above
FIG. 8 / The springs under the padsthe leaves stand 0.35 above the base and sit 0.2 lower under the card
The empty top edge seen from straight above: the slot mouth with its lead-in, the key rib at one end, the eight gold spring tips inside and the thumb scoop below
FIG. 9 / The top edge, emptyseen from straight above, front of the player at the bottom
The top edge with a card all the way in: only the card's ribbed end shows, with its spine label, level with the edge
FIG. 10 / The top edge with a card inonly the ribbed end shows, level with the edge

Putting a card in and taking it out

five movements
The player standing on its bottom edge with the card beside it, label side toward you and the ribbed end at the top
1 / The card, label side upribbed end at the top
The card held above the slot in the top edge, an arrow pointing down
2 / Line up with the slotthe pad end goes in first
The card all the way in, only its ribbed end showing level with the top edge, and the screen showing the album
3 / All the way inthe ribbed end is level with the edge and the album starts
The card pulled up out of the slot, an arrow pointing up
4 / Pull it straight upthumb in the scoop at the front, fingertip in the notch at the back
The top edge seen from behind with a card part way out: the finger notch in the back skin under the card's ribbed end
5 / The back of the top edgethe finger notch sits under the card's ribbed end

Pinch the ribbed end between a thumb in the scoop in the front of the end wall and a fingertip in the notch in the back skin, then pull the card straight up and out. The card never clicks or locks. Without the reader, the slot blank goes in and out the same way.

Printing and assembling a card

label half, contact half
  1. Print the halves. The label half (pk01_card_face.stl, label face up) and the contact half (pk01_card_frame.stl, contact face up) are in section 03. Supports go on the inner faces, which are joined together. Wash, cure and sand the support nubs flat, keeping the sanding off the pocket walls and the card's edges, which must stay 22.0 wide.
  2. Paint the outside before you add the medium, one colour per card. Keep paint out of the window in the contact half and off the label recess, the spine recess and the key cut.
  3. microSD in a card: Fit the microSD. Put a 0.2 foam tape pad on the label half's inner face, set the microSD in the window with its pads facing out and its leading edge, the end with the pads, toward the card's leading end, and press it onto the tape. The tape also takes up the 0.2 between a 1.0 thick microSD and the 1.2 thick contact half.
  4. Card circuit board: Order and fit the board. out/card/pk01_premium_card_pcb.dxf gives the outline, the eight pads and the chip area on separate layers, and pk01_premium_card_pcb.step the 0.4 board with the chip. Order 0.4 mm FR4 with black solder mask and ENIG gold on the pads, and route the chip to the eight pads from its datasheet: the pads follow the microSD pad order. Solder the chip on the side opposite the pads. If the chip has no pull-up on its chip select line, add a 47 k resistor from chip select to 3V3 on the board: the player's card detect depends on the card pulling that line high. Then tape the board to the label half like the microSD, pads out.
  5. Close the card. Put a thin line of cyanoacrylate along the seam of the two halves, away from the window, press them together flat and hold until set.
Check the card

The card is 22.0 wide, 34.0 long and 2.6 thick, give or take 0.1, and nothing stands out of any edge or face. The eight pads are level with the underside to within 0.1: lay a steel rule across the face and you should see no pad above it. The assembled board and chip must be no thicker than 1.15 behind the pad face. Slide the finished card into the slot: it must go in the whole way with a light push and stop with its end level with the edge.

Filling a card on a computer

folders, cover, album.json

Plug the card into a computer and format it FAT32 (exFAT for a card over 32 GB). A record card is filled like the library card, and the player reads this layout:

/Music/Artist/Album/01 Title.flac
/Music/Artist/Album/02 Title.flac
/Music/Artist/Album/cover.jpg      # or folder.jpg: shown on the colour screens only
/config.txt                        # library card only, section 07
  • Folders. One folder per artist and one per album. FLAC and WAV up to 24 bit / 96 kHz play; other files are skipped. Put one album on a card for the neatest result: a card is a record.
  • Cover. Put cover.jpg (or folder.jpg, or the .jpeg forms) in the album folder, square, about 600 x 600, saved as a baseline JPEG (a progressive JPEG or a PNG is not read). Without a file, the player uses the picture embedded in the album's first FLAC track, if it is a JPEG. The player crops it to its centred square, shows it large on Now Playing and small beside each album in the lists, and keeps 160 and 64 pixel copies in /.pk01/art on the library card so the next time is instant; the first time an album is shown its cover appears a moment later, once decoded in the background. An album with no usable cover shows a plain dark tile with a note. A record card is never written to, so its cover is decoded each time. The OLED bar shows no art.
  • album.json. To be defined. The firmware does not read an album.json file yet and no format is fixed. The player takes album, artist and track names from the tags in the music files. Until the format is defined, keep no file of that name on a card, and keep your own notes elsewhere.

Printing and fitting labels

face and spine

Labels are adhesive vinyl on sticker paper, printed at 600 dpi and cut to size. Both lie in recesses 0.2 deep so they sit flush; cut each about 0.1 under the recess size so it lies flat and cannot lift at an edge.

LabelSize (mm)Where it goes
Face20 x 20the square recess on the label half, 1.0 from each side and 11.0 from the ribbed end. Print the art upright for a card held label side up with the ribbed end at the top, as it sits in the player
Spine18 x 2.2the recess across the ribbed end, over both halves, 2.0 from each side. It reads along the spine, and shows when the card stands in the rack
Undersidenonethe underside carries the window and the pads, so it has no label

Paint and seal the card first, then peel each label and lay it on from one edge so no air is trapped. Press it flat with a soft cloth.

The rack

five cards, spines out

The card rack (pk01_card_rack.stl, printed once) holds five cards standing on their flat leading edge, spine up, so the spine labels read like records on a shelf. The pads are on the underside and never touch the rack's ribs or base. Each slot is 3.0 wide and has a drain slot under it. The rack is 22.2 x 25.8 x 22.

The card rack with four record cards standing in its slots, spines up with their labels showing
FIG. 11 / The card rackcards of both kinds
11

Docking in the SP-01 dock speaker

Needs an SP-01 dock editionOutput a player that charges and plays through the dock

The SP-01 dock edition holds a PK-01 upright in a slot in its face. This section covers what the dock is specified to do with it.

  • How it sits. The player stands upright, ports down, with its screen toward the listener, dropped in from the top. It stands about 36 mm proud of the speaker's top, so the wheel, the keys, the screen and the hold slide stay usable while it is docked.
  • The slot stays clear. The record card slot is in the top edge, which faces up when the player is docked and stays clear, so you can swap cards while it plays.
  • The fit. The dock's bay is built for this 66 wide body.
  • Power. The dock's plug charges the player through its USB-C port, and tells it that it is docked: the player senses the supply on its battery and USB sense pin (section 06). There are no extra contacts on the port end.
  • Music. Once docked, the player connects to the dock over Bluetooth by itself at close range and plays through the speaker automatically, with no pairing to do. When the supply on the sense pin rises above 2.35 V (three readings in a row), the player lets go of any headphones (one Bluetooth link at a time), then reconnects to the dock it has bonded with or, the first time, looks for a device named exactly SP-01 dock and connects to the strongest one above -55 dBm, which is a dock within about a metre (a docked player is at about -28 dBm). The dock accepts a new bond only from a device named PK-01 above -45 dBm, so only a docked player can bond; later docks reconnect from the stored bond, within a few seconds. The audio switches to the dock once the link is up, and the music carries on from where it was. On a wall charger there is no dock to find: the player tries for about half a minute and then stays quiet until USB is unplugged and plugged in again. The dock never appears in the Settings list. This is written but has not run against a real dock: the range and timing are the first things to check.
  • Lifting it out. The slot is top loading: the player lifts straight out. When the supply drops the player lets go of the dock and goes back to the output it had before, the jack or the remembered Bluetooth headphones (which reconnect), without you choosing anything. A docked player does not switch itself off while paused.
A

Troubleshooting

SymptomCheck
The board will not start or will not flashthe DAC data wire on the MI pad must read low at reset (no pull-up on the DAC input); the screen's DC wire on the BOOT pad must not be held low; hold BOOT, tap reset, then release BOOT to enter download mode
Nothing on the screen3V3 and GND at the module; the backlight pin is on 3V3; CS on A3, DC on the BOOT pad, DIN on MO, CLK on SCK; the pin header matches section 06
No soundDAC power and ground; BCK on SDA, LCK on RX, DIN on MI; the SCK pad grounded; tip and ring wired to the jack
Library card not foundcard is formatted FAT32; CS on A2, CMD on MO, CLK on SCK, DAT0 on A0; the card is latched in its socket
Record card not seenthe card is pushed all the way in and level with the top edge; the springs are not bent and sit on the pads; CS (pin 2) goes to A1 with the 1 M resistor to GND; the eight wires go to the right tails; on a Premium card, the chip select pull-up is fitted
The card will not go init is turned over or round (the rib stops it at the mouth); a print burr in the channel; paint on the card's edges; a spring bent upward by a card pushed in sideways
The card falls out or rattlessprings too weak or a channel printed too wide; a 0.1 crush bump on a channel wall is the fix, never a latch
A key does nothing or two keys act togetherthe ladder resistor values; the node on the TX pad with its 22 k to 3V3; one side of every switch on GND
The deck will not sit flata wire under its edge, a cap stuck on its flange, or the screen module not rocking freely before the band is on
A cap stickspaint in the hole or on the stem; thin the paint, not the cap
The wheel does not turn the encoderthe sleeve not fully on the dial; the dial rubbing the slot in the right wall; the A and B wires on the STEMMA lead (yellow and blue)
Cell will not chargecharger module IN+ on the 5V pad, OUT+ and OUT- to the cell and the BAT pads with the right polarity; the cell's protection board
Bluetooth range is shorta wire or the DAC's ground plane near the antenna end of the QT Py; move wires away from that end
B

Licence and credits

WhatLicence
FirmwareMIT
CAD, print files, this manual and its images© 2026 Rod Leviton, RPXL / Reactive Pixels. Licensed for building for your own personal use; not for redistribution or resale
Fonts embedded in this page: Inter, IBM Plex Mono. Font in the CAD: IBM Plex MonoSIL Open Font License 1.1
Firmware libraries: dr_flac, ESP-IDF, esp_tinyusbtheir own licences

© 2026 Rod Leviton, RPXL / Reactive Pixels. The PK-01 page and the rest of the range: B-Side. More from the studio at reactivepixels.com.