DEV...ELeferno

tady se pracuje. Kurva, fakt těžce se tu pracuje. Ale už to mám skoro hotový.Lz.

Tato část textu bude zajímavá zřejmě pouze pro opravdové úchyly, jimž ovšem poskytne očekávané potěšení (Lz)

math.asm

main.asm

 

wait.asm

main-debug.inc

set-shared.inc

vars.inc


; main.asm - EMS
; xtal = 24MHz, instr 0.5us
;
; Changes:
;

#include "main-debug.inc"
#include "set-shared.inc"
#include "iLCD.inc"
#include "vars.inc"


.macro Led1On
clr Led1
.endm
.macro Led1Off
setb Led1
.endm
.macro Led2On
clr Led2
.endm
.macro Led2Off
setb Led2
.endm
.macro Led3On
clr Led3
.endm
.macro Led3Off
setb Led3
.endm



#define cFreqNum 10000
#define cldTH1 100 // 0.1ms * 100 = 10ms
// cykl r7

.using 0
.Data
; for int driving
tPinOnL: .ds.b 1 ; time pin active
tPinOnH: .ds.b 1
tPinOffL: .ds.b 1 ; time pin nonactive
tPinOffH: .ds.b 1
reTH0: .ds.b 1 ; reload var
ldTH0: .ds.b 1 ; payload for TH0
extraTH0: .ds.b 1 ; extra register for timer 0


tBurstOn: .ds.b 1 ; burst length (* base)
tBSpace: .ds.b 1 ; space between bursts
reTL1: .ds.b 1 ; reload var
reTH1: .ds.b 1 ; reload var
extraTH1: .ds.b 1

actMenu: .ds.b 1 ; active menu index
tBBase: .ds.b 1 ; timer base for burst (0.1s , 1s)

.bdata
;btmp: .ds.b 1
.bitdata
isEnabledOut: .ds.b 1
isPinOn: .ds.b 1
isRandEn: .ds.b 1

randReq: .ds.b 1 ; random - request
.ibss
Stack: .ds.b 30

.Text
ljmp reset
.org 0x03
reti
.org 0x0B ; timer 0
ljmp PinService
.org 0x13
reti
.org 0x1B ; timer 1
ljmp BurstService
.org 0x23
reti
.org 0x2B ; timer 2
reti

.ascii "===* EMS v0.47 *==="
reset:
mov p0,#0xFE
mov p1,#0xFF
mov p2,#0xFF
mov p3,#0xFF

mov sp,#Stack-1

lcall iLCDInit
lcall iCurHome

clr isPinOn
mov tPinOnL,#6 ; 0.1m * 6 = 600us
mov tPinOnH,#0 ; 1-1 = 0
mov tPinOffL,#130 ; 0.1m * 130 = 13m
mov tPinOffH,#0 ;
mov tBurstOn,#1 ; 0.1s
mov tBSpace,#0 ; off
mov tBBase,#10 ; * 10ms = 100ms


; set timer T0
mov tl0,#(256-200) ; 0.5*200=100us=0.1m
mov th0,#(256-200) ; auto-reload

mov a, tPinOffL
mov reTH0, a
mov ldTH0, a
mov extraTH0, tPinOffH
inc extraTH0

; set timer T1
mov tl1,#(256-200) ; 0.5*200=100us=0.1m
mov th1,#(256-200) ; 0.5*200=100us=0.1m
; mov rcap2l,#(256-200) ; 100us
; mov rcap2h,#(256-100) ; 10ms
mov reTH1,tBBase ; 100ms

setb isEnabledOut
clr isRandEn ; disable random
clr randReq

;;;;;;;;;; USART init ;;;;;;;;;;;;;
;;;;;;;; 24 MHZ xtal , 9k6 bps,8 bits,bez parity
;; tl1 = th1 =256 - (fosc*2^SMOD) / (32*12*bps)
; mov tl1,#243
; mov th1,#243

mov pcon,#0B10000000
mov scon,#0B01010000
mov tmod,#0B00100010 ; mode2,mode2

