[pre]
STATE_TABLE:
DW MAIN_STATE_0 ; pointer to State 0 routine
DW MAIN_STATE_1 ; pointer to State 1 routine
DW MAIN_STATE_2 ; pointer to State 2 routine
DW MAIN_STATE_3 ; pointer to State 3 routine
STATE_CNT EQU ($ - STATE_TABLE)/2 ;number of states
[/pre]

The '$' symbol means the current address. For example if STATE_TABLE was at address 2000h then $ = 2000h + 8 = 2008h. Each DW (define word allocates two bytes of code space). So STATE_CNT = 2008h - 2000h / 2 = 4. STATE_CNT is an abreviation for state count, ie the number of states. If you added DW MAIN_STATE_4, the assembler calculate STATE_CNT to equal 5 and so on.



[pre]
MOV R0, #SwitchStates ; clear all switch states to 0
MOV R2, #8
SwStInit:
MOV @R0, #0
INC R0
DJNZ R2, SwStInit
[/pre]

Why does the programmer not just move zeroes to the bytes? This code is more generic - if you make a change as in add more switches etc the assembler makes the changes for you. It is a little more work up front, but makes the code easier to maintain.


[pre]
MOV A, SwitchNo ; fetch the state for the current
ADD A, #SwitchStates ; switch
MOV R0, A
MOV A, @R0
[/pre]

Ok, we're indexing a table here. SwitchNo is the current switch we're processing, SwitchStates is the table in memory where the states for each switch is stored. In 'c' this would be something like a = SwitchStates[SwitchNo];

For switch 0, the address would be SwitchStates+0
For switch 1, the address would be SwitchStates+1
For switch 2, the address would be SwitchStates+2
and so on.

So we calculate the address we want to read by #Switchstates which is the address of the table (note #) and add the SWitchNo as each entry is one byte. This address is put into R0,and the mov a,@r0 reads from that address thus retrieving the state value we want.

SWT_MSK translates to 'switch mask' - we give it a bit value (0..7) and it returns us a mask value with the bit number set - for bit 0 it returns us 1, for bit 7 it returns us 80h. We use this value 'anded' with the port value to isolate the switch bit we want to look at. The result after the 'and' is either zero or non-zero.


FIVE_SEC_CNT (five second count) equals 5 * 100 = 500 - the assembler does the calculation for you. If each timer tick is 10mS there is 100 * 10mS per second. This value is obviously a word value (byte only is 0 -255) so the HIGH and LOW operators get the high or low byte of the word value.



Shifting left multiplies the value by 2. Shifting right divides by two. Think of the binary sequence : 1,2,4,8,16....



The Switchcounters table is a word table (two bytes for each entry) so +0 is the high byte, +1 is the low byte



The description of the routine tells you exactly what it does. The DPTR is loaded with the address of a table of word addresses. A has the index into this table. The routine figures out which jump address from the table to use,pushes this address onto the stack then does a RET which effectively jumps to that address. You will see STATE_TABLE has 4 routines it can jump to: MAIN_STATE_0...3. Therefore A can only have the value 0..3 when passed to CALL_Table. Put simply, if you call CALL_TABLE with DPTR loaded with STATE_TABLE and A = 0, then you will jump to MAIN_STATE_0, if A= 3 you jump to MAIN_STATE_3


Hopefully this answers all your questions. Again, a step through with the simulator would have told you all this.

This code does a lot of indexing that can be confusing for a beginner. The code was written to be flexible as well as understandable. The techniques used are very common. I had not seen this code before and was able to understand what it was supposed to do, so therefore the code was written in a manner that is easily maintainable. This is what professional programmers such as myself are paid to do!