PicoCPU - Revision history

Karljans: /* Table of instructions */

2015-11-24T14:17:40Z

‎Table of instructions

Karljans: /* Instruction set */

2015-11-24T13:28:04Z

‎Instruction set

Karljans: /* Instruction set */

2015-11-24T13:12:44Z

‎Instruction set

Karljans at 13:04, 24 November 2015

2015-11-24T13:04:10Z

Karljans at 12:05, 24 November 2015

2015-11-24T12:05:50Z

Karljans at 12:04, 24 November 2015

2015-11-24T12:04:55Z

Karljans at 19:19, 23 November 2015

2015-11-23T19:19:10Z

Karljans: Created the page

2015-11-23T17:29:48Z

Created the page

New page

TBD

@@ Line 53: / Line 53: @@
 = Instruction set =
-== Table of instructions ==
+'''== Table of instructions ==
 {| class="wikitable"
 |'''Opcode'''
@@ Line 220: / Line 220: @@
 |PC ← PC + 1
 |}
 = Download =

@@ Line 53: / Line 53: @@
 = Instruction set =
 {| class="wikitable"
 |'''Opcode'''
@@ Line 212: / Line 213: @@
 |NOP
 |All unused instructions are treated as NOP
+|PC ← PC + 1
 |-
 |'''11111'''
 |NOP
 |All unused instructions are treated as NOP
+|PC ← PC + 1
 |}

@@ Line 211: / Line 211: @@
 |'''11110'''
 |NOP
-|All unused instructions are treated as
+|All unused instructions are treated as NOP
-|NOP
 |-
 |'''11111'''
 |NOP
-|All unused instructions are treated as
+|All unused instructions are treated as NOP
-|NOP
 |}

← Older revision		Revision as of 13:04, 24 November 2015
Line 53:		Line 53:

	= Instruction set =		= Instruction set =
		+	{\| class="wikitable"
		+	\|'''Opcode'''
		+	\|'''Instruction'''
		+	\|'''Description'''
		+	\|'''Register Transfer Language Description'''
		+	\|-
		+	\|00000
		+	\|ADD
		+	\|Add the operand to the AC, no carry in
		+	\|AC ← AC + OP
		+	\|-
		+	\|'''00001'''
		+	\|SUB
		+	\|Subtract the operand from the AC, no carry in
		+	\|AC ← AC – OP
		+	\|-
		+	\|'''00010'''
		+	\|INC
		+	\|Increment the AC by one, no carry in
		+	\|AC ← AC + 1
		+	\|-
		+	\|'''00011'''
		+	\|DEC
		+	\|Decrement the AC by one, no carry in
		+	\|AC ← AC -1
		+	\|-
		+	\|'''00100'''
		+	\|SLL
		+	\|Logical shift the AC value to the left
		+	\|AC ← SLL(AC)
		+	\|-
		+	\|'''00101'''
		+	\|SRL
		+	\|Logical shift the AC value to the right
		+	\|AC ← SRL(AC)
		+	\|-
		+	\|'''00110'''
		+	\|SLA
		+	\|Arithmetical shift the AC value to the left
		+	\|AC ← SLA(AC)
		+	\|-
		+	\|'''00111'''
		+	\|SRA
		+	\|Arithmetical shift the AC value the right
		+	\|AC ← SRA(AC)
		+	\|-
		+	\|'''01000'''
		+	\|AND
		+	\|AND the operand with the AC
		+	\|AC ← AC AND OP
		+	\|-
		+	\|'''01001'''
		+	\|OR
		+	\|OR the operand with the AC
		+	\|AC ← AC OR OP
		+	\|-
		+	\|'''01010'''
		+	\|XOR
		+	\|XOR the operand with the AC
		+	\|AC ← AC XOR OP
		+	\|-
		+	\|'''01011'''
		+	\|INV
		+	\|Invert the AC value
		+	\|AC ← INV(AC)
		+	\|-
		+	\|'''01100'''
		+	\|NEG
		+	\|Calculate the opposite-signed value of the AC value (pos → neg, neg → pos)
		+	\|AC ← INV(AC)+1
		+	\|-
		+	\|'''01101'''
		+	\|LOADN
		+	\|Load the number in operand into the AC
		+	\|AC ← OP
		+	\|-
		+	\|'''01110'''
		+	\|LOADV
		+	\|Load the value of the address specified in the operand into the AC
		+	\|AC ← M(OP)
		+	\|-
		+	\|'''01111'''
		+	\|STORE
		+	\|Store the contents of the AC into the address in the operand
		+	\|M[OP] ← AC
		+	\|-
		+	\|'''10000'''
		+	\|JMP
		+	\|Set the program counter to the value in the operand
		+	\|PC ← OP
		+	\|-
		+	\|'''10001'''
		+	\|BIZ
		+	\|If 0 flag is set, set PC to address in operand, else by increase it by 1
		+	\|if (Z == 1) then PC ← OP, else PC ← PC +1
		+	\|-
		+	\|'''10010'''
		+	\|BINE
		+	\|Subtract the operand from the AC. if 0 flag set, PC=PC+1( instruction PC+1 has to contain jump command to branch), else PC=PC+2
		+	\|AC ← AC – OP; if (Z != 1) then PC ← PC + 1, else PC ← PC + 2
		+	\|-
		+	\|'''10011'''
		+	\|BIOF
		+	\|If OV flag is set, set PC to address in operand, else by increase it by 1
		+	\|if (OV == 1) then PC ← OP, else PC ← PC +1
		+	\|-
		+	\|'''10100'''
		+	\|SETR
		+	\|Copy the value in the AC into the register
		+	\|R ← AC
		+	\|-
		+	\|'''10101'''
		+	\|CLRR
		+	\|Clear the register
		+	\|R ← 0
		+	\|-
		+	\|'''10110'''
		+	\|SETF
		+	\|Set the flag described in operand
		+	\|F[OP] ← 1
		+	\|-
		+	\|'''10111'''
		+	\|CLRF
		+	\|Clear the flag in operand
		+	\|F[OP] ← 0
		+	\|-
		+	\|'''11000'''
		+	\|MUXR
		+	\|Set the ALU input to the register After executing that instruction, all operands in all instructions will be replaced by the contents of the chosen register until MUXOP is executed
		+	\|OP ← R
		+	\|-
		+	\|'''11001'''
		+	\|MUXOP
		+	\|Set the ALU input to operand in. The operand in this command is ignored
		+	\|OP ← OP
		+	\|-
		+	\|'''11010'''
		+	\|LOADA
		+	\|Load the value from a memory cell specified in the AC into the AC
		+	\|AC ← M(AC)
		+	\|-
		+	\|'''11011'''
		+	\|STOREA
		+	\|Stores the value in the register to address in AC
		+	\|M(AC) ← R
		+	\|-
		+	\|'''11100'''
		+	\|HALT
		+	\|Halt the CPU
		+	\|PC ← PC
		+	\|-
		+	\|'''11101'''
		+	\|NOP
		+	\|No operation
		+	\|PC ← PC + 1
		+	\|-
		+	\|'''11110'''
		+	\|NOP
		+	\|All unused instructions are treated as
		+	\|NOP
		+	\|-
		+	\|'''11111'''
		+	\|NOP
		+	\|All unused instructions are treated as
		+	\|NOP
		+	\|}

@@ Line 36: / Line 36: @@
 The zero flag indicates that the value in the accumulator is equal to 0 and OV flag indicates that the last operation caused an overflow in the accumulator. User can access the values of these flags using some conditional branching functions (BranchIfZero, etc.). The flags are only held up as long as the condition for a flag is true (i.e. the accumulator is zero) and are, thus, usually available only to the next isntruction (except some neutral instructions like NOP, that are not data-related).
-== Impementation ==
+= Impementation =
 [[File:PicoCPU testbench.png|thumbnail|right|Diagram showing implementation of picoCPU]]
 Each main component of picoCPU is implemented as a separate entity. The structure of the connections can be seen in the figure on the right.
@@ Line 42: / Line 42: @@
 In case of picoCPU, the program memory is emulated be the testbench. Its contents are read from a text file. This enables easy reprogramming of picoCPU for simulation purposes.
-=== Program Memory Data format ===
+== Program Memory Data format ==
 [[File:Instruction.png|thumbnail|right|Description of the instruction format for picoCPU]]
 As it can be seen in the figure on the right, each instruction for the picoCPU consists of 16 bits. The three highest bits are reserved and not currently used, so they should be given the values '0'. The next 5 bits (bits 12 - 8)
 specify the opcode. Finally the lowest 8 bits (bits 7-0) specify the operand. It has to be noted, that picoCPU accepts only one operand in an instruction. In case no operand is needed for the instruction, the operand bits are ignored.
-=== Program memory file format ===
+== Program memory file format ==
 As mentioned above, the program memory in picoCPU is emulated by the tesbench and its contents are read from a text file. The format of the text file is quite simple: each line represents one memory address, line 1 mapping to memory address 0x0, line 2 to address 0x1 and so on. Each line contains 16 bits in a format mentioned above.
 The execution of the program starts from memory address 0x0 and the address is normally increased by one after executing of every line, except branching instructions, that can cause the program execution to jump to other addresses.
-=== Instruction set ===
+= Instruction set =

@@ Line 6: / Line 6: @@
 * '''Control Unit (CU):''' Reads the instructions, advances the program counter and controls the work of the rest of the CPU
 * '''Data Path Unit (DPU):''' Does all the calculations and other data manipulation operations
-* '''Instruction Memory (IM):''' A ROM that contains the program data. In picoCPU, it is emulated by the testbench.
+* '''Program Memory (PM):''' A ROM that contains the program data. In picoCPU, it is emulated by the testbench.
 * '''Data memory (DM):''' The data memory is implemented as a RAM. It contains the temporary data that are needed by the currently running program.
@@ Line 14: / Line 14: @@
 [[File:Control Unit.png|thumbnail|right|Diagram of the control unit for picoCPU]]
 The most important part of the CU is the control FSM, that has four states:
-# '''Fetch:''' fetches the data from the instruction memory and stores it in the instruction register.
+# '''Fetch:''' fetches the data from the program memory and stores it in the instruction register.
 # '''Decode:''' Seperates operand from instruction
 # '''Execute:''' Executes the instruction
 # '''Write back:''' Writes execution result to the destination register or memory address, advances the program counter.
-The program counter (PC) is a pointer to the instruction memory address of the currently executed instruction. The program counter's value directly specifies the memory address for reading the instruction memory. Usually, the program counter is increased by one after the current instruction is loaded (next address of the instruction memory is chosen). However, it is also possible to change the PC's value to an arbitrary one, for example to implement branching in the code.
+The program counter (PC) is a pointer to the program memory address of the currently executed instruction. The program counter's value directly specifies the memory address for reading the program memory. Usually, the program counter is increased by one after the current instruction is loaded (next address of the program memory is chosen). However, it is also possible to change the PC's value to an arbitrary one, for example to implement branching in the code.
 == Data Path Unit ==
 [[File:DPU.png|thumbnail|right|Diagram of the DPU's architecture for the picoCPU]]
 === ALU ===
-The central part of the DPU is the Arithmetic and Logic Unit (ALU). ALU's task is to execute all the arithmetical and logical calculations. It has many functions and the correct one is chosen by the CU, based on the currently executed instruction. Every calculation result always ends up in the accumulator register. The first input of the ALU can be multiplexed between a register and the operand from the operand from the instruction memory and the contents of a register (the multiplexor  can be controlled be specific instructions).  The second input is always the contents of the accumulator.
+The central part of the DPU is the Arithmetic and Logic Unit (ALU). ALU's task is to execute all the arithmetical and logical calculations. It has many functions and the correct one is chosen by the CU, based on the currently executed instruction. Every calculation result always ends up in the accumulator register. The first input of the ALU can be multiplexed between a register and the operand from the operand from the program memory and the contents of a register (the multiplexer  can be controlled be specific instructions).  The second input is always the contents of the accumulator.
 === Memory operations ===
@@ Line 37: / Line 37: @@
 == Impementation ==

← Older revision		Revision as of 19:19, 23 November 2015
Line 1:		Line 1:
−	~~TBD~~	+	The picoCPU was built as a course work during the Digital Systems Modelling and Synthesis course. Its goal is to provide very simple and minimal, but still functional, general purpose CPU design for educational purposes.
		+
		+	= Architecture =
		+	[[File:PicoCPU architecture.png\|thumbnail\|right\|Architecture of picoCPU]]
		+	PicoCPU is divided into four main components (seen in the figure on the right):
		+	* '''Control Unit (CU):''' Reads the instructions, advances the program counter and controls the work of the rest of the CPU
		+	* '''Data Path Unit (DPU):''' Does all the calculations and other data manipulation operations
		+	* '''Instruction Memory (IM):''' A ROM that contains the program data. In picoCPU, it is emulated by the testbench.
		+	* '''Data memory (DM):''' The data memory is implemented as a RAM. It contains the temporary data that are needed by the currently running program.
		+
		+	PicoCPU is designed to have a generic design and it's bitwidth is scalable to satisfy the user's preference, being 8-bit by default. All the data are '''always''' treated as '''signed''' values.
		+
		+	== Control Unit ==
		+	[[File:Control Unit.png\|thumbnail\|right\|Diagram of the control unit for picoCPU]]
		+	The most important part of the CU is the control FSM, that has four states:
		+	# '''Fetch:''' fetches the data from the instruction memory and stores it in the instruction register.
		+	# '''Decode:''' Seperates operand from instruction
		+	# '''Execute:''' Executes the instruction
		+	# '''Write back:''' Writes execution result to the destination register or memory address, advances the program counter.
		+
		+	The program counter (PC) is a pointer to the instruction memory address of the currently executed instruction. The program counter's value directly specifies the memory address for reading the instruction memory. Usually, the program counter is increased by one after the current instruction is loaded (next address of the instruction memory is chosen). However, it is also possible to change the PC's value to an arbitrary one, for example to implement branching in the code.
		+
		+	== Data Path Unit ==
		+	[[File:DPU.png\|thumbnail\|right\|Diagram of the DPU's architecture for the picoCPU]]
		+	=== ALU ===
		+	The central part of the DPU is the Arithmetic and Logic Unit (ALU). ALU's task is to execute all the arithmetical and logical calculations. It has many functions and the correct one is chosen by the CU, based on the currently executed instruction. Every calculation result always ends up in the accumulator register. The first input of the ALU can be multiplexed between a register and the operand from the operand from the instruction memory and the contents of a register (the multiplexor can be controlled be specific instructions). The second input is always the contents of the accumulator.
		+
		+	=== Memory operations ===
		+	Writing to and reading from the data memory always involves the accumulator - all data read from the memory always ends up in the accumulator. It is also only possible to write into the memory data that is stored in the accumulator.
		+
		+	For writing into the register, the file data to be written has to be already in the accumulator. Then, a special instruction is used for doing the writing. Reading from the register can be done only through the ALU, using the regular ALU-related instructions, just the MUX has to be configured to take its input from the register. Due to the fact that it is possible to access the register only through the ALU, the value of the register can only be retrieved by running an arithmetic or logic operation on it. If just retreaving of the value is desired, a neutral operation, that does not change the value can be performed, like adding or subtracting 0 to/from the register or AND-ing the value with 1-s.
		+
		+	=== Flags ===
		+	The picoCPU features two flags: zero (Z) and overflow(OV)
		+
		+	The zero flag indicates that the value in the accumulator is equal to 0 and OV flag indicates that the last operation caused an overflow in the accumulator. User can access the values of these flags using some conditional branching functions (BranchIfZero, etc.). The flags are only held up as long as the condition for a flag is true (i.e. the accumulator is zero) and are, thus, usually available only to the next isntruction (except some neutral instructions like NOP, that are not data-related).
		+
		+	== Impementation ==