; t1, t0,i1,i0
; mov tcon,#0B00010101 ; zastaveny vzorkovani
; mov tcon,#0B01000101 ; zastaveny snet
mov tcon,#0B01010101
; mov T2CON,#0b00000100 ; enable timer2 autoreload
; mov T2MOD,#0b00 ; timing up
mov ip, #0B10000010
mov ie, #0B00001010 ; t1,t0 on , global off

;================================== MAIN start =======================================
; lcall ShowRandQ
; lcall ShowFreq
; lcall ShowBurst
; lcall ShowBurstBase

setb EA
clr actMenu
ljmp keymenu
main:
Led1Off
jb pinKey1Up,1f
ljmp key1up
1: jb pinKey1Down,1f
ljmp key1down
1: jb pinKey2Up,1f
ljmp key2up
1: jb pinKey2Down,1f
ljmp key2down
1: jb pinKeyMenu,1f
ljmp keymenu
1:
jbc randReq, generateRND

inc rand8reg ; set random nums
ljmp main
generateRND:
jnb isRandEn,1f
lcall rand8
mov tBSpace, a
1:
ljmp main
keywait:
mov r7,#2
lcall Wait005s
; Led1Off
ljmp main
;================================== MAIN end ===================================
keymenu:
; wait for release
2: jnb pinKeyMenu,2b

mov a, actMenu
inc a
; anl a,#1
mov actMenu, a

; menu 0 - freq
jnz 1f
lcall ShowFreq
ljmp main
1:
; menu 1 - burst
cjne a,#1,1f
lcall ShowBurst
ljmp main
1:
; menu 2 - random
cjne a,#2,1f
lcall ShowRandQ
ljmp main
1:
; menu 3 - burst base
cjne a,#3,1f
lcall ShowBurstBase
ljmp main
1:
; unknown menu - set 0
clr actMenu
; dec actMenu
ljmp keymenu


key1up:
Led1On
mov a, actMenu
; menu 0 func
jnz 1f
lcall IncPinOn
lcall ShowFreq
ljmp keywait
1:
; menu 1 func
cjne a,#1,1f
inc tBurstOn
lcall ShowBurst
ljmp keywait
1:
; menu 2 func
cjne a,#2,1f
setb isRandEn
lcall ShowRandQ
ljmp keywait
1:
; menu 3 func
cjne a,#3,1f
mov tBBase,#5
lcall ShowBurstBase
ljmp keywait
1:
ljmp main

key1down:
Led1On
mov a, actMenu
; menu 0 func
jnz 1f
lcall DecPinOn
lcall ShowFreq
ljmp keywait
1:
; menu 1 func
cjne a,#1,1f
dec tBurstOn
lcall ShowBurst
ljmp keywait
1:
; menu 2 func
cjne a,#2,1f
clr isRandEn
lcall ShowRandQ
ljmp keywait
1:
; menu 3 func
cjne a,#3,1f
mov tBBase,#10
lcall ShowBurstBase
ljmp keywait
1:
ljmp main
key2up:
Led1On
mov a, actMenu
; menu 0 func
jnz 1f
lcall IncPinOff
lcall ShowFreq
ljmp keywait
1:
; menu 1 func
cjne a,#1,1f
inc tBSpace
lcall ShowBurst
ljmp keywait
1:
; menu 3 func
cjne a,#3,1f
mov tBBase,#100
lcall ShowBurstBase
ljmp keywait
1:

; other
ljmp main
key2down:
Led1On
mov a, actMenu
; menu 0 func
jnz 1f
lcall DecPinOff
lcall ShowFreq
ljmp keywait
1:
; menu 1 func
cjne a,#1,1f
dec tBSpace
mov a, tBSpace
jnz 2f
setb isEnabledOut
2:
lcall ShowBurst
ljmp keywait
1:
; menu 3 func
cjne a,#3,1f
mov tBBase,#200
lcall ShowBurstBase
ljmp keywait
1:

; other
ljmp main

;----------------------------
ShowBurstBase:
lcall iClearDisp

