## Σniac II

The Σniac II (pronounced "Zee-niac") is a minimal processor. There is only one user-accessible register, the accumulator A. The Σniac operates on 8-bit words, and has a 5-bit address space. There are 6 regular instructions, as well as a special "halt" instruction that indicates the end of computation. Each instruction is encoded in one byte: 3 bits opcode, and 5 bits address. The 5-bit instruction counter IC is reset to 0 upon a reset, so that instruction always starts at address 0.

The memory is organized as follows:
ROM: addresses 0x00 .. 0x17 (24 bytes) - for program and constants
RAM: addresses 0x18 .. 0x1f  (8 bytes)  - for memory variables

#### Σniac II instruction set and opcodes

```    opcode        mnemonic        meaning

7   111 11111     halt            stop execution
```

The Σniac II is a slight modification of the Σniac, a computer designed by students in a J-term course in 1999. Later in the semester we will construct and simulate a complete circuit for the Σniac II in Logisim.

#### Sample programs

Here is a small program to compute 3+10-1 and store the result in RAM. Note that labels are used for all addresses.

```address            instruction   opcode            comments
hex binary label   (mnemonic)    binary     hex
00  00000          ld   A, C3    000 00101  05     // constant 3 is stored at address C3 == 5
01  00001          add  A, C10   010 00110  46
02  00010          sub  A, C1    001 00111  27
03  00011          st   A, X     011 11000  78
04  00100          halt          111 11111  FF
05  00101  C3:     3             0000 0011  03
06  00110  C10:    10            0000 1010  0A
07  00111  C1:     1             0000 0001  01

18  11000 X:                                        // variable X is stored in RAM at address 0x18

```

Here is a program to sum the numbers from 1 to N and load the result into the accumulator. Addresses are given in hex. Again, labels are used fo all addresses (constants, variables, and branch targets)

```address    instruction   opcode

00         ld   A, N     000 01100  0C
01         st   A, sum   011 11001  79
02  loop:  sub  A, C1    001 01011  2B
03         bneg end      101 01001  A9
04         st   A, i     011 11000  78
05         add  A, sum   010 11001  59
06         st   A, sum   011 11001  79
07         ld   A, i     000 11000  18
08         b    loop     100 00010  82
09  end:   ld   A, sum   000 11001  19
0A         halt          111 11111  FF
0B  C1:    1             0000 0001  01
0C  N:     5             0000 0101  05

18  i:
19  sum:
```

Use the formatting of the above program as a model when you write your own programs. After a bit of practice you can omit the binary opcode column.