16.1.4. Instructions for Adding and Subtracting Registers

So now, we are saying that we are designing one more Instruction called SUB M. So, it means subtraction. So, what is this Instruction this is basically nothing but Accumulator is equal to Accumulator minus contents of the Memory.

The SUB M instruction is a way for the computer to perform subtraction. When this instruction is executed, the computer takes the current value stored in the Accumulator and subtracts the value from a specific memory location from it. Therefore, if the Accumulator had a value of 10 and the memory location held a value of 3, after executing the SUB M instruction, the Accumulator would now hold the value 7.

Think of the Accumulator as a bank account balance. If you have $10 in your account and you want to subtract$3 (the amount in a piggy bank, which can be considered our memory location), you will be left with $7 in your account after the transaction.

Ok we are going to give the Instruction format is same whatever we are going to design for all the Instruction it is going to follow this particular pattern.

Every instruction in this system adheres to the same format for consistency and predictability. This means that regardless of what operation is being executed—be it addition, subtraction, or a load operation—the format will remain the same. This consistent structure helps the CPU interpret and execute instructions efficiently.

Consider how a rectangle is always defined by its length and width; regardless of the size, the way you describe it (with length and width) remains unchanged. Similarly, each instruction in our system has a defined structure that does not vary, which ensures that the computer can easily understand and execute different instructions.

So, if I say that this is your 9000 means it is going to refer to this particular Register R0.

Registers are small storage locations within a CPU that hold data temporarily. For our system, the instruction code '9000' signifies that it refers to Register R0. Thus, if '9000' is encountered by the CPU, it will look to Register R0 to get or store the required information.

Imagine registers as desks in an office. Each desk (register) has a specific identifier (R0, R1, etc.) and holds certain items (data). If someone says 'go to desk 0', you know to get or put items there, just as the CPU knows to refer to Register R0 when it processes the instruction 9000.

This Instruction is basically nothing but Accumulator is equal to Accumulator + R7.

This line describes how the Accumulator works when executing addition instructions. Specifically, it states that the value in Register R7 will be added to the current value in the Accumulator, and the result will be stored back in the Accumulator. For example, if the Accumulator previously had a value of 5 and Register R7 had a value of 2, the new value in the Accumulator will be 7 after the operation.

Consider using a counting jar. If you previously had 5 candies in the jar (the Accumulator) and you add 2 more candies from another jar (Register R7), you will count a total of 7 candies after the operation.

Now, if I am going to talk about LDA M. So, M is going to take all the 12 bit address. This is your 2^twelve; that means, 4096 Memory space.

This section discusses the addressing capability of instructions like LDA M when compared to register-related operations. LDA M can access 4096 different memory addresses (because 2^12 = 4096), while the register operations can only use 8 different registers (from R0 to R7). This exemplifies how memory gives a much larger pool of data to work with compared to limited registers.

Imagine a library. The memory is like the entire library, which has numerous books (4096) on different subjects. However, the registers are like just a few special bookshelves (8) where only specific types of books can be stored. While the shelves can hold only a few books, the entire library can hold many more.

So, what will happen we are having one increment operation and one decrement operation we can increment the value of my Register or Memory or we can decrement the value of my Memory or Register.

The incrementation and decrementation instructions allow the computer to add or subtract 1 from a specific memory or register value. For instance, if we have a register holding the value 10 and we execute an increment instruction, the value will increase to 11. Conversely, if we execute a decrement instruction, it will reduce from 10 to 9.

Think of a scoreboard. If the score is currently at 10 points and you 'increment' by one point for a successful play, the new score becomes 11 points. Alternatively, if there's a penalty and you 'decrement' the score by one point, the score shifts down to 9 points.

So, instead of doing it what generally we used to do we are going to put special circuit over here which is going to increment it or decrement it.

In digital circuits, special arrangements called counters can perform increment and decrement operations without disturbing other values in the system. Instead of adding or subtracting directly in the Accumulator, the processor uses a counter to maintain the incremented or decremented value efficiently.

Consider a set of stairs. If you are trying to keep track of how many steps you have taken (the counter), instead of erasing numbers from a log book (the Accumulator each time you step, you just add to the counter whenever you go up or down the stairs. This way, the original log remains intact while the counter adjusts.

Now here I am saying that opcode 0 is your JMP. It is a jump Instruction.

Control instructions dictate how the CPU should move during the execution of a program. The JMP (jump) instruction allows the program to skip to different parts of the code, which is crucial for controlling the flow of the program based on conditions set in the instructions.

Think of a recipe. If a recipe instructs you to skip certain steps depending on previous outcomes (like 'if the sauce is too thick, skip to step 6'), those instructions are akin to jump instructions in a program. They guide when and where to go next in the flow of tasks.

--