mov a,#ciLCDLine1
lcall iSetPos
mov dptr,#tBBase1
lcall iCPrint
mov a,#ciLCDLine2
lcall iSetPos
mov dptr,#tBBase2
lcall iCPrint

mov a, tBBase
lcall Print8Num
ret
;----------------------------
ShowRandQ:
lcall iClearDisp

mov a,#ciLCDLine1
lcall iSetPos
mov dptr,#tRand1
lcall iCPrint
mov a,#ciLCDLine2
lcall iSetPos
mov dptr,#tRand2
lcall iCPrint

jb isRandEn,1f
mov dptr,#tNo
lcall iCPrint
ret
1:
mov dptr,#tYes
lcall iCPrint
ret
;----------------------------
ShowBurst:
lcall iClearDisp
mov a,#ciLCDLine1
lcall iSetPos
mov dptr,#tBurst1
lcall iCPrint

mov a, tBurstOn
lcall Print8Num

mov a,#ciLCDLine2
lcall iSetPos
mov dptr,#tBurst2
lcall iCPrint

mov a, tBSpace
; dec a ;; ne!
lcall Print8Num

ret
ShowFreq:
.using 0
lcall iClearDisp
mov a,#ciLCDLine1
lcall iSetPos
mov dptr,#tTsum
lcall iCPrint

; 1/(0.0001*T) = (1 / 0.0001) * (1 / T) = 10000 * 1 / T = f [Hz]
mov ren1, tPinOnL
mov ren2, tPinOnH
mov ren3, tPinOffL
mov ren4, tPinOffH
lcall add16to16

mov ren1, ar4
mov ren2, ar5
; mov re2,dil // re2 = ren3 = dil
; mov re3,dih // re3 = ren4 = dih
lcall bin_bc
; out
lcall PrintNum

mov dptr,#tFreq
lcall iCPrint

mov dil,ar2 ; ren1
mov dih,ar3 ; ren2
mov DL,#LOW(cFreqNum)
mov DH,#HIGH(cFreqNum)
lcall div16x16
; out: dih,dil : DH,DL


; mov re2,dil // re2 = ren3 = dil = r4
; mov re3,dih // re3 = ren4 = dih = r5
lcall bin_bc
; out
lcall PrintNum

mov a,#ciLCDLine2
lcall iSetPos
mov dptr,#tTon
lcall iCPrint

mov re2, tPinOnL
mov re3, tPinOnH
lcall bin_bc
; out
lcall PrintNum

ret
;----------------------------------------

PrintNum: ; tmp,re3,re2
; mov a,tmp
anl a,#0x0F
add a,#'0'
lcall iPutch

mov a, re3
swap a
anl a,#0x0F
add a,#'0'
lcall iPutch

mov a, re3
anl a,#0x0F
add a,#'0'
lcall iPutch

mov a, re2
swap a
anl a,#0x0F
add a,#'0'
lcall iPutch

mov a, re2
anl a,#0x0F
add a,#'0'
lcall iPutch
ret
;----------------------------------------
Print8Num: ; in: acc
mov b,#100
div ab
jz 1f
add a,#'0'
lcall iPutch
1:
mov a, b
mov b,#10
div ab
add a,#'0'
lcall iPutch

mov a, b
add a,#'0'
lcall iPutch
ret
;------------------------------------------
IncPinOn:
inc tPinOnL
mov a, tPinOnL

#ifdef TON_16BIT
jnz 1f
inc tPinOnH
1:
#End If
ret
DecPinOn:
mov a, tPinOnL
#ifdef TON_16BIT
jnz 1f
mov a, tPinOnH
jz 2f
dec tPinOnH
1:
#Else
jz 2f
#End If
dec tPinOnL
2:
ret
IncPinOff:
inc tPinOffL
mov a, tPinOffL
jnz 1f
inc tPinOffH
1:
ret
DecPinOff:
mov a, tPinOffL
jnz 1f
mov a, tPinOffH
jz 2f
dec tPinOffH
1:
dec tPinOffL
2:
ret

;======================= Interrupt Service ==================================
BurstService:
; call every 0.1ms
push psw
clr TF2

