Ever wondered how emulators work?
I have been programming a CHIP8 interpreter, because while I have used a lot of other people's interpreter and emulation code, I have never really built one myself.
CHIP8 is generally considered a great introduction to writing emulators, it's the "Hello World" of this kind of thing.
We could expand to be a true emulator if you wanted that additional challenge - CHIP8 was originally used on the COSMAC VIP and Telmac 1800, which were 8-bit computers from the mid-1970s.
Really, though, the idea of CHIP8 was mostly to make creating and porting games easier for these systems.
If you want to follow my progress, you can find the public repo for my CHIP8 emulator solution written in C over at Github.
I am coding my interpreter using the following useful reference docs:
For CHIP8 programs I am using https://johnearnest.github.io/Octo/ , though I might make my own assembler which would be another interesting challenge.
Loading a program involves reading each byte into the emulated computer's 4kb of RAM in the correct place.
Each CHIP-8 instruction is exactly 2 bytes long, and programs should be loaded into memory starting at address 0x200, so after loading that is where we need to set our Program Counter (PC) to start.
The main loop keeps reading the next instruction from "RAM", combining two bytes into a sixteen-bit value.
CHIP-8 has 35 opcodes, which are all two bytes long and stored big-endian.
Our instructions being "Big-Endian" means the first byte takes up the left 8 bits, then the second byte is put into the right-hand bits. We do this by shifting the first byte left:
combined_instruction = (current_byte << 8 | next_byte);
We have a big switch statement to parse instructions. Some start with the same number, so we have to further filter using individual nibbles.
In fact a lot of my debugging has come down to which parts of the instruction we are using at any given time, so I made these variables:
opcode = instruction & 0xF000;
rNibble = instruction & 0x000F;
reg = (instruction & 0x0F00) >> 8;
reg2 = (instruction & 0x00F0) >> 4;
data = instruction & 0x0FFF;
low_byte = instruction & 0x00FF;
For any instruction we do not yet handle, I output the details:
PC:2 Unhandled Instruction: Op:9000 Reg:0 rNibble:90 Data:90
Results so far:
I'm quite happy that a lot of CHIP8 test suite programs actually run on my little interpreter, but I would like to get it to the point where 64×32 games with the original set of opcodes run (no extensions).
Not sure if I will bother with sound, though!
