6502tinymachines

The notebook by kind

The notebook is grouped by the part of the console each document is about. This is the other question: what is this document, and should I open it first. Every one of them appears here exactly once.

58 documents, each carrying the kind its own entry declares

Inside each kind the documents keep the reading order of the console's notebook, so each list runs the way the work did.

The letters

A code beside a title is the milestone the repository files that document under. The letter says which part it is about, and the number where it falls in that part's run.

N
the console itself 11
A
the 2A03, its CPU and sound chip 2
P
the 2C02, its picture chip 5
M
the signal to the television 6

Plans 8

Written before the work, saying what would be checked and how closely.

  • The plan for the whole consoleSketch v0.2What a working console means, how the parts fit together, the milestones from N0 to N8, and the decisions made along the way.
  • Planning the fast 2A03N3 planThe 6502's fast core with its decimal adjust switched off, and the sound unit as tables measured out of the chip.
  • Planning the fast 2C02P3 planA picture chip that steps one dot at a time, driven by a schedule measured out of the transistor-level chip.
  • Planning the console's pictureN6 planThe picture through the signal path, and how a captured frame will be compared, with the tolerances written down first.
  • Planning the console's soundN7 planThe sound through the board's audio stage, read off the schematic.
  • Planning the console's windowN8 planThe window the console plays in, the picture on the GPU, the pacing, and a second target in the browser.
  • Planning the benchA real console and the model under the same controller presses: a bridge on the controller port, relays and a scope under one script, and the checks for each step.
  • Planning the calibration cartridgeOne cartridge whose every screen is built to be measured off the real console and the model through the same reader, each frame naming itself; colour, resolution, filtering and the pad.

Reports 26

Written after it, where every figure is a measurement with the run that printed it.

  • The contract the chips shareN0 reportThe pin tables, the dot frame and the cartridge edge as one small crate with no dependencies, checked against the recorded reference runs.
  • The 2A03 at its switches, matching its reference exactlyA0 reportThe NES's CPU and sound chip simulated transistor by transistor, bit for bit against its reference with no list of exceptions.
  • First sound from the 2A03A3 reportA program's note read off the chip's own output, and the mixer written down as a claim we have not yet measured.
  • The fast 2A03, built and checkedN3 reportThe fast chip checked at its pins against the transistor-level one, the sound tables measured out of the chip, and the bus stalls frame for frame.
  • The 2C02 at its switchesP0 reportThe picture chip simulated transistor by transistor, its reference run replayed, and the transistors that only work when the supply is on found.
  • The 2C02's first pictureP1 reportThe picture chip driven through its simulated bus, its colour output matching the table, and the latches that power up unset named.
  • The 2C02's hard cornersP2 reportSprite 0, the vblank read race and OAM corruption, each settled by a small register program that the reference runs too, without knowing the answer.
  • The fast 2C02, dot for dot with the chipP3 reportThe fast picture chip agreeing with the transistor-level one on three test scenes, the register writes, and the picture with rendering switched off.
  • The timing grid everything stands onM0 reportThe sample grid, the leftover phase at every step, and the data every later stage depends on.
  • The NES encoder and the first decoderM1 reportThe encoders checked against their reference, and the first decoding filter checked against blargg's.
  • The comb filters, the RGB encoder and the speedM2 reportThe decoder's notch and comb filters checked against their reference and against each other, and how fast they run.
  • Making the signal bench fastHow the signal path got several times faster, fast enough to run live in the browser: three changes named before they were built, a filter shortcut the comb tests caught being wrong, and the speeds before and after.
  • The television's picture stagesM3 reportThe stages between a decoded signal and a picture on a tube, with every setting we chose labelled as a choice.
  • Capturing a real consoleM4 reportThe capture source, the round trip through our own model, and the first recordings of a real console scored against our own synthesis.
  • Checking what the documents claimM5 reportA scanner that finds every number the documents state and re-checks it, the known departures from the references, and the specification agreed.
  • Where the signal path departs from the referencesEach place the signal path knowingly differs from the published references, with the reason.
  • The mainboard's glueN4 reportThe handful of parts on the NES-001 board between the chips, each checked against its datasheet and labelled as written by us.
  • Both chips on one clockN5 reportThe console running: the two fast chips on one clock, the timing between them checked against the transistor-level chips, and blargg's test ROMs run end to end.
  • The console's pictureN6 reportThe picture through the signal path, the screen with rendering off measured on the chip, and a captured frame scored, figures recorded and not fitted.
  • The console's soundN7 reportThe sound through the board's audio stage, blargg's mixer test ROMs cancelling, and his recordings of real hardware beside ours.
  • The console in a windowN8 reportThe window built and checked without a screen, the GPU picture matching the CPU's, and the browser build measured.
  • What the bench's tools have shownEach tool working on a synthetic run, each with a sabotage run that must fail; the chip answered the first question before the real console could, and the model changed for it.
  • Eyes versus scopeThe console's video split to the scope and to a USB grabber, getting the grabber to work, and the grabber's picture scored against our own decode of the scope's recording.
  • A real cartridge in the modelWhy the reader guessed the wrong game, the verified dump, and the mapper-66 board the model grew so the same bytes could run on both sides for a picture comparison.
  • Every cartridge on the desk has a boardThe seven cartridge boards the model grew, the two that could only be tested with a console around them, the screen split that needed an interrupt to become a line, and the twentieth dump, which is the multicart's first bank read alone.
  • Super Mario Bros., dissectedThe first game taken apart on the model: the loop inside the interrupt, the frame scanline by scanline, the routine tree through the jump engine, the VRAM pipeline, and the pad's byte on its way to a jump; shape only, never the code