djnz reTL1, bsExit
mov reTL1,#100 ; 0.1ms * 100 = 10ms

djnz reTH1, bsExit
mov reTH1,tBBase ;

djnz extraTH1, bsExit
; preselected interval
jb isEnabledOut,2f
; enable out
setb isEnabledOut
Led3On
mov extraTH1, tBurstOn
ljmp bsExit
2:
; disable out
push acc
setb randReq
mov a, tBSpace
jz alwayson
clr isEnabledOut
clr isPinOn
clr pinDrive
Led3Off
dec a
alwayson:
inc a ; 0 -> 1 pro rychlejsi reakci
mov extraTH1, a
pop acc

bsExit:
pop psw
reti
;--------------------------------------------------------
PinService:
; called every 0.1ms = 100us
push psw

jnb isEnabledOut,psExit ; output disabled

djnz reTH0, psExit
; mov reTH0,ldTH0 ; nesmim reload!
djnz extraTH0,psExit ; jump if not zero
;; is time to cpl
push acc
jb isPinOn,1f
mov a, tPinOnL
mov reTH0, a
mov ldTH0, a
mov extraTH0, tPinOnH
inc extraTH0

setb isPinOn
setb pinDrive
Led2On

pop acc
ljmp psExit
1:
mov a, tPinOffL
mov ldTH0,a ; inverzni (inkrementuje)
mov reTH0, a
mov extraTH0, tPinOffH
inc extraTH0

clr isPinOn
clr pinDrive
Led2Off

pop acc
psExit:
pop psw
reti

// 1234567890123456
tTsum: .ascii "T:\0"
tFreq: .ascii ",f:\0"
tTon: .ascii "Ton[100us]:\0"

tBurst1: .ascii "Bon: \0"
tBurst2: .ascii "Boff: \0"

tRand1: .ascii "Enable random\0"
tRand2: .ascii "Boff? \0"

tYes: .ascii "Yes\0"
tNo: .ascii "No\0"

tBBase1: .ascii "Select B timer\0"
tBBase2: .ascii "base: \0"


;================================== END of FILE ================================
#include "vars.inc"

.Global add16to16
.Global div16x16
.Global bin_bc
.Global rand8
.Global rand8reg

.Data
rand8reg: .ds.b 1
.Text
;*********************************************
; addition 16b + 16b - result 16b
; quick - 8 cycles of processor
; code size - 7 byte
;*********************************************
;Input in ren2 is byte_H , ren1 is byte_L of first addend -m1
; in ren4 is byte_H , ren3 is byte_L of second addend -m2
;in ren4 is so m2H, in ren3 - m2L, ren2 - m1H , ren1 -m1L
;
;output in ren4 is byte_H , ren3 is byte_L of sum
;in flag Cy may be overflow
; to change registers: Psw,ren3,ren4
; possibility to change work. registers **********
;*
******
add16to16:
xch a,ren3 ;m2L <-> acc
Add a, ren1
xch a,ren4 ;m2H <-> result of Lbytes sum
addc a, ren2
xch a,ren4 ;result of Lbytes sum <-> result of Hbytes sum
xch a,ren3 ;acc <-> result of Lbytes sum
ret
;*******


