Glossary

The wiki’s technical terms, explained in one or two sentences, and in the sense in which Eliott65 uses them.

The hardware

6502, W65C02S

The 8-bit processor of the Apple II, Commodore 64, Oric or BBC Micro. The W65C02S is its modern CMOS version, still made by WDC; it is the one fitted in the Neo6502kbd.

RP2040

The microcontroller of the Raspberry Pi Pico: two ARM Cortex-M0+ cores, 264 KiB of memory, and PIO blocks. On the board, it plays the memory and peripherals of the 6502; Eliott65 runs inside it.

Core 0, core 1

The two ARM processors of the RP2040. Under Eliott65, core 0 runs the kernel (and draws the graphics), core 1 produces the video signal.

PIO

Small specialised processors in the RP2040, which run programs of a few instructions at the pace of the clock and drive the pins to the exact cycle. Eliott65 uses them for the bus and the video.

DMA

Direct Memory Access: a controller that copies data from one place to another without tying up the cores. It serves every byte of the 6502 bus and feeds the video.

Bus, bus cycle

The wires through which the processor exchanges addresses and data with the memory. A cycle is one exchange: an address, a byte read or written.

PHI2

The 6502’s clock. During its low phase, the address settles; during its high phase, the data is exchanged. On the board, it is the RP2040 that generates it.

74LVC245

A “buffer” chip that lets eight signals through, in a chosen direction. The board has three of them, which share the same eight pins of the RP2040.

Flash, XIP

Flash is the memory that keeps the firmware when the power is off (2 MB on the board). The RP2040 can run code directly from it (eXecute In Place, XIP), but more slowly than from its RAM.

PWM

Pulse-width modulation: a square wave whose frequency and share of time at 1 can be set. Eliott65 uses it to make the board’s speaker sound.

Static (core)

A static processor tolerates its clock being stopped indefinitely without losing anything. The W65C02S is one: Eliott65 can freeze it at any moment.

The system

Firmware

The software that runs in the RP2040. Eliott65 is a firmware, which also contains the kernel.

Kernel, out-of-band kernel

The kernel is the heart of the system: it manages programs, memory, files. It is out-of-band when it runs alongside the processor it serves (here in the RP2040), and not inside it.

Call gate

The two bytes $FFF8–$FFF9 through which a program asks for a service. Writing the high byte triggers the call. See System calls.

Parameter block

The small area, in the program’s memory, where it stores the service number and its parameters, and where the kernel writes the results.

Vectors

The last six bytes of the 6502’s memory ($FFFA–$FFFF): the addresses it goes to on NMI, RESET and IRQ.

Zero page

The first 256 bytes of the 6502’s memory ($0000–$00FF), faster to access. Parameter blocks must not be placed there.

RESET, IRQ, NMI

Three pins of the 6502: the reset, the ordinary (maskable) interrupt and the non-maskable interrupt, which cannot be ignored. Eliott65 uses the NMI for pre-emption.

.E65

The format of Eliott65 programs: a header and the code, loaded directly into the 6502’s memory.

Evanescent boot

Launching a program without a resident loader: the RP2040 places it in memory, then releases RESET.

libe65

The small assembler library supplied to programs: calling through the gate, hibernation, switching, sleep. Its include file, e65.inc, is generated from the API description.

Multitasking

Process

A running program. Eliott65 accepts up to 8 of them.

Foreground

The process that has the screen and the keyboard. You change it with Ctrl+Tab.

Switching

Moving from one process to another.

Cooperative, pre-emptive

In cooperative multitasking, each program hands back control itself. In pre-emptive multitasking, the kernel takes it back, even if the program does not want to give it up.

Page, frame

The 6502’s memory is divided into 16 pages of 4 KiB. The pages of waiting processes are stored in frames in the RP2040’s reserve.

MMU

Memory Management Unit: a device that translates addresses on every access. Tried in the Eliott65 bus, it cost 34% of speed and was set aside.

Hibernation, .HIB

Saving the whole machine to a .HIB file, from which it can resume exactly. See Hibernation.

Files and USB

FAT, cluster

The file system of USB sticks and floppy disks. The disk is divided into clusters; the FAT table says which cluster follows which in a file. FAT12, FAT16 and FAT32 differ in the size of its entries.

8.3 name, long name

An 8.3 name has 8 characters, a dot, 3 characters (BONJOUR.E65). Long names are stored separately, in special entries.

Host, hub, enumeration

The USB host directs the exchanges (here the RP2040). The hub multiplies the ports. Enumeration is the discovery of a newly plugged-in device.

Low Speed, Full Speed, PRE

Two USB speeds (1.5 and 12 Mbit/s). A slow device behind a fast hub requires a PRE packet before each exchange.

HID

Human Interface Device: the USB family of keyboards and mice. A keyboard sends HID reports: the keys pressed.

Bulk-Only, SCSI

The USB stick protocol: SCSI commands (read, write, capacity…) carried over Bulk-Only.

Video and graphics

DVI, HDMI, TMDS

DVI is the digital video signal that any HDMI socket accepts. Each pixel of each colour is encoded in it as a 10-bit TMDS symbol.

Line buffer

An area of memory that holds a single line of the picture, ready to go out. Eliott65 has only two, instead of a complete frame.

Tile, map, layer

A tile is a small pattern (8 × 8 or 16 × 16 pixels). A map says which tile to put where. A layer is one level of background, made of tiles or a bitmap; Eliott65 has two.

Sprite

A small drawing that moves freely over the background; in French, lutin.

bpp

Bits per pixel: 1 bpp gives 2 colours, 4 bpp 16 colours, 8 bpp 256 colours.

Palette, palette bank

The palette maps a colour number to an actual colour. A bank is a piece of the palette; changing it on every line puts more colours on the screen.

The workshop

SWD, probe

SWD is the debug port of ARM processors. A probe connected to it reads and writes the memory of the running RP2040.

OpenOCD

The free software that drives the probe from the PC.

Emulator, test bench

An emulator runs the machine on the PC. A test bench simulates one specific part of the hardware (the bus, the video, USB) in order to test the real driver.

ADR

Architecture Decision Record: a note that records a decision, its context and its consequences. See The decisions.

KiB, MB

A KiB (kibibyte) is 1,024 bytes; the 6502’s 64 KiB make 65,536 bytes.