Procedures 6

Things to follow with the machine in front of you: wiring, sittings, scripts, sheets.

  • Wiring the bridgeThe shift register that stands in for the pad, the level shifter, the microcontroller's pins, the relays, and the meter checks to do before power.
  • The bridge's schematics and partsThe bridge as schematics (v1 and v1b), the extended bridge (v2), one controller poll as timing lanes, and an original pad as a phone's pad; parts lists and the build order.
  • The v1b bridge on an Arduino UNOThe version built first, everything at five volts: why the level shifters go away, the pin table, and four things writing the firmware showed the plan had wrong.
  • The build guide, in five sittingsWhat to wire pin by pin, what the command then measures, which photographs to take, and where each sitting stands. Generated from the tool that runs the build.
  • An original pad as a USB or Bluetooth keyboardThe standalone adapter, drawn to build from and built: the part read off its own silkscreen, the headers measured, the drawings, why the build moved twice (to a P4 module when the C6 would not take a flash, then from Bluetooth to USB when the module's radio link crashed), and an original pad's every button reaching a Linux host over USB.
  • Building the calibration cartFrom the idea of a frame that names itself, through a cartridge written with a sixty-line assembler, to the ROM in the model, its checksums, and the cartridge in a console.

References 12

Things to look something up in: parts, patterns, words, specifications.

  • The signal path's specificationSpecification v0.3The agreed plan for the NTSC signal: the sources, the decoder's filters, the television's picture stages and the capture.
  • The desk as builtVersion 1, read off the code on 2026-09-28: how seven repositories become one console in the browser, what each window on the create desk consumes, produces and saves, the seam between the page and the machine, and where a moment, a recording and a cartridge go.
  • The bench scriptOne file both the bench and the model read: the pad's bytes by poll, the arm, the trigger and the capture.
  • The bench's parts listOne table per schematic sheet, and one list of everything to gather. Generated from the file that draws the schematics, so the two cannot disagree.
  • The bench cheat sheetBoth breakouts pin by pin with the harness colours, the four jumpers, and every pin of every chip with what it does and where it goes. Generated from the schematic and the lab log.
  • The head's hands cheat sheetSheet 3 of the v1b package as tables: the Pi's four jumpers by header position, the power and reset breakout, every wire, and each pin of the PC817 and relay modules with what it does and where it goes. Generated from the schematic.
  • The QA rigThe cameras and the boards on the frame, in inches and pixels: each camera's job, mount and scale, the backing board and breadboard dimensions, the bench photographed, and what to run when something moves.
  • From a button to a keystroke, layer by layerWhat travels between an original pad and a phone when the pad is a USB keyboard: the pad's shift register, the byte as a key report, the descriptor that tells the host how to read it, USB itself, then the browser's keydown; why it is not a boot keyboard, and a seven-step plan that checks one layer at a time, all seven passed, the last on a phone.
  • Which ESP32 does which jobWhich Espressif chips can be a Bluetooth keyboard, which a USB one and which both, read from the vendor's own headers for eight of them rather than remembered; the comparison that moved the pad onto a P4 module.
  • The encyclopedia of code patternsWhat the x-rays add up to: each NES code pattern with its signature as measured on the model, a window on the die's pages, and the mechanism it teaches; code only from cartridges whose source is ours
  • The calibration screensThe cartridge's screens as our own decoder sees them, the strip that names each frame, and what each screen is for; the grabber's frames join them once the cart is in a console.
  • The blank boards and the programmerPhotographed and read: which board takes the calibration ROM's two chips, what the EPROM adapter is for, and what is still not known.

Records 6

What happened, kept as it happened, including the attempts that failed.

  • The v1b board as builtRead off its photographs: where the chips sit and which way they face, the rails, the UNO ribbon, and where the headers should move to keep the jumpers short.
  • The rig locked and the bridge reading rightThree days on the bench: the v1b bridge passes bytes into the console and reads every one back, the trigger stops the scope, the cameras are on a frame; what the plan had wrong, what the eye cannot see, and what is next.
  • The lab notebookThe bench wired one step at a time, every attempt kept including the failures, each step ending in a measurement. Generated from the build tool's log.
  • What is still openEverything noticed along the way that is not finished: the calibration cart's part side, where the model's hue differs from the console's, the grabber, the bench and the cartridge reader, each with why it matters and what would close it.
  • Exercising the benchThe two stacks as one logical diagram with every flow typed, the dialect layer by layer, a regime of six steps each with its gate, and the three programmes on top: the model's knobs measured on the part, games learned from the pad to the picture, and the x-ray behind an encyclopedia of code patterns.
  • The build, as it goesThe cartridge being made, one measured step at a time: the programmer on the bench, each chip written and read back whole, the board's jumpers read off both sides, the parts it takes, and what is still open.

The same documents by the part they are about: The console arc's notebook.