0000 ORG 0 ; PROGRAM START ADDRESS

0000 31FF13 LXI SP, RAMAD ; STACK DEFINITION

0003 3E98 MVI A, 98H ; CONTROL WORD FOR 8255,
0005 D317 OUT CONWO
0007 0600 NBU: MVI B, 0 ; RESET COUNTER

COUNTER=$0004, PC=$0005, SP=$13FF, A=$98, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Ejecucin de la instrucin $0005 OUT CONWO

Ciclo de Fetch de la instruccin $0005 OUT CONWO

Buffer_direcc PC ($0005)
Bus_ADR Buffer_direcc ($0005)
BUS_CONTROL MEMR
BUS_DATA MEM[BUS_ADR] ( $D3) ; Lectura de memoria
BUS_INT BUS_DATA ( $D3)
RI BUS_INT ( $D3) ; Opcode de OUT ( $D3) en RI
Counter PC ($0005)
Counter Counter+#Bytes_INT; incremento en #Bytes ( Decodif de RI )
PC Counter ($0007)
Counter Counter-#Bytes_INT ; $0007 - 2
Counter Counter+1 ; $0005+1

COUNTER=$0006, PC=$0007, SP=$13FF, A=$98, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00
microprocesadores, clase N3 1
 0000 ORG 0 ; PROGRAM START ADDRESS
0000 31FF13 LXI SP, RAMAD ; STACK DEFINITION
0003 3E98 MVI A, 98H ; CONTROL WORD FOR 8255,
0005 D317 OUT CONWO
0007 0600 NBU: MVI B, 0 ; RESET COUNTER

COUNTER=$0006, PC=$0007, SP=$13FF, A=$98, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Ciclo de ejecucin de la instruccin $0005 OUT CONWO

Buffer_direcc Counter ($0006)

Bus_ADR Buffer_direcc ($0006)
BUS_CONTROL MEMR
BUS_DATA MEM[BUS_ADR] ( $17) ; Lectura de memoria
BUS_INT BUS_DATA ( $17)
BUS_ADR BUS_INT ( $17) ; 2 Byte en BUS_ADR
BUS_INT A ( $98)
BUS_DATA BUS_INT ( $98)
BUS_CONTROL IO_W
PORT [BUS_ADR] ( $98) ; PORT [$0017] = $98

COUNTER=$0006, PC=$0007, SP=$13FF, A= $98, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

La ejecucin de la instruccin $0005 genero la occin de escribir el contenido del registro A ( $98)
en la puerta cuya direccin ($0017 CONWO ) es el segundo Byte de la instruccin. El PC ( $0007)
apunta a la siguiente instruccin a ejecutar. Obs, en la direccin de la puerta solo se consideran
los 8 bits menos significativos por que las puertas son solo 256.
microprocesadores, clase N3 2
 Programa en assembler
ADR CONT LABEL NEM OPER COMENTARIO

0000 ORG 0 ; PROGRAM START ADDRESS

0000 31FF13 LXI SP, RAMAD ; STACK DEFINITION
0003 3E98 MVI A, 98H ; CONTROL WORD FOR 8255,
0005 D317 OUT CONWO
0007 0600 NBU: MVI B, 0 ; RESET COUNTER
0009 DB14 IN LB ; FETCH LIGHT BARRIERS
000B E603 ANI 3 ; MASK D0, D1
000D FE03 CPI 3 ; MEASURING PATH FREE?
000F C20700 JNZ NBU ; NOT BOTH UNBROKEN
0012 DB14 LBU: IN LB
0014 E6 01 ANI 1
0016 C21200 JNZ LBU ; LEFT LB STILL UNBROKEN?
0019 04 RBU: INC B ; INCREMENT COUNTER
001A CD2A00 CALL WAIT ; TIME LOOP (e.g. adjustable to 1 ms)
001D DB14 IN LB
001F E602 ANI 2 ; MASK RIGHT BARRIER
0021 C2100 JNZ RBU ; RIGHT LB UNBROKEN ?
0024 78 MOV A, B
***************************************************************Convert to speed
0025 D315 OUT DISP ; OUTPUT COUNT IN HEX
0027 C30700 JMP NBU ; RETURN TO START PROGRAM
*************************Subroutine time loop (approx 255 x 15 clock cycles)
002A 0EFF WAIT: MVI C, 0FFH ; TIME LOOP
002C OD LOOP: DCR C
002D C22C00 JNZ LOOP
0030 C9 RE T
********************Assignment of values to the symbolic address
0017 CONWO: EQU 17H ; CONTROL PORT 8255
0014 LB: EQU 14H ; INPUT PORT A
0015 DISP: EQU 15H ; OUTPUT PORT B
0013 RAMAD: EQU 13FFH ; HIGHEST RAM ADDRESS, BEGINNING OF STACK
0000 END