;*********************************************
; division 16b / 16b unsigned
;time of executive - min 7 cycles of processor for div by 0
; - w/w max 39 cycles of processor
; - w/B max 143 cycles of processor
; - B/B max 27 cycles of processor
; - average 70 cycles of processor
; code size (8051) - 93 byte
;*********************************************
;input in DH is byte_H and in DL is byte_L of dividend
;input in dih is byte_H and dil is byte_L of divisor
;output Cy =1 for div by 0, other Cy =0 and
; in DH is byte_H and in DL is byte_L - of remainder
; in dih is byte_H and in dil is byte_L - of quotient (the result)
;
; to change registers: Acc,DH,DL,dH,dL,b,Psw
; possibility to change work. registers **********
;*******
div16x16:
cjne dih,#0,divAA
cjne dil,#0,divBA
setb c
ret ;divide by 0
divAA:
mov a, DH
mov b, dih
div ab
jnz divAB ;result has H_byte
mov dih, a
mov dil, a
ret ;divide finalised, result=0
divAB:
push b ;store remainder
mov DH,a ;defer result_L in rp
mov b, dil
mul ab
xch a, DL
subb a, DL
xch a, DL
pop acc
subb a, b
jnc divABcont ;result positive, no correction
dec DH
xch a, DL
Add a, dil
xch a, DL
addc a, dih
clr c
divABcont:
xch a, DH
mov dil, a
mov dih,#0
ret ;divide finalised
divBA:
mov b, dil
mov a, DH
div ab
mov dih,a ;store H_result
mov DH,b ;a new value of DH
cjne DH,#0,divBB
mov b,dil ;divide byte/byte
mov a, DL
div ab
mov dil, a
mov DL, b
ret
divBB:
mov DH,#8 ;divide word/byte
divBB1:
mov a,DL // the shorted improved Booth's loop
rlc a
mov DL, a
mov a, dil
xch a, b
rlc a
jc divBB2 ;for divisors > 7FH
div ab
rrc a
djnz DH, divBB1
mov a, b
xch a,DL ;remainder -> DL, intermediate result_L-> acc
rlc a
mov dil, a
ret
divBB2: clr c
subb a, b
mov b, a
djnz DH,divBB1 ;a possibly end for divisors > 7FH
mov a, b
xch a,DL ;remainder -> DL, intermediate result_L-> acc
rlc a
mov dil, a
ret
;*******

;*********************************************
; konverze bin -> BCD pro rozsah čísla do 65 535
; superrychlé - max 84 cyklů procesoru
; rozsah kodu (8051) - 85 byte
;*********************************************
;vstup v re3 je udaj_H a re2 je udaj_L
;vystup v re3 je tis_sta a re2 je des_jed
; v acc desítky tisíc
;
; mění reg.: Acc,re2,re3, psw
; možnost zvolit prac registry******
;*******

bin_bc:
push B ;odlož obsah B
mov a, re3
clr c
rrc a ;vydělí re3 číslem 2 = posune o 1 doprava
xch a,re2 ;re2->acc, re3/2 ->re2
rrc a ;vydělí re2 číslem 2, b0 re2->C
mov f0,C ;bit0 z re2 schové do f0
xch a,re2 ;re2/2->re2 , re3/2->acc
clr c
rrc a ;vydělí re3/2 číslem 2 = posune o 1 doprava
xch a,re2 ;re2/2->acc, re3/4 ->re2
rrc a ;vydělí re2/2 číslem 2, b1 re2->Cy
push psw ;odloží b1 re2 do Cy
xch a,re2 ;re3/4->acc, re2/4 ->re2
mov re3,a ;re3/4 -> re3
mov b,#06
mul ab
add a,re2 ;připočte re2/4
xch a,b ;bajt_H ->acc , bajt_L -> b
addc a,#0
jz correct1
xch a, re3
add a,re3 ;konečný počet tisíců
xch a,re3 ;konečný počet tisíců -> re3,bajt_H ->acc
add a,#6
jbc acc.0,correct4 ;acc byl 1
add a,#4 ;acc byl 2
correct4:
Add a, b
jnc correct3 ;přenos z výrazu (u_H*6 + u_L) - bod C
inc re3
add a,#6
correct3:
mov b, a
correct1:
mov a,#25 ;bude dělit 25D tj. 100/4
xch a,b ;b->25D,zbytek po dělení 1000D -> acc
div ab ;v acc stovky , v b zbytek
cjne a,#10,correct2 ;viz bod D
clr a
inc re3
correct2:
mov re2,a ;re2 ->počet stovek
mov a,#10 ;pro určení desítek
xch a,b ;b->10D,zbytek po dělení 100D -> acc
pop psw ;;obnoví b1 z re2 v Cy
rlc a
mov C,f0 ;nésobí 4 a doplĹ�uje odloženĂ©
rlc a ;bity
div ab
swap a
orl a,b ;BCD desítky_jednotky -> acc
xch a,re3 ;acc -> re3,konečný počet tisíců -> acc
mov b,#10 ;pro urceni desitek tisic
div ab ;v acc desitky tisic , v b tisice
xch a,b ; acc <-> b
swap a ;tisice do H_nibble
orl a,re2 ;BCD tisíce a sta -> acc
xch a,re3 ;BCD desítky_jednotky -> acc,BCD tisice a sta -> re3
mov re2,a ;BCD desítky_jednotky -> re2
mov a,b ;odloženĂ© des_tisíc do Acc
pop b ;obnova b
ret
;*******
;----------------------------------------
rand8:
mov a, rand8reg
jnz rand8b
cpl a
mov rand8reg, a
rand8b:
anl a, #0b10111000
mov c, p
mov a, rand8reg
rlc a
mov rand8reg, a
ret
#include "vars.inc"

