Added on 8 Jan 2017, Last updated on 29 Jan 2017.
29 Jan 2017
Added Super Chip-8 info
8 Jan 2017
Initial upload
Documentation on the Super Chip 8.
By elzo_d
The Chip 8 has the following registers and specs:
16 8-bit general registers (V0-Vf). Vf is also used as a carry-flag with certain arithmetic opcodes.
A 16-bit register (I), used as a memory-pointer.
A 16-bit stack with 16 levels and a stack pointer (sp) pointing to the last used value. What the amount of levels originally was is unknown but is said to be 12.
A 8-bit sound-timer (ST) and a 8-bit dealy-timer (DT) counting down at 60 Hz if it is above 0. A beep will play when the sound-timer is more than 0.
A 16-bit Program counter (PC) pointing to the opcode to execute. Each opcode is 16-bit. It starts at 0x200 and after executing a opcode, it is increased by 2.
4096 (0x1000) bytes of ram. The first 512 (0x200) bytes of it was reserved for the Chip-8 interprenter. This means that programs are loaded from address 0x200 onward.
All registers/values exept the PC are initialized to 0.
Pushing on the stack changes the stack value at sp and then increases sp by 1. Pulling from it decreases sp by 1 and return the value on the stack at sp.
The Super Chip 8 adds the ability to use 8 HP-48 8-bit flags (R0-R7) and a flag for low-res/high-res mode.
Note that I, the PC and the stack addresses are 16-bit even though all ram is addressable with just 12 bits.
Certain emulators (inculding mine) emulate I and the PC as being 12-bits wide for this reason.
On resetting certain games expect the V registers and the ram to be unchanged to do special things. I added a setting to my emulator for such cases.
The chip 8 has a 16-button keypad numbered 1-9 and a-f:
1 2 3 C 4 5 6 D 7 8 9 E A 0 B F
The Original Chip 8 has a 64*32 (width*height) monochrome screen.
The Super Chip 8 has a 128*64 monochrome screen and a low-res (default) and high-res mode.
In low-res mode, it acts just as the original chip 8 screen (64*32) meaning that each "pixel" is actually 2*2 pixels in size.
In High-res mode, it allows the full resolution to be used. This is to keep compatibility with original chip 8 games which won't set high-res mode.
The Chip 8 has a built-in 4*5 font for the characters 0-9 and A-F and a opcode for pointing I to it.
The Super Chip 8 also has a built-in 8*10 "high-res" font for the characters 0-9 and another opcode for pointing I to that.
Most emulators (including mine) store the font in the 0x0-0x200 area of ram, because it was reserved space.
Here are the bytes my emulator use for the fonts. Note that it has an upscaled version of the low-res font for the high-res font.
0xF0, 0x90, 0x90, 0x90, 0xF0, // 0 0x20, 0x60, 0x20, 0x20, 0x70, // 1 0xF0, 0x10, 0xF0, 0x80, 0xF0, // 2 0xF0, 0x10, 0xF0, 0x10, 0xF0, // 3 0x90, 0x90, 0xF0, 0x10, 0x10, // 4 0xF0, 0x80, 0xF0, 0x10, 0xF0, // 5 0xF0, 0x80, 0xF0, 0x90, 0xF0, // 6 0xF0, 0x10, 0x20, 0x40, 0x40, // 7 0xF0, 0x90, 0xF0, 0x90, 0xF0, // 8 0xF0, 0x90, 0xF0, 0x10, 0xF0, // 9 0xF0, 0x90, 0xF0, 0x90, 0x90, // A 0xE0, 0x90, 0xE0, 0x90, 0xE0, // B 0xF0, 0x80, 0x80, 0x80, 0xF0, // C 0xE0, 0x90, 0x90, 0x90, 0xE0, // D 0xF0, 0x80, 0xF0, 0x80, 0xF0, // E 0xF0, 0x80, 0xF0, 0x80, 0x80, // F //highres font 0xff, 0xff, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0xff, // 0 0x0c, 0x0c, 0x3c, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3f, 0x3f, // 1 0xff, 0xff, 0x03, 0x03, 0xff, 0xff, 0xc0, 0xc0, 0xff, 0xff, // 2 0xff, 0xff, 0x03, 0x03, 0xff, 0xff, 0x03, 0x03, 0xff, 0xff, // 3 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0x03, 0x03, 0x03, 0x03, // 4 0xff, 0xff, 0xc0, 0xc0, 0xff, 0xff, 0x03, 0x03, 0xff, 0xff, // 5 0xff, 0xff, 0xc0, 0xc0, 0xff, 0xff, 0xc3, 0xc3, 0xff, 0xff, // 6 0xff, 0xff, 0x03, 0x03, 0x0c, 0x0c, 0x30, 0x30, 0x30, 0x30, // 7 0xff, 0xff, 0xc3, 0xc3, 0xff, 0xff, 0xc3, 0xc3, 0xff, 0xff, // 8 0xff, 0xff, 0xc3, 0xc3, 0xff, 0xff, 0x03, 0x03, 0xff, 0xff, // 9
Following is a list of opcodes. in these opcodes certain letters indicate variables:
p: A nibble (4 bits), used directly.
x and y: A V-register.
kk: A byte, used directly
nnn: A 12-bit address, used directly
00Cp - SCD #p - scroll screen down p pixels (Super chip 8).
Moves the content on the screel down p pixels. p pixel-rows at the top are erased. Note that in low-res mode, because each "pixel" is actually 2 pixels high, it scrolls p/2 "pixels".
00E0 - CLS - clear the screen.
Sets all the pixels on the screen to off.
00EE - RET - return from subroutine.
Returns from a subroutine. It sets the PC to the last value pushed on the stack.
00FB - SCR - scroll screen right 4 pixels (Super chip 8).
Moves the content on the screel right 4 pixels. 4 pixel-columns at the left are erased. Note that in low-res mode, because each "pixel" is actually 2 pixels in width, it scrolls 2 "pixels".
00FC - SCL - scroll screen left 4 pixels (Super chip 8).
Moves the content on the screel left 4 pixels. 4 pixel-columns at the right are erased. Note that in low-res mode, because each "pixel" is actually 2 pixels in width, it scrolls 2 "pixels".
00FD - EXIT - exit the inteprenter (Super chip 8).
Exits the inteprenter. In emulators this usually ends emulation with a message.
00FE - LOW - set low-res mode (Super chip 8).
Sets the screen to low-res mode. The screen acts as a 64*32 screen.
If the screen is supposed to be cleared when switching is not clearly defined. My emulator has a setting for this because of it.
00FF - HIGH - set high-res mode (Super chip 8).
Sets the screen to high-res mode. The screen acts as a 128*64 screen.
If the screen is supposed to be cleared when switching is not clearly defined. My emulator has a setting for this because of it.
1nnn - JP #nnn - jump to address nnn.
Jumps to address nnn. It sets the PC to nnn.
2nnn - CALL #nnn - call subroutine at address nnn.
Jumps to subroutine at address nnn. It pushes the address of the next instruction on the stack and sets the PC to nnn.
3xkk - SE Vx, #kk - skip next instruction if Vx = kk.
Skips the next opcode if Vx equals kk by increasing the PC by 2.
4xkk - SNE Vx, #kk - skip next instruction if Vx != kk.
Skips the next opcode if Vx does not equal kk by increasing the PC by 2.
5xy0 - SE Vx, Vy - skip next instruction if Vx = Vy.
Skips the next opcode if Vx equals Vy by increasing the PC by 2.
6xkk - LD Vx, #kk - load Vx with kk.
Sets Vx to value kk.
7xkk - ADD Vx, #kk - add kk to Vx.
Adds kk to Vx. Note that overflowing does not affect Vf.
8xy0 - LD Vx, Vy - load Vx with Vy.
Sets Vx to Vy.
8xy1 - OR Vx, Vy - OR Vx with Vy.
Does a bitwise OR (|) on Vx with Vy. (for each bit, if either or both are 1, the result is 1, else 0)
8xy2 - AND Vx, Vy - AND Vx with Vy.
Does a bitwise AND (&) on Vx with Vy. (for each bit, if both are 1, the result is 1, else 0)
8xy3 - XOR Vx, Vy - XOR Vx with Vy.
Does a bitwise XOR (^) on Vx with Vy. (for each bit, if they are different, the result is 1, else 0)
8xy4 - ADD Vx, Vy - add Vy to Vx.
Adds Vy to Vx. When there is overflow (result is more than 8 bits), Vf gets set to 1, otherwise, Vf gets set to 0.
8xy5 - SUB Vx, Vy - subtract Vy from Vx.
Subtracts Vy from Vx. When a carry is needed (result is negative), Vf gets set to 0, otherwise, Vf gets set to 1.
A negative number is represented as it's 2's complement, meaning (for 8-bit numbers) 0 - 1 = 255, 0 - 2 = 254, etc.
8xy6 - SHR Vx, {vy} - shift Vx right once.
Shifts the value of Vx right once (>> 1). Vf gets set to the bit shifted "off" the number (value ANDed with 1). (shifting right equals dividing by 2)
Note that Vf gets set after the shift so shifting Vf itself will mean that Vf contains the shifted-off bit, not the result.
In the original interprenter the value of Vy got shifted and stored in Vx instead.
Certain games require this behaviour, but other games break beacuse of it. My emulator has a setting for this because of it.
8xy7 - SUBN Vx, Vy - subtract Vx from Vy and store in Vx.
Subtracts Vx from Vy and stores the result in Vx. When a carry is needed (result is negative), Vf gets set to 0, otherwise, Vf gets set to 1.
A negative number is represented as it's 2's complement, meaning (for 8-bit numbers) 0 - 1 = 255, 0 - 2 = 254, etc.
8xyE - SHL Vx, {Vy} - shift Vx left once.
Shifts the value of Vx left once (<< 1). Vf gets set to the bit shifted "off" the number (value ANDed with 0x80, divided by 0x80). (shifting left equals multiplying by 2)
Note that Vf gets set after the shift so shifting Vf itself will mean that Vf contains the shifted-off bit, not the result.
In the original interprenter the value of Vy got shifted and stored in Vx instead.
Certain games require this behaviour, but other games break beacuse of it. My emulator has a setting for this because of it.
9xy0 - SNE Vx, Vy - skip next instruction if Vx != Vy.
Skips the next opcode if Vx does not equal Vy by increasing the PC by 2.
Annn - LD I, #nnn - load I with address nnn.
Sets I to the value nnn.
Bnnn - JP V0, #nnn - jump to nnn + V0
Jumps to nnn + V0. It sets the PC to the result of nnn + V0.
Cxkk - RND Vx, #kk - load Vx with random value ANDed with kk.
Sets Vx to the result of a random value (0-255) ANDed with kk.
Certain games expect that the value gets set to the random value modulus (%) kk instead, but this breaks other games.
My emulator has a setting for this because of it.
Dxyp - DRW Vx, Vy, #p - draw p-high sprite at (Vx, Vy).
If p is not 0, it draws a 8*p (width*height) sprite at location (Vx, Vy) using data from memory at I.
The positions are modulus screen width/height. (this, of course, changes depending on low/high res modes)
Pixels are XOR-red on the screen meaning that is a pixel is drawn on an already existing pixel, it gets set back to off. If any pixels got set to off, Vf gets set to 1, otherwise, Vf gets set to 0.
Each byte from memory is equal to 1 row of the sprite meaning each bit is a pixel. The most signifcant bit is the leftmost pixel and the least significant bit the rightmost.
Note that in low-res mode, each "pixel" is drawn as 2*2 pixels meaning the x and y positions are doubled.
If p is 0 and the screen is in low-res mode, a 8*16 sprite is drawn. In high-res mode however, it draws a 16*16 sprite.
For a 16*16 sprite each set of 2 bytes from memory is a row where the first byte are the left 8 pixels and the second byte the right 8 pixels.
What happens when a sprite is partially off-screen is not clearly defined. Certain games expect the pixels to loop to the opposite side, other games expect them to not be drawn at all.
My emulator has a setting for what happens because of this.
Ex9E - SKP Vx - skip next instruction if key Vx is pressed.
Skips the next opcode if the key labeled the value of Vx is currently pressed.
ExA1 - SKNP Vx - skip next instruction if key Vx is not pressed
Skips the next opcode if the key labeled the value of Vx is not currently pressed.
Fx07 - LD Vx, DT - load Vx with delay-timer.
Sets Vx equal to the current value of the delay-timer.
Fx0A - LD Vx, K - wait for keypress and load Vx with pressed key.
Waits until a key is pressed and released and sets Vx to the label of the pressed key.
Apparently the interprenter on the HP-48 continues as soon as a key is pressed. I added a setting to my emulator for this.
Fx15 - LD DT, Vx - load delay-timer with Vx.
Sets the delay-timer to Vx.
Fx18 - LD ST, Vx - load sound-timer with Vx.
Sets the sound-timer to Vx. This means it generates a tone for Vx/60 seconds.
Fx1E - ADD I, Vx - add Vx to I.
Adds Vx to I. Note that atleast one game seems to require this to affect Vf, where it gets set to 1 if I overflows out of 12 bits and to 0 otherwise.
Because this seems a bit stramge (I is technically 16-bits), I made this a setting in my emulator.
Fx29 - LD F, Vx - load I with address of built-in font for Vx.
Sets I to the address pointing to the 4*5 sprite from the font for the value in Vx.
Fx30 - LD HF, Vx - load I with address of built-in high-res font for Vx (Super chip 8).
Sets I to the address pointing to the 8*10 sprite from the high-res font for the value in Vx.
Fx33 - LD B, Vx - load ram starting at I with 3-digit BCD of Vx.
Sets ram at I, I + 1 and I + 2 to the BCD representation of Vx.
This means that the ram at I becomes the hunders digit, the ram at I + 1 the tenths digit and the ram at I + 2 the ones digit of the number in Vx.
Fx55 - LD [I], Vx - load ram starting at I with registers V0-Vx.
Sets the ram at I, I + 1 ... I + x to the registers V0, V1 ... Vx.
In the original interprenter I was changed to I + x + 1 at the end of this opcode.
Certain games require this behaviour, but other games break beacuse of it. My emulator has a setting for this because of it.
Fx65 - LD Vx, [I] - load V0-Vx with ram starting at I.
Sets registers V0, V1 ... Vx to the ram at I, I + 1 ... I + x.
In the original interprenter I was changed to I + x + 1 at the end of this opcode.
Certain games require this behaviour, but other games break beacuse of it. My emulator has a setting for this because of it.
Fx75 - LD R, Vx - load Hp-48 flags 0-x with V0-Vx (Super chip 8).
Sets the HP-48 flags R0, R1 ... Rx to the registers V0, V1 ... Vx.
Fx85 - LD Vx, R - load V0-Vx with Hp-48 flags 0-x (Super chip 8).
Sets the registers V0, V1 ... Vx to the HP-48 flags R0, R1 ... Rx.