Ps 8-32m Fantasy Console

The Ps 8-32m is a fantasy console made for the FC Dev Jam. The console is only tested with Google Chrome.

The following is a list of features for the console:

• 160 x 96 pixels 1-bit display
• Display divided into 8 x 8 pixels blocks
• 30 FPS refresh rate
• 32K of memory for user programs
• Custom character table
• Custom 8-bit processor that works with 8-, 16-, and 32-bit integers

Besides the fantasy console the following tools / dev features are provided:

• Scalable output display
• The choice of pixel perfect or fuzzy up-scaling
• The possibility of pausing the console and stepping through it 'x' cycles at a time
• A character encoder tool that can encode a bitmap image into a data array that can be used as character maps in the fantasy console.
• A memory debugger that can display the memory at any given point. Vital for debugging programs.
• A simple compiler that can compile a custom assembly language into byte code that can be loaded into the fantasy console and executed.

Getting started

The Ps 8-32m starts in paused mode. Press the 'resume/pause' button in the menu to toggle if the console is running. Make sure the Compiler tool is selected. The compiler comes with a few example programs. Select a program from the examples dropdown. Press the 'Compile' button. The byte code should show up in the output window and an 'Execute' button should appear. Press the execute button and make sure you have pressed the 'resume/pause' button in the main menu so the computer is running. You should know see the program running.

Compiling and then executing a program through the compile tool is currently the only way to run a program in the Ps 8-32m.

Memory layout

The following list illustrates the Ps 8-32m memory layout:

• 0x0000 - 0x7FFF: This is currently user available memory. When a program is loaded it starts at address 0x0000
• 0x8000 - 0x979C: VRAM. This is the memory dedicated to the video controller.
  • 0x8000: Display mode. 0 is block mode. 1 is character text mode.
  • 0x8001 - 0x8003: Background palette. RGB colors.
  • 0x8004 - 0x8006: Foreground palette. RGB colors.
  • 0x8007: Current character map. The video controller supports 3 character maps. 0 is the default character map. 1 and 2 is user assignable character maps.
  • 0x8008 - 0x8009: Sync interrupt address. This interrupt occurs every second. Assign a 16-bit address here to execute some code when the interrupt occurs. If these 2 bytes are 0 the interrupt will not execute.
  • 0x800a - 0x800b: HBlank interrupt address. This interrupt occurs every hblank. Assign a 16-bit address here to execute some code when the interrupt occurs. If these 2 bytes are 0 the interrupt will not execute.
  • 0x800c - 0x800d: VBlank interrupt address. This interrupt occurs every vblank. Assign a 16-bit address here to execute some code when the interrupt occurs. If these 2 bytes are 0 the interrupt will not execute.
  • 0x8010 - 0x878F: Default character map. Each byte represents 8 pixels in a character block.
  • 0x8790 - 0x8F0F: User character map 1. Each byte represents 8 pixels in a character block.
  • 0x8F10 - 0x968F: User character map 2. Each byte represents 8 pixels in a character block.
  • 0x9690 - 0x97c7: Display memory. Each byte represents a character block that is displayed.
• 0x97c8 - 0x98c7: Keyboard memory
  • 0x97c8 - 0x97c9: Key interrupt address. This interrupt occurs every time a key is pressed or released. Assign a 16-bit address here to execute some code when the interrupt occurs. If these 2 bytes are 0 the interrupt will not execute.
  • 0x97ca: Last key. Contains the last key that was pressed or released.
  • 0x97d0 - 0x98c7: Keyboard map. Each byte indicates if a key is pressed (255) or not (0). A specifics keys address is defined as 0x97d0 + keycode. Note that many of these addresses are unused.

Keycodes

This is a list of the currently defined keycodes:

• KC_SPACE = 0x00
• KC_EXCLAMATION = 0x01
• KC_QUOTE = 0x02
• KC_HASH = 0x03
• KC_DOLLAR = 0x04
• KC_PERCENT = 0x05
• KC_AMPERSAND = 0x06
• KC_SINGLEQUOTE = 0x07
• KC_OPENPARENS = 0x08
• KC_CLOSEDPARENS = 0x09
• KC_MULTIPLY = 0x0a
• KC_PLUS = 0x0b
• KC_COMMA = 0x0c
• KC_MINUS = 0x0d
• KC_PERIOD = 0x0e
• KC_SLASH = 0x0f
• KC_ZERO = 0x10
• KC_ONE = 0x11
• KC_TWO = 0x12
• KC_THREE = 0x13
• KC_FOUR = 0x14
• KC_FIVE = 0x15
• KC_SIX = 0x16
• KC_SEVEN = 0x17
• KC_EIGHT = 0x18
• KC_NINE = 0x19
• KC_COLON = 0x1a
• KC_SEMICOLON = 0x1b
• KC_LESS = 0x1c
• KC_EQUAL = 0x1d
• KC_GREATER = 0x1e
• KC_QUESTION = 0x1f
• KC_AT = 0x20
• KC_CA = 0x21
• KC_CB = 0x22
• KC_CC = 0x23
• KC_CD = 0x24
• KC_CE = 0x25
• KC_CF = 0x26
• KC_CG = 0x27
• KC_CH = 0x28
• KC_CI = 0x29
• KC_CJ = 0x2a
• KC_CK = 0x2b
• KC_CL = 0x2c
• KC_CM = 0x2d
• KC_CN = 0x2e
• KC_CO = 0x2f
• KC_CP = 0x30
• KC_CQ = 0x31
• KC_CR = 0x32
• KC_CS = 0x33
• KC_CT = 0x34
• KC_CU = 0x35
• KC_CV = 0x36
• KC_CW = 0x37
• KC_CX = 0x38
• KC_CY = 0x39
• KC_CZ = 0x3a
• KC_OPENBRACK = 0x3b
• KC_BACKSLASH = 0x3c
• KC_CLOSEDBRACK = 0x3d
• KC_HAT = 0x3e
• KC_UNDERSCORE = 0x3f
• KC_BACKTICK = 0x40
• KC_A = 0x41
• KC_B = 0x42
• KC_C = 0x43
• KC_D = 0x44
• KC_E = 0x45
• KC_F = 0x46
• KC_G = 0x47
• KC_H = 0x48
• KC_I = 0x49
• KC_J = 0x4a
• KC_K = 0x4b
• KC_L = 0x4c
• KC_M = 0x4d
• KC_N = 0x4e
• KC_O = 0x4f
• KC_P = 0x50
• KC_Q = 0x51
• KC_R = 0x52
• KC_S = 0x53
• KC_T = 0x54
• KC_U = 0x55
• KC_V = 0x56
• KC_W = 0x57
• KC_X = 0x58
• KC_Y = 0x59
• KC_Z = 0x5a
• KC_OPENCURLY = 0x5b
• KC_PIPE = 0x5c
• KC_CLOSEDCURLY = 0x5d
• KC_TILDE = 0x5e
• KC_POUND = 0x5f
• KC_CIRCLE = 0x60
• KC_RARROW = 0x61
• KC_LARROW = 0x62
• KC_UARROW = 0x63
• KC_DARROW = 0x64
• KC_ENTER = 0x80
• KC_TAB = 0x81
• KC_BACKSPACE = 0x82
• KC_SHIFT = 0x83
• KC_ALT = 0x84
• KC_CTRL = 0x85

