COMPUTER ARCHITECTURE

Introduction

In the world of mechatronics, where mechanical systems meet digital control, understanding the language of processors is crucial. This language consists of instruction sets and opcodes, which form the foundation of how our robotic creations think and act. Let's dive into this fascinating world and see how it applies to the mechatronic systems you'll be designing and programming.

What are Opcodes?

Opcodes, short for Operation Codes, are the basic instructions that a computer's processor can understand and execute. Think of them as the most fundamental "words" in a computer's vocabulary. Each opcode tells the processor to perform a specific operation, like adding two numbers or moving data from one place to another.

Example: Adding Two Numbers

Let's start with a very basic operation: adding two numbers. In a high-level language like Python, you might write:

sum = 5 + 3

Now, let's break this down into steps that a processor might take:

• Load the first number (5) into a register

• Load the second number (3) into another register

• Add the contents of these registers

• Store the result in memory

In a simple assembly language, this might look like:

MOV R1, #5    ; Move 5 into Register 1

MOV R2, #3    ; Move 3 into Register 2

ADD R3, R1, R2 ; Add R1 and R2, put result in R3

STR R3, [R0]  ; Store result from R3 into memory address in R0

From Assembly to Opcodes

Now, let's see how these assembly instructions might translate to opcodes. We'll use a simplified 8-bit opcode format for this example:

MOV R1, #5    -> 00 01 0101  --> (00 = MOV, 01 = R1, 0101 = immediate value 5)

MOV R2, #3    -> 00 10 0011  --> (00 = MOV, 10 = R2, 0011 = immediate value 3)

ADD R3, R1, R2 -> 10 11 0102  --> (10 = ADD, 11 = R3, 01 = R1, 02 = R2)

STR R3, [R0]  -> 11 11 0000  --> (11 = STR, 11 = R3, 00 = R0)

In this simplified format:

• The first 2 bits indicate the operation (00 for MOV, 10 for ADD, 11 for STR)

• The next 2 bits indicate the destination register

• The last 4 bits are either an immediate value or source registers

Example: Loops

A simple program to count up to 5.

Python:

The high-level language that humans can more readily understand.

counter = 0

limit = 5

while counter != limit:

    counter += 1

# Program end (result in counter)

Assembly Version:

A low-level language that directly translates to machine code instructions.

MOV R0, #0        ; Initialize counter

    MOV R1, #5        ; Set limit

loop:

    ADD R0, R0, #1    ; Increment counter

    CMP R0, R1        ; Compare counter with limit

    BNE loop          ; Branch if not equal (loop back)

end:

    ; Program end (result in R0)

Machine Code:

What the CPU or microcontroller actually uses.

1110 00 11010 0 0000 0000 00000000   ; MOV R0, #0

1110 00 11010 0 0001 0000 00000101   ; MOV R1, #5

1110 00 10100 0 0000 0000 00000001   ; ADD R0, R0, #1

1110 00 01010 1 0000 0000 00000001   ; CMP R0, R1

1001 10 10 111111111111111111111101  ; BNE loop (branch back 3 instructions)

How It Works:

Let's break down how the assembly version works:

1. MOV R0, #0: This initializes our counter. It moves the immediate value 0 into register R0.

2. MOV R1, #5: This sets our limit. It moves the immediate value 5 into register R1.

3. loop:: This is a label that marks the beginning of our loop. It's not an instruction, but a reference point for branching.

4. ADD R0, R0, #1: This increments our counter. It adds 1 to the value in R0 and stores the result back in R0.

5. CMP R0, R1: This compares the counter (R0) with the limit (R1). It subtracts R1 from R0 and sets flags based on the result, but doesn't store the result anywhere.

6. BNE loop: This is a conditional branch. If the previous comparison was Not Equal (NE), it jumps back to the loop label. If they were equal, it continues to the next instruction.

7. end:: Another label marking the end of our program. We don't have any instructions after this in our simple example.