.Global add16to16
.Global div16x16
.Global bin_bc
.Global rand8
.Global rand8reg

.Data

rand8reg: .ds.b 1
.Text
;*********************************************
; addition 16b + 16b - result 16b
; quick - 8 cycles of processor
; code size - 7 byte
;*********************************************
;Input in ren2 is byte_H , ren1 is byte_L of first addend -m1
; in ren4 is byte_H , ren3 is byte_L of second addend -m2
;in ren4 is so m2H, in ren3 - m2L, ren2 - m1H , ren1 -m1L
;
;output in ren4 is byte_H , ren3 is byte_L of sum
;in flag Cy may be overflow
; to change registers: Psw,ren3,ren4
; possibility to change work. registers **********
;*******
add16to16:
xch a,ren3 ;m2L <-> acc
Add a, ren1
xch a,ren4 ;m2H <-> result of Lbytes sum
addc a, ren2
xch a,ren4 ;result of Lbytes sum <-> result of Hbytes sum
xch a,ren3 ;acc <-> result of Lbytes sum
ret
;*******


;*********************************************
; division 16b / 16b unsigned
;time of executive - min 7 cycles of processor for div by 0
; - w/w max 39 cycles of processor
; - w/B max 143 cycles of processor
; - B/B max 27 cycles of processor
; - average 70 cycles of processor
; code size (8051) - 93 byte
;*********************************************
;input in DH is byte_H and in DL is byte_L of dividend
;input in dih is byte_H and dil is byte_L of divisor
;output Cy =1 for div by 0, other Cy =0 and
; in DH is byte_H and in DL is byte_L - of remainder
; in dih is byte_H and in dil is byte_L - of quotient (the result)
;
; to change registers: Acc,DH,DL,dH,dL,b,Psw
; possibility to change work. registers **********
;*******
div16x16:
cjne dih,#0,divAA
cjne dil,#0,divBA
setb c
ret ;divide by 0
divAA:
mov a, DH
mov b, dih
div ab
jnz divAB ;result has H_byte
mov dih, a
mov dil, a
ret ;divide finalised, result=0
divAB:
push b ;store remainder
mov DH,a ;defer result_L in rp
mov b, dil
mul ab
xch a, DL
subb a, DL
xch a, DL
pop acc
subb a, b
jnc divABcont ;result positive, no correction
dec DH
xch a, DL
Add a, dil
xch a, DL
addc a, dih
clr c
divABcont:
xch a, DH
mov dil, a
mov dih,#0
ret ;divide finalised
divBA:
mov b, dil
mov a, DH
div ab
mov dih,a ;store H_result
mov DH,b ;a new value of DH
cjne DH,#0,divBB
mov b,dil ;divide byte/byte
mov a, DL
div ab
mov dil, a
mov DL, b
ret
divBB:
mov DH,#8 ;divide word/byte
divBB1:
mov a,DL // the shorted improved Booth's loop
rlc a
mov DL, a
mov a, dil
xch a, b
rlc a
jc divBB2 ;for divisors > 7FH
div ab
rrc a
djnz DH, divBB1
mov a, b
xch a,DL ;remainder -> DL, intermediate result_L-> acc
rlc a
mov dil, a
ret
divBB2: clr c
subb a, b
mov b, a
djnz DH,divBB1 ;a possibly end for divisors > 7FH
mov a, b
xch a,DL ;remainder -> DL, intermediate result_L-> acc
rlc a
mov dil, a
ret
;*******

;*********************************************
; konverze bin -> BCD pro rozsah čísla do 65 535
; superrychlé - max 84 cyklů procesoru
; rozsah kodu (8051) - 85 byte
;*********************************************
;vstup v re3 je udaj_H a re2 je udaj_L
;vystup v re3 je tis_sta a re2 je des_jed
; v acc desítky tisíc
;
; mění reg.: Acc,re2,re3, psw
; možnost zvolit prac registry******
;*******

bin_bc:
push B ;odlož obsah B
mov a, re3
clr c
rrc a ;vydělí re3 číslem 2 = posune o 1 doprava
xch a,re2 ;re2->acc, re3/2 ->re2
rrc a ;vydělí re2 číslem 2, b0 re2->C
mov f0,C ;bit0 z re2 schové do f0
xch a,re2 ;re2/2->re2 , re3/2->acc
clr c
rrc a ;vydělí re3/2 číslem 2 = posune o 1 doprava
xch a,re2 ;re2/2->acc, re3/4 ->re2
rrc a ;vydělí re2/2 číslem 2, b1 re2->Cy
push psw ;odloží b1 re2 do Cy
xch a,re2 ;re3/4->acc, re2/4 ->re2
mov re3,a ;re3/4 -> re3
mov b,#06
mul ab
add a,re2 ;připočte re2/4
xch a,b ;bajt_H ->acc , bajt_L -> b
addc a,#0
jz correct1
xch a, re3
add a,re3 ;konečný počet tisíců
xch a,re3 ;konečný počet tisíců -> re3,bajt_H ->acc
add a,#6
jbc acc.0,correct4 ;acc byl 1
add a,#4 ;acc byl 2
correct4:
Add a, b
jnc correct3 ;přenos z výrazu (u_H*6 + u_L) - bod C
inc re3
add a,#6
correct3:
mov b, a
correct1:
mov a,#25 ;bude dělit 25D tj. 100/4
xch a,b ;b->25D,zbytek po dělení 1000D -> acc
div ab ;v acc stovky , v b zbytek
cjne a,#10,correct2 ;viz bod D
clr a
inc re3
correct2:
mov re2,a ;re2 ->počet stovek
mov a,#10 ;pro určení desítek
xch a,b ;b->10D,zbytek po dělení 100D -> acc
pop psw ;;obnoví b1 z re2 v Cy
rlc a
mov C,f0 ;nésobí 4 a doplĹ�uje odloženĂ©
rlc a ;bity
div ab
swap a
orl a,b ;BCD desítky_jednotky -> acc
xch a,re3 ;acc -> re3,konečný počet tisíců -> acc
mov b,#10 ;pro urceni desitek tisic
div ab ;v acc desitky tisic , v b tisice
xch a,b ; acc <-> b
swap a ;tisice do H_nibble
orl a,re2 ;BCD tisíce a sta -> acc
xch a,re3 ;BCD desítky_jednotky -> acc,BCD tisice a sta -> re3
mov re2,a ;BCD desítky_jednotky -> re2
mov a,b ;odloženĂ© des_tisíc do Acc
pop b ;obnova b
ret
;*******
;----------------------------------------
rand8:
mov a, rand8reg
jnz rand8b
cpl a
mov rand8reg, a
rand8b:
anl a, #0b10111000
mov c, p
mov a, rand8reg
rlc a
mov rand8reg, a
ret

Vyhledávání

Kdo je online

Celkem přihlášeno: 71 uživatelů
No members online
Členů: 0 / Hostí: 71

Nejnovější uživatelé

  • Frfafel
  • PragueMate
  • 5Z28BA7 Thank you for signing up - it was amazing and delightful, wishing you all the best and much success. www.apple.com dsaqwrqw
  • Jiří
  • 11591159altara