Assembly reference

The processor has 21 registers. 16 of those are user assignable 8-bit registers known as R-registers. The R-registers can also store 16-, and 32-bit integers if they are combined. E.g. if $r0 is 0xAB and $r1 is 0xCD then if you read a 16-bit number from either $r0 or $r1 the value 0xCDAB is returned. Note that the processor uses little endianess.

• 0 => (8/16/32-bit) the value 0. Can't be assigned directly
• pc => (16-bit) program counter - points to the next address to process. Can't be assigned directly
• mem => (16-bit) memory address - user set address that points at memory
• ret => (16-bit) return address - ret = pc+1 when call is executed. pc = ret when return is executed. Can't be assigned directly
• int => (16-bit) return address for interrupt handlers. Can't be assigned directly
• r0..r15 => (8-bit) registers

Opcodes are 1 byte. Register addresses are also 1 byte. Some instructions can use multiple registers to create 16- or 32-bit numbers.

• r* = 1 byte register
• i, i8 = 1 byte immediate signed number
• i16 = 2 bytes immediate signed number
• i32 = 4 bytes immediate signed number
• ui, ui8 = 1 byte immediate unsigned number
• ui16 = 2 bytes immediate unsigned number
• ui32 = 4 bytes immediate unsigned number

Bit Manipulation:

• and r0 r1 r2 => r0 = r1 & r2
• andi r0 r1 i8 => r0 = r1 & i8
• or*
• xor*
• not*
• shr*
• shl*

Arithmetic:

• add8 r0 r1 r2 => r0 = r1 + r2
• addi8 r0 r1 i => r0 = r1 + i
• add16 r2 r4 => r0r1 = r2r3 + r4r5
• add32 r4 r8 => r0r1r2r3 = r4r5r6r7 + r8r9r10r11
• addi16 r2 i16 => r0r1 = r2r3 + i16
• addi32 r4 i32 => r0r1r2r3 = r4r5r6r7 + i32
• addu* => unsigned versions of all the above addition instructions
• sub* => subtraction
• mul* => multiplication
• div* => integer division - remainder is placed in r12-r15

Store/Load/Move:

• li8 r0 i8 => r0 = i
• li16 r0 i16 => r0r1 = i16
• li32 r0 i32 => r0r1r2r3 = i32
• lui8 r0 i8 => r0 = i
• lui16 r0 i16 => r0r1 = i16
• lui32 r0 i32 => r0r1r2r3 = i32
• lm8 r0 => r0 = mem*
• lm16 r0 => r0r1 = mem*
• lm32 r0 => r0r1r2r3 = mem*
• sm r0 => mem* = r0
• sm8 r0 => mem* = r0
• sm16 r0 => mem* = r0r1
• sm32 r0 => mem* = r0r1r2r3
• mov8 r0 r1 => r0 = r1
• mov16 r0 r2 => r0r1 = r2r3
• mov32 r0 r4 => r0r1r2r3 = r4r5r6r7
• mvm a16 b16 i8 => a16[0..i8-1] = b16[0..i8-1] copy memory from a16 to b16
• clm a16 i8 c8 => a16[0..i8-1] = c8 clear memory from a16

Control (every register is treated as an usigned number):

• beq8 r0 r1 i16 => pc = i16 if r0 = r1
• beq16 r0 r2 i16 => pc = i16 if r0r1 = r2r3
• beq32 r0 r4 i16 => pc = i16 if r0r1r2r3 = r4r5r6r7
• blt* => branch if less than
• ble* => branch if less or equal
• bgt* => branch if greater than
• bge* => branch if greater or equeal
• bne* => branch if not equal

Jumping:

• jmp i16 => pc = i16
• call i16 => ret = pc + 1, jmp i16
• ret => jmp ret, ret = 0
• rint => jmp rint, rint = 0

Skipping:

• nop => do nothing, skip a cycle
• nopi i8 => do nothing, skip i8 cycles