Hi! Welcome to my guide to CASL/COMET II Assembly Laguage. The main reason why you'll study this is because you want to pass the Japanese Information Technology Standards Examination (JITSE)/ Philippine National Information Technology Standards (PhilNITS). Well, this guide can help you know the fundamentals. If you have difficulties learning it (after reading), I suggest that you simulate it. However, this thing requires you to have JAVA installed in your computer. If you have good background in Assembler programming, you'll easily grasp the idea as this is common problem in assembly language programming.
OK! Let's begin. But first, read the pre-requisite of this guide. I want you to study about them, I won't be spoon-feeding the ingredients. I'll just give you an insight to the fundamentals. Please study:
Bits, Nibbles, Bytes, Words, Double Words
Bit Shifts & Number Compliments
Program Logic Formulation
If you're familiar with it already, then OK. If not, I suggest you study about it.
By Richie Ryan R. Reyes, E.C.E. (Electronics and Communications Engineer)
ECE#0033195 / FE01-0084
Well, as this is just a guide I'll describe register in a way that you'll get the idea easily. In my own words, Registers are fixed variables of fixed size. They are intact, and need not to be assigned. In CASL/COMET, these registers are 1-word length. 1 word = 16 bits. Think of them as variables already defined as 16 bits length. Please refer to my example.
Bits from 0-7 are lower ordered bit and bits from 8-15 are higher order bits.
The 15th bit is the sign bit. This determines if the number is positive or negative (as per IEEE standards).
Now, these registers can contain any combinations of bits, as assigned or as modified by an instruction. Let's take this example (now you'll see why you need to be familiar with the number systems).
We then calculate it, having a value of 2^6 + 2^5 + 2^3 + 2^0.
We can represent the contents of the register in different number systems.
In binary, the contents of the register will be 0000000001101001
In decimal, the contents of the register will be 105
In octal, the contents of the register will be 151
In hexa-decimal (or hex), the contents of the register will be 0069
In CASL/COMET, we'll be using Decimal, Binary and Hexa most of the time.
These are the kinds of registers used in CASL/COMET:
GR (General Purpose Registers)
In this AL (Assembly Language), there are 8 GRs, GR0 to GR7, all of 16 bits length.
SP (Stack Pointer)
This register keeps track of the upper tier address of the stack. SP is 16-bit length.
PR (Program Register)
This register keeps the address of the next instruction. It works the same as the Instruction Pointer in other AL. PR is 16-bit length.
FR (Flag Register)
The flag register is like a status register. They are used when making conditional jumps. FR consist of 3 bits: I also mentioned this on this blog ウェブ開発者
OF (Overflow Flag)
Whenever the result of an operation exceeds the value of the register, it is set to 1. Else it is normally 0.
SF (Sign Flag)
Whenever the result of an operation makes the 15th bit 1(or could be from other operations) of the register, it is (SF) set to 1. Else it is normally 0.
ZF (Zero Flag)
Whenever the result of an operation zeroes all bits of the register, it is set to 1. Else it is normally 0.
The flag register is arranged in this manner: OF-SF-ZF
Let's go to the program Instructions.
Most of instructions will be in this format:
[Instruction] [Destination], [Source]
[Instruction] is the instruction you want to perform
[Destination] the destination regsiter
, is a separator for registers or numerical values.
[Source] is the source register or numerical value.
LD GR1, GR2 (Loads the contents of GR2 to GR1)
AND GR1, GR2 (ANDs the GR1 to GR2 and stores the result in GR1)
ASSIGNING VALUE TO REGISTER
LD - load
moves the contents of source to destination.
LD Destination, Source
|LD GR2,=1111||GR2 =0457|
|LD GR2,=1||GR2 =0001|
|LD GR2,=12||GR2 =000C|
|LD GR2,=16||GR2 =0010|
NOTE: INPUT IS DECIMAL, IT IS STORED AS THE CONVERTED NUMBER TO HEX
NOTE: IF YOU APPEND # BEFORE THE NUMBER, THE ASSEMBLER CONSIDER THE INPUT AS HEX
NOTE: SOURCE CAN BE A REGISTER, DESTINATION CANNOT BE AN IMMEDIATE VALUE
The logical Product
AND Destination, Source
RESULT: GR2 = 0001
RESULT: GR2 = 0010
NOTE: FIRST CONVERT ALL HEX TO BIN, THEN *operand* TO VALUE
THEN STORE RESULT IN GR2
LD GR2,=15 GR2 =000F
RESULT: GR2 = 0001
LAD GR2,1,GR1 ;LOAD THE CONTENTS OF GR1 AND ADD 1 THEN STORE IN GR2
NOTE: ALTHOUGH THIS IS USED TO COMPARE THE CONTENTS, TO RELATE IT BETTER WHEN IT ALTER THE FLAGS, TREAT THIS AS IF YOU'RE SUBTRACTING SOURCE FROM DESTINATION AND WILL NOT STORE THE RESULT TO THE DESTINATION.
IF IT RETURNS POSITIVE, SF = 0 AND ZF = 0;
IF IT RETURNS ZERO, SF = 0 AND ZF = 1;
IF IT RETURNS NEGATIVE, SF = 1 AND ZF = 0;
OVERFLOW FLAG (OF) IS ALWAYS ZERO, if no overflow occurred.
LOGICAL SHIFT (KASAMA UNG SIGN BIT)
SLL (Shift Left Logical)
SRL (Shift Right Logical)
ARITHMETIC SHIFT (ZERO PAG GALING SA LEFTMOST BIT, SIGN BIT FROM THE RIGHT MOST)
SLA (Shift Left Arithmetic)
SRA (Shift Right Arithmetic)
NOTE: THE VALUE OF THE LAST SHIFTED BITS WILL BE SET TO THE OVERFLOW FLAG.
GR2 = #0000
OF = 1
GR2 = #0000
OF = 0
PUSH AND POP
PUSH PLACE THE CONTENTS OF REGISTER TO STACK
PUSH 0,GR1 PUSHES VALUE OF GR1 TO STACK
PUSH 1,GR1 PUSHES VALUE OF GR1+1 TO STACK
TAKE NOTE THAT 1 IS DECIMAL AND IS CONVERTED TO BIN WHEN ADDING. SO,
IF GR1=#000E AND WE
THE RESULT IS
STACK POINTER IS DECREMENTED BY ONE. (DON'T WORRY, NDI GINAGAMIT SA FLOW UNG STACK POINTER SO YOU NEED NOT TO WORRY ABOUT TOO MUCH ADDRESSING, UNLESS YOU'RE UP MAKING EVIL THINGS LIKE VIRUSES. HOWEVER TO BECOME A CONTROL FREAK, MASTER THE MANIPULATION OF THINGS THAT CANíT BE EASILY ALTERED, LIKE INSTRUCTION POINTER OR STACK POINTER)
GR1 = #000E
(ASSUME STACK BEFORE PUSH IS @ F000.)
(STACK POINTER NOW IS AT EFFF)
VALUE OF PLACE WHERE STACK POINTER IS POINTING
POP SIMPLY TAKE THE VALUE FROM THE PRESENT STACK POINTER TO THE REGISTER
FROM THE LAST EXAMPLE, THE VALUE 002E IS BEING POINTED
STACK = EMPTY
GR1 = 000E
GR2 = 000E
ZERO FLAG : (ZF)
PAG ZERO LAHAT NG BITS, VALUE IS 1.
PAG HINDI ZERO, VALUE IS ZERO.
IN SHORT: INDICATE NYA PAG WALANG LAMAN UNG NAPAGSTOREAN.
LD GR2,=#FFFF (Zero Flag is 0, because the contents of register is not set to zero)
LD GR2,=0 (Zero Flag is 1, because the contents of register is set to zero)
GR2 = #1111
GR1 = #EEEE
ZF = 0
GR2 = #0000
GR1 = #FFFF
ZF = 1
OVERFLOW (OF) = 0 IF NO OVERFLOW, 1 IF Overflow OCCURRED
THESE OPERANDS ALWAYS SET OF=0 WHEN EXECUTED
OPERANDS WHERE SETTING IS PERFORMED
VALUE BEFORE EXECUTION IS STORED:
OF LESS IMPORTANCE (NOT USED IN FUNDAMENTAL IT EXAM DUE TO COMPLICATION)
SVC (CHECKING FOR ERROR CONTROL)
NOP (END OF OPERATION)
SP - stores the address on the top of the stack INITIALLY AT F000
push (sp ) -L 1
POP (SP) +L 1
DS (Define Storage)
DS DECLARES A VARIABLE OF FIXED WORD LENGTH, ST ASSIGNS VALUE TO A DECLARED
DS HULA 1
DC Ė EQUIVALENT OF DEFINE SA ASSEMBLER
Well, that's it. I hope you're on your way to learning CASL/COMET. The key to mastering CASL/COMET assembly is LOTS of practice!
Don't worry if you don't understand half of the stuff I talked about here. Put this thing aside and just make lots and lots
of little programs. If they don't work, debug them, even if that takes you all night or longer. Than come back to this. And don't bother trying to find help. There are only very few people who know CASL/COMET assembly, and if you can figure it out yourself you learn more.
Remember, you don't have to start coding something big, as long as you code
_something_! And CASL/COMET so far is only used in the examinations. I doubt if
it would be really used in actual programming or commissioning. Don't expect to
learn everything in this tutorial within a few days, I would say that if you can
do it in 4 months or so you are doing great.
The only good is knowledge and the only evil ignorance. - Socrates