microprocesadores, clase N3 3
 Modificacin de Flags y uso de Stack

Para analizar el efecto de las instrucciones en los Flags, se asume

un valor arbitrario en el Registro A y se ejecuta la instruccin
$000B ANI $03

Posteriormente para analizar el manejo del Stack se ejecuta la

instruccin $001A CALL WAIT

Finalmente se analiza la instruccin $0030 RET

microprocesadores, clase N3 4
 000B E603 ANI 3 ; MASK D0, D1
000D FE03 CPI 3 ; MEASURING PATH FREE?
000F C20700 JNZ NBU ; NOT BOTH UNBROKEN

COUNTER=$0002, PC=$0003, SP=$13FF, A=$9F, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Ejecucin de la instrucin $000D CPI 3

Ciclo de Fetch de la instruccin $000D CPI 3

Buffer_direcc PC ( $000D)
Bus_ADR Buffer_direcc ($000D)
BUS_CONTROL MEMR
BUS_DATA MEM[BUS_ADR] ( $FE ) ; Lectura de memoria
BUS_INT BUS_DATA ( $FE)
RI BUS_INT ( $FE) ; Opcode de CPI ( $FE) en RI
Counter PC ($000D)
Counter Counter+#Bytes_INT; incremento en #Bytes ( Decodif de RI )
PC Counter ($000F)
Counter Counter-#Bytes_INT ; $000F - 2
Counter Counter+1 ; $000D+1

COUNTER=$000E, PC=$000F, SP=$13FF, A=$9F, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

microprocesadores, clase N3 5
 000B E603 ANI 3 ; MASK D0, D1
000D FE03 CPI 3 ; MEASURING PATH FREE?
000F C20700 JNZ NBU ; NOT BOTH UNBROKEN
0012 DB14 LBU: IN LB

COUNTER=$000E, PC=$000F, SP=$13FF, A=$03, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Ciclo de ejecucin de la instruccin $000D CPI

Buffer_direcc Counter ($000E)

Bus_ADR Buffer_direcc ($000E)
BUS_CONTROL MEMR
BUS_DATA MEM[BUS_ADR] ( $03) ; Lectura de memoria
BUS_INT BUS_DATA ($03)
REG_AUX BUS_INT ( $038) ; 2 Byte en registro auxiliar (ALU)
ALU (RESTAR) Rag A Reg Aux ; Resta en la ALU, resultado en BUS Interno y FLAGs
el resultado es igual a 0 pero no se carga, adems se modifica el Flag Zero
res =0 entonces Zero = Verdadero = 1

COUNTER=$000E, PC=$000F, SP=$13FF, A=$03, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Al concluir la ejecucin de la instruccin $000D CPI, el nico resultado que se puede percibir est en el
Flag Z ( Z igual a 1), en la siguiente instruccin (000F JNZ NBU ) se cumple que Z=verdadero (1 ),
por lo tanto NZ (Not Z ) es Falso, entonces, como no se cumple la condicin no se ejecutar un salto a
NBU ( $0007), la prxima instruccin a ejecutarse ser: 0012 DB14 LBU: IN LB
microprocesadores, clase N3 6
 Llamada a una subrutina
001A CD2A00 CALL WAIT ; TIME LOOP (e.g. adjustable to 1 ms)
001D DB14 IN LB

COUNTER=$0019, PC=$001A, SP=$13FF, A=$00, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Ejecucin de la instrucin $001A CALL WAIT

Ciclo de Fetch de la instruccin $001A CALL WAIT

Buffer_direcc PC ($001A)
Bus_ADR Buffer_direcc ($001A)
BUS_CONTROL MEMR
BUS_DATA MEM[BUS_ADR] ( $CD) ; Lectura de memoria
BUS_INT BUS_DATA ( $CD)
RI BUS_INT ( $CD) ; Opcode de CALL ( $CD) en RI
Counter PC ($001A)
Counter Counter+#Bytes_INT; incremento en #Bytes ( Decodif de RI )
PC Counter ($001D)
Counter Counter-#Bytes_INT ; $001D - 3
Counter Counter+1 ; $001A+1

COUNTER=$001B, PC=$001D, SP=$13FF, A=$00, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Al final del Fetch, el PC ( $0019) apunta a la direccin de memoria que tiene el Opcode ( $DB) de la
siguiente Instruccin, por su parte, Counter ($0019) apunta al segundo Byte de la actual instruccin
( $2A).
microprocesadores, clase N3 7
001A CD2A00 CALL WAIT ; TIME LOOP (e.g. adjustable to 1 ms)
001D DB14 IN LB

COUNTER=$001B, PC=$001D, SP=$13FF, A=$98, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Ciclo de ejecucin de la instruccin $001A CALL WAIT

SP SP-1 ; decremento del Stack SP ($13FE)

