HERA

HERA: Hopefully Electronics Running Automatically

A slightly less simple CPU than the SPEAR [blocked]. It is way more powerful due to:

• Significantly more control lines, thus more instructions
• An extra C register
• Direct read and write access to all registers
• Jump and branches as individual instructions (SPEAR solution was creative, but tedious)
• A 16-bit bus (i.e. jump in single cycle)
• 16-bit registers and ALU
• RAM size increased from 256 bytes to 128 KiB
• Additional NOR operation
• Multiple flags (carry out, zero, negative) in a proper status register
• Far better input/output capabilities
• Instructions without literal value fit into one byte

Features

• Full 16-bit architecture
  • 16-bit addressing for ROM and RAM (ROM: 64 KiB, RAM: 128 KiB)
    • Two RAM chips for direct 16-bit access
  • 16-bit bus, registers and ALU
• Usable digital I/O
  • 256 input ports (16-bit)
  • 256 output ports (16-bit), can be extended at expense of RAM size

Technical details

Instructions

The upper 4 bits of any instruction represent control lines for writing to the internal bus (everything but STAT uses 16-bit values):

If a literal is selected to be written to the bus (upper nibble is 0x0), it is read from the two bytes after the instruction in big-endian format.

The lower 4 bits represent control lines for reading from the internal bus:

Status register

The flags of the status register STAT are written on any arithmetic operation (ADD, COM, NOR) and any instruction writing the A register. Arithmetic operations overwrite all flags, instructions writing the A register overwrite only the zero and negative flags.

Assembly code Examples

Machine code Examples

Copying the value of the A register into the B register is done by instruction 0x12 (upper nibble 1 -> write A to bus, lower nibble 2 -> read from bus into B).

Setting B to a literal value is done by instruction 0x02 followed by two bytes in big-endian order (i.e. 0x02 0x12 0x34 -> B=0x1234).

Some larger programs showcasing some optimized instructions (all instructions in hexadecimal):

# This program writes a lookup-table (array) for showing a 4-bit value as a hexadecimal character on a seven segment display using the following segments (a=LSB, h=MSB):

#  aaa
# f   b
# f   b
# f   b
#  ggg
# e   c
# e   c
# e   c
#  ddd  h

# Using lower nibble 0xB can be a very efficient way to count a pointer (by setting the operand and the pointer in a single instruction), the counting offset (or "step") is determined by the A register.

(00) 01 00 01   # A = 0x01 (increment pointer while writing lookup-table)
(03) 0b 00 80   # B = RAM_P = 0x0080 (base pointer of lookup-table)
(06) 04 00 3f   # Write 0x3f (character '0') at address 0x0080
(09) ab         # Add into B register and RAM_P (increment pointer by 1)
(0A) 04 00 06   # Write 0x06 (character '1') at address 0x0081
(0D) ab         # 
(0E) 04 00 5b   # '2'
(11) ab         # 
(12) 04 00 4f   # '3'
(15) ab         # 

Default memory map