5.8 KiB

Raw Blame History

Thingamajig v1.1-dev

Thingamajig v1.1 is a RISC/MISC homebrew computer architecture. Its git repository can be found at https://ahti.space/git/crazyettin/Thingamajig.

Included Software

The repository includes an emulator implementation of Thingamajig with a control program for the emulated paper tape reader and punch, and an assembler and a disassembler, all written in FreePascal. It also includes couple of simple example programs for Thingamajig written in assembly.

Registers and Memory

24-bit instruction register IR
16-bit instruction and return pointers IP and RP
8-bit general-purpose registers R0-R3
8-bit memory locations 0-FFFF

Multi-byte values are big-endian. Memory locations 0-FFEF are used for RAM while FFF0-FFFF are reserved for memory mapped devices.

Input and output are mapped to address FFFF, while arbitrary devices can be mapped to the other reserved addresses. When interacting with memory mapped devices Thingamajig will stop processing to wait for the device to be ready if needed.

Instructions

Instructions without an immediate or address argument are 8-bit, those with an immediate one 16-bit, and those with an address one 24-bit. The instruction pointer is incremented before being accessed or modified.

0 HALT 1 RET IP = *RP; RP += 2

2 SHL RX, N RX <<= N (logical) Shifts of 1-4 steps, 3 SHR RX, N RX >>= N (logical) with 4 encoded as 0 4 ROL RX, N RX <<= N (rotating) in machine code. 5 ROR RX, N RX >>= N (rotating)

6 NAND RX, RY RX = ~(RX & RY) 7 AND RX, RY RX &= RY 8 OR RX, RY RX |= RY 9 XOR RX, RY RX ^= RY

A LOAD RX, ~0, IMM RX = IMM Written as "LOAD RX, #IMM" 0, ADDR RX = *ADDR Written as "LOAD RX, ADDR" B STORE RY, ADDR *ADDR = RY Written as "STORE ADDR, RY"

C BREQ RX, RY, ADDR if (RX == RY) IP = ADDR D BRNEQ RX, RY, ADDR if (RX != RY) IP = ADDR E CLEQ RX, RY, ADDR if (RX == RY) {RP -= 2; *RP = IP; IP = ADDR} F CLNEQ RX, RY, ADDR if (RX != RY) {RP -= 2; *RP = IP; IP = ADDR}

Assembly Language

Lines of assembly are of the following form:

LABEL: OPER ARG1, ARG2, ARG3 ;Comment

The language is case-insensitive and uses hexadecimal numbers. A label can consist of any alphanumeric characters as long as it is not interpretable as a hexadecimal number. The label, instruction, and comment elements are all optional, as is spacing between the arguments. For the arguments of each instruction see the previous section.

Address arguments can be either absolute addresses or references to or relative to a label. Relative references are of the form LABEL +/- N; the spacing is optional.

In addition to the true instructions there are three pseudo-instructions. ORG sets the location of the following code and data; as it has no direct equivalent in machine code it cannot have a label. The default starting address of 0 does not need to be indicated with ORG. DATA introduces a byte of data. ADDR introduces two bytes of data containing the address of a reference to or relative to a label.

Boot

At boot the initial program loader (IPL) loads a program to RAM starting at address 0 after which is cedes control to the CPU. If an implementation has a front panel the IPL is optional. The instruction and return pointers are initialised as 0 and the first address after RAM respectively, while other registers and RAM are uninitialised.

Emulator and Tapectl

Usage:

emulator (-v) program (2> verbose_output)
tapectl (-r tape) (-p tape)

By default the emulator runs at roughly 500 KIPS and has 2 KiB of RAM. The arguments -dRAM4, -dRAM8, -dRAM16, -dRAM32, and -dRAM64 can be used to compile the emulator with 4, 8, 16, 32, or 64 KiB (minus the reserved addresses) of RAM respectively instead and the speed limitations can be removed with the argument -dfast. When run with the argument -v the current state of the registers is output to stderr before each instruction.

Input and output are handled by an emulated roughly 1000 CPS ASCII-compatible glass teletype terminal with local echo on by default. Of the control characters bell (^G), backspace (^H), line feed (^J), carriage return (^M), and device control characters two (^R) and four (^T) are used by the terminal: the device control characters are used to turn the local echo on and off respectively while the rest have their standard uses. The backspace and delete keys input their respective characters and non-character keys null.

In Linux the emulator can be compiled with support for a character printer and an emulated high speed (roughly 500 CPS in and 50 CPS out) 8-bit paper tape reader and punch with the arguments -dprinter and -dtape respectively. The printer is mapped to address FFFE and the tape reader and punch to FFFD. The printer prints into /dev/usb/lp0 and the tape files read from and punched to are (re)set using the program tapectl with the arguments -r and -p respectively.

The IPL loads the program specified as an argument when running the emulator.

Assembler and Disassembler