Buffer_direcc SP ($13FE)
Bus_ADR Buffer_direcc ($13FE)
BUS_INT PC_HI ( $00 ) ; 8 bits mas significativos del PC
BUS_DATA BUS_INT ( $00 )
BUS_CONTROL MEMW ; Escritura de memoria, PC_HI al STACK

SP SP-1 ; decremento del Stack SP ($13FD)

Buffer_direcc SP ($13FD)
Bus_ADR Buffer_direcc ($13FD)
BUS_INT PC_LOW ( $1D) ; 8 bits menos significativos del PC
BUS_DATA BUS_INT ( $1D)
BUS_CONTROL MEMW ; Escritura de memoria PC_LOW al STACK

COUNTER=$001B, PC=$001D, SP=$13FD, A=$98, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

En este punto el PC es almacenado en el Stack, el Stack Pointer ha sido decrementado en 2 , por

lo tanto se puede decir que la direccin de retorno de la subrutina est almacenada en el Stack

microprocesadores, clase N3 8
001A CD2A00 CALL WAIT ; TIME LOOP (e.g. adjustable to 1 ms)
001D DB14 IN LB

COUNTER=$001B, PC=$001D, SP=$13FF, A=$98, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Ciclo de ejecucin de la instruccin $001A CALL WAIT ; Continuacin

Buffer_direcc Counter ($001B)

Bus_ADR Buffer_direcc ($001B)
BUS_CONTROL MEMR
BUS_DATA MEM[BUS_ADR] ( $2A ) ; Lectura de memoria
BUS_INT BUS_DATA ( $2A)
PC_LOW BUS_INT ( $2A) ; 2 Byte Instruccin en PC_LOW, 8 BITS LSB
Counter Counter+1 ($001B+1)
Buffer_direcc Counter ($001C)
Bus_ADR Buffer_direcc ($001C)
BUS_CONTROL MEMR
BUS_DATA MEM[BUS_ADR] ($00 ) ; Lectura de memoria
BUS_INT BUS_DATA ($00)
PC_HI BUS_INT ($00) ; 3 Byte Instruccin en PC_HI, 8 BITS MSB

COUNTER=$001B, PC=$002A, SP=$13FD, A=$98, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Al concluir la ejecucin de la instruccin CALL WAIT , en el Stack est almacenada la direccin de

retorno ($001D) y el PC ($002A)apunta a la direccin de la subrutina

microprocesadores, clase N3 9
 Retorno de una subrutina
002D C2C00 JNZ LOOP
0030 C9 RET ;

COUNTER=$002C, PC=$0030, SP=$13FD, A=$00, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Ejecucin de la instrucin $0030 RET

Ciclo de Fetch de la instruccin $0030 RET

Buffer_direcc PC ( $0030)
Bus_ADR Buffer_direcc ($0030)
BUS_CONTROL MEMR
BUS_DATA MEM[BUS_ADR] ( $C9 ) ; Lectura de memoria
BUS_INT BUS_DATA ( $C9)
RI BUS_INT ( $C9) ; Opcode de RET ( $C9) en RI
Counter PC ($0003)
Counter Counter+#Bytes_INT; incremento en #Bytes ( Decodif de RI )
PC Counter ($0031)
Counter Counter-#Bytes_INT ; $0031 - 1
Counter Counter+1 ; $0030+1

COUNTER=$0031, PC=$0031, SP=$13FD, A=$00, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

microprocesadores, clase N3 10
002D C2C00 JNZ LOOP
0030 C9 RET ;

COUNTER=$0031, PC=$0031, SP=$13FD, A=$98, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00

Ciclo de ejecucin de la instruccin $0030 RET

Buffer_direcc SP ($13FD)
Bus_ADR Buffer_direcc ($13FD)
BUS_CONTROL MEMR
BUS_DATA MEM[BUS_ADR] ( $1D ) ; Lectura de memoria (STACK)
BUS_INT BUS_DATA ( $1D)
PC_LOW BUS_INT ( $1D) ; PC_LOW recuperado desde el Stack

SP SP+1 ($13FD+1) ; Se incrementa el Stack Pointer SP ($13FE)

Buffer_direcc SP ($13FE)
Bus_ADR Buffer_direcc ($13FE)
BUS_CONTROL MEMR
BUS_DATA MEM[BUS_ADR] ( $00) ; Lectura de memoria (STACK)
BUS_INT BUS_DATA ( $00)
PC_HI BUS_INT ( $00) ; PC_HI recuperado desde el Stack
SP SP+1 ($13FE+1) ; Se incrementa el Stack Pointer SP ($13FF)

COUNTER=$001B, PC=$001D, SP=$13FF, A=$98, B=$00, C=$00, E0=$00, D=$00, H=$00, L=$00
microprocesadores, clase N3 11
El PC es recuperada desde el Stack, el Stack Pointer ha sido incrementado 2. El Stack tiene la