32 bit math

[BigWumpus]

Oh,

it is easy !

Shift left all bits by 2 positions (= x4),
store it to a variable X
Shift left all bits by 3 positions (= x32),
add it to the variable X
Shift left all bits by 1 position (= x64),
add it to the variable X

X is holding the result !

It can easily be done by small assembler-code.

[Charles Linquis]

Unfortunately, I'm "assembly challenged" when it comes to math. Can someone point me to a good source of information on how to accomplish what Mr. Wumpus has explained?

[BigWumpus]

IMHO:

;Here you must place your 32-bit-value
AU var byte BankA ;Upper
AH var byte BankA ;High
AM var byte BankA ;Middle
AL var byte BankA ;low

;Here the result is placed
XU var byte BankA ;Upper
XH var byte BankA ;High
XM var byte BankA ;Middle
XL var byte BankA ;low

asm
;clear X
clrf _XU
clrf _XH
clrf _XM
clrf _XL
;shift A by 1 position left
rlncf _AL,f
rlcf _AM,f
rlcf _AH,f
rlcf _AU,f
[repeat the shift-routine]
;move A to X
movff _AU,_XU
movff _AH,_XH
movff _AM,_XM
movff _AL,_XL
[repeat the shift-routine]
[repeat the shift-routine]
[repeat the shift-routine]
;add A to X
movf _AL,w
addwf _XL,f ;ignore Carry
movf _AM,w
addwfc _XM,w
movf _AH,w
addwfc _XH,w
movf _AU,w
addwfc _XU,w
[repeat the shift-routine]
[repeat the add-routine]
endasm

[Charles Linquis]

Thanks for the code, but when I input 0x64, I get 0x90 as an output.

In the meantime, I try to figure it out at this end.

[Charles Linquis]

This is what I'm using.

If input = $64
Output = $36

;-----------------------------------------------------------------

The code:


Mult32:

asm
;clear X
clrf _XU
clrf _XH
clrf _XM
clrf _XL

;shift A by 1 position left

rlncf _AL,f
rlcf _AM,f
rlcf _AH,f
rlcf _AU,f

;[repeat the shift-routine]

rlncf _AL,f
rlcf _AM,f
rlcf _AH,f
rlcf _AU,f


;move A to X

movff _AU,_XU
movff _AH,_XH
movff _AM,_XM
movff _AL,_XL

;[repeat the shift-routine]

rlncf _AL,f
rlcf _AM,f
rlcf _AH,f
rlcf _AU,f

;[repeat the shift-routine]

rlncf _AL,f
rlcf _AM,f
rlcf _AH,f
rlcf _AU,f

;[repeat the shift-routine]

rlncf _AL,f
rlcf _AM,f
rlcf _AH,f
rlcf _AU,f


;add A to X

movf _AL,w
addwf _XL,f ;ignore Carry
movf _AM,w
addwfc _XM,w
movf _AH,w
addwfc _XH,w
movf _AU,w
addwfc _XU,w

;[repeat the shift-routine]

rlncf _AL,f
rlcf _AM,f
rlcf _AH,f
rlcf _AU,f

;[repeat the add-routine]

movf _AL,w
addwf _XL,f ;ignore Carry
movf _AM,w
addwfc _XM,w
movf _AH,w
addwfc _XH,w
movf _AU,w
addwfc _XU,w



endasm

[Darrel Taylor]

Charles,

You have a timer running at 100 hz, and you're dividing those interrupts by 100 to count seconds. Then later you want to multiply the seconds times 100.

Why not just count the interrupts directly? Then you have the Sec*100 already (plus fractional secs), and you can DIV32 100 that number for the seconds, or keep a separate count for the seconds and no DIV or MUL required.
<br>

[Charles Linquis]

Darrel,

Actually, I have 1Khz interrupt running. I really didn't want to use it because I really like routines that run often to be very short. Since this is for an SNMP trap (an ERROR has ocurred), the timer tick value will be output something like once a year. That is why I wanted to do the multiply only when necessary.

Maybe I'm getting too stingy with the 8722's time!