CHAPTER 9

CHAPTER 9

Nuts and Bolts

We have talked a lot about functional blocks, but there is a lot of reused code which is common to all modules, the nuts and bolts which make the program possible and hold it together!

We must include in these categories two areas about which we have said very little.

MATHEMATICS
LOGIC

Math routines

All of the basic routines for hexadecimal maths

Multiplication
Division
Addition
Subtraction

are freely available on the internet. They come in a multitude of shapes, 4 , 8, 16,24,32…bit.

There are just two little problems. Many of them aren’t what you want and, many of them are theoretical, and hard to put into assembler code ( a euphemism for maybe they never have worked).

Another more subtle problem is that some work with the example figures but not with others…. Gulp!!!

We need routines that work with all figures inside the bit range required.

So you can imagine that this was a long process narrowing down what was available and what was required.

Fortunately in the PICLIST. COM, you will find the routines that I have used and many others, which also work, but whose operation is a bit too subtle to be included in this SIMPLE first time code effort.

LOGIC routines

These have been kept to a minimum . Basically the Bike computer uses

An EQUAL TEST, which is the xorwf instruction. STATUS, Z

A less than equal =< coupled with greater than > test

Which use these instructions e.g. subwf dtothi,w followed by btfsc STATUS,C

These, AND MANY MORE, are well explained in the articles in PICLIST.COM.

Conversion routines

The three main types that had to be invented were converting

HEX to DECIMAL

HEX FRACTIONS to DECIMAL FRACTIONS

NUMBER SCALING

HEX to DECIMAL

This we have already discussed h2d in previous paragraphs but the basic routine is used in the three calculation modules for, SPEED, DISTANCE and AVERAGE SPEED.

You should be able to follow the conversion routines after a little bit of study. The notes in each routine to say where you are in the process are abundant.

HEX FRACTIONS to DECIMAL FRACTIONS

This merely is an extension of the previous routines with a little bit of reasoning to change hex remainder and fractions into decimal fractions.

The fraction routines are needed because the pics don’t handle directly fractions, so they have to be changed into whole numbers by suitable multiplication.

NUMBER SCALING

We do a lot of multiplication and division in the three main calculations for Speed, Distance and Average Speed.

But we have a practical 16bit number limit. The numbers can’t be bigger than 65536.

If they are, then we need to add more registers, and probably bigger calculation routines able to handle more than 16bits. So I decided to try and stay as far as possible within the 16bit routines.

In some places you divide and the result of the division has to be multiplied by another number. For example 2000.

So you divide your first two numbers. The result is say ten.

Then the next operation has no problem because 10 x 2000 is 20000 which is< 65536.

However if the first division had given as a result 300, then we have a problem.

300 x 2000 = 600000 way above the limit of 65536 we need to scale somewhere.

The scale factor here would be about 20. But this is one of those things that is best seen following the steps the code takes , say in the SPEED block.

Basically the number is tested for size and divided down until its product with a reference number is smaller than 65536. But as we said above, follow the steps taken in the actual code block to see how the scaling is done to solve a specific application problem.

LCD Setup, Signalling and data transfer routines

The LCD itself has on board a complex controller chip whose job is to interface with a uController, in this case our 16F84A and steer the incoming data messages to the correct position for display.

There are two basic operation modes; 4 bit and 8 bit. Most applications seem to use the 4 bit mode as it will free 4 lines of a uController to do other things.

The data is strobed into the LCD using appropriate signals on the E and RS lines. The protocols are also time sensitive. They have to be as long as the minimum times quoted on the LCD data sheets. Here lies a problem.

The LCD chosen is very popular. It has many clones. SOME of the clones need EVEN longer times. This means that the typical DELAYS programmed could be insufficient.

Before anything can be displayed, the LCD needs to be initialised. This is a really slow process taking about 50 to 100ms. The number of times the routines are repeated during the initiation sequences seems a little exaggerated but it has to be that way to get the LCD up and running, it is exactly what the manufacturers spell out on their data sheets.

Each command or data interchange between the PIC and the LCD has it’s corresponding minimum time. These have all to be scrupulously observed or the process fails.

That is the reason why there are so many different time blocks within the delay module plus some additional ones for other tests.

All of the routines can be found on the PICLIST.COM site. I take my hat off to whoever sat down and worked them out first time round, a really heroic and Herculean task.

Automatic menu (2)

The operation of Automatic menu was explained previously under the heading of that name when we were looking at the Flow Chart.

However this was one of two possibilities in the original project, the other, manual function selection needed two push buttons plus the corresponding code so that was dropped as the PIC was running out of space.

There is nothing special about the way the menu presents the three main features. Their combinations features to the LCD can be changed if you prefer. For example, maybe you would like to see at once Average Speed and Total distance, or maybe Speed and total distance.

There are many combinations possible. Of course if you do change then don’t forget to follow through into each module that is being used to see that there is no other unwanted effects.

Bike3.asm

We can now study the complete program which is called bike3.asm

With the help of the previous Flow Chart which shows the sequence of major functional blocks of the program, and reading through the code below, it should now be possible to understand, hopefully fairly easily, how the code blocks have been cobbled together.

Made to implement the basic equation we started out with.

Speed = Distance /Time.

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

; bike3.asm Combines: Time , Dist, Av velocity, Inst Vel

; Fred Maher 1st March 2002

; BASIC BICYCLE COMPUTER WITH THESE FUNCTIONS

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

; 1 Trip Time HRS:MIN:SEC

; 2 Trip Dist 000km 00m

; 3 Trip AvSpd 00.00km/hr

; 4 Speed 00.00km/hr

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

;------- HEADER ----------

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

; LCD MESSAGES

; position at beginning of 1st line col 0 movlw H'80

; position at beginning of second line movlw H'C0'

LIST P=16F84 ; 16F84 Runs at 4.096 MHz

INCLUDE "p16f84A.inc"

__CONFIG _CP_OFF & _WDT_OFF & _XT_OSC & _PWRTE_ON

ERRORLEVEL -224 ; suppress annoying message because of tris

ERRORLEVEL -302 ; suppress message because of page change

; Define Information

#DEFINE RS PORTA, 2

#DEFINE E PORTA, 3

;#DEFINE TOGGLESW PORTB, 6 ; not used at the moment

;#DEFINE LED PORTB, 5

; Macro

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

CBLOCK 0CH ; from 0C to 4F = 67

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

; MATH ROUTINES

; 16 X16 Mult , --> 32

; mah mal x mbh mbl = mq4 mq3 mq2 mq1 ( mq4 highest)

mq4

mq3

mq2

mq1

mbh

mbl

mah

mal

; 16 / 16 Div --> 16

denlo

denhi

numlo

numhi

rmdrlo

rmdrhi

reshi

reslo

;temp also used in nybble

; Addition 16+16 out max 65536 (no carry)

; Subtraction q1_16-q2_16 out r_16; neg numbers not allowed

q1hi

q1lo

q2hi

q2lo

rhi

rlo

;------------ Distance -----------------------

dtotlo ; total trip distance in metres

dtothi ; dtothi/lo hold a max of 65km 536m,

dtothi2 ; with this added max now 16777km

dist54 ; corrects +2m every 54m (27x2.0747 =56)

dm10

dm100

dm1000

dm10000

dm100000

;------------ Average velocity Vav -------------------

;vavhi

;vavlo

;divrat

;stemphi ;second info passed to stemphi/lo

;stemplo

;dtemphi ;dist info passed to dtemphi/lo

;dtemplo

m10

m100

m1000

;--------- Time and trip time --------------------

;

sectotlo ; total trip seconds

sectothi ; max 65536 = aprox 18hrs

sec ; seconds digit

sec10 ; 10's of second digit

min ; minutes digit

min10 ; 10's of minutes digit

hr ; hours digit

hr10 ; 10's of hours digit

oldsec ; holds last value of sec

cntmsec ; count ms

TMR18 ; TMR0 217* TMR18 18 = 1 SEC

;---- isr interrupt service routine push pop -------

w_temp ; W isr var

status_temp ; STATUS isr var

fsr_temp ; FSR isr var

; --------- Instantaneous Velocity Vin --------------------

vinhi

vinlo

sectemp

oldtemp

totmslo

totmshi

totms2lo

totms2hi

mshi

mslo

spdflg ; 1st pass =0 2nd pass =1, diff is time between pulses

;-------- Miscellaneous ------------------

temp ; a temporary used in divide and nybble

count

ENDC ; end of definition block

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

ORG 0 ; start at location 0

goto main ; jump over to main routine

ORG 4

goto Isr ; jump to interrupt routine

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

; The Main routine ;

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

; -------- THE MAIN MODULES ---------

; Isr stores elapsed TRIP time and generates hr:min:sec

; Disptime TRIP time, to max 99:59:59

; Dist Calculates total TRIP distance

; Dispdist TRIP distance to a max of 999km 999m

; Velav Average velocity, Totdist/totsecs max 99km/hr

; Dispvav Average TRIP speed up to 99.99 km/hr

; Velocity Speed from 2m/(time diff of pulse2-pulse1)

; Dispd Speed up to 99.99km/hr

; NOTE. Speed is your calculated velocity every second

; -------- more to come??? NO, running out of space ---------

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

; M A I N

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

main:

call Init ; Initialize ports, set up timer

call Initlcd ; Initialize the LCD DUMMY

Initend:

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

; Changesec Changewhlpulse wait for interrupts from newsec or newwheelpulse

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

clrf menu ; initially set to 0 menu loop

clrf spdflg ; Initially = 0 2nd = sub for time from zero

; every new sec, set to zero

; CHANGESEC LOOPS TILL SEC CHANGES

;clrw ;DUMMY

;xorwf sec,w ;DUMMY

;btfsc STATUS,2 ;DUMMY

;incf sec,f ;DUMMY

Changesec: ;loops checking new sec and new wheel pulse

movf oldsec, w

xorwf sec,w

; if equal, w= 0 and Z bit=1

btfsc STATUS,2 ; test Z bit

goto Changesec ; no change, loop

movf sec,w ; sec has increased, update

movwf oldsec ; sec and oldsec are = again

incf menu,f ; increases menu every sec

; Note1, sectotlo/hi are updated every sec in ISR module

; Note2, Decimal time also created in ISR module

; but time display for LCD controlled from

; the automatic menu below

call Disptime ;TRIP time, will appear on LCD top line

Changewhp: ; 1st detected wheelpulse starts menu sequence

clrf PORTB

bcf PORTB,5 ; start with green LED off

loop:

btfss PORTB, 4 ;(PUT BTFSC FOR TEST); i/p hi,?DUMMY

goto loop ; not yet

; i/p hi detected

;green LED flashes with every wheel pulse

bsf PORTB, 5 ; LED on

; wait a while to make sure switch has

; settled

movlw D'10' ; wait about 10 msec

call nmsec

btfsc PORTB, 4 ; will be lo (0) when finished

goto $ -1 ; still low

; now must wait a make sure bouncing stopped

movlw D'10' ; 10 milliseconds

call nmsec

; and check again

btfsc PORTB, 4 ; if set, not finished

goto $ -5 ; still hi start debounce wait again

Tp1: ; green LED ready for next wheel pulse

bcf PORTB,5 ; i.e. LED off

movf PORTB,w ; reading to clear

; AUTOMATIC MENU: (LCD Top line always time)

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

; menu selects at 10sec intervals in rotation

; Speed menu 1 to 10

; Dist ance menu 11 to 20

; Velav Avg vel menu 21 to 30

; MENU 0 TO 10

; as speed ( Speed) is stand alone, no sense in calculating it

; if it is not going to be displayed when menu is >10.

; BUT if SPEED AVERAGING IS TO BE USED, kill off the lines below that bypass

; the SPEED calc module

Menucheck:

movlw 0x0A ;check menu > 10 (to meet >10 AND =<20)

subwf menu,w

btfss STATUS,C ;compare with 10

goto $+2 ;menucount =< 10 not yet got to 11 jump to Speed

goto Distblk

call Speed ; Calculates instant speed,(time between pulses)

movlw 0x0A ; DUMMY, was movlw 0xA

subwf menu,w

btfss STATUS,C ;compare with 10

call Spdflgcheck ;menucount =< 10 ; also see 0-1 spdflg

goto Distblk

Spdflgcheck:

clrw

xorwf spdflg,w

btfsc STATUS,Z

call Dispd ;menucount =< 10 AND spdflg =1

Return

Distblk:

call Dist ;menucount > 10 skip Dispd update Dist

; MENU 11 TO 20

movlw 0x0A ;check menu > 10 (to meet >10 AND =<20)

subwf menu,w

btfss STATUS,C ;compare with 10

goto $+5 ;menucount =< 10 not yet got to 11 jump to velav

movlw 0x14

subwf menu,w

btfss STATUS,C ;compare with 20

call Dispdist ;menucount =< 20

call Velav ;menucount > 20 skip dispdist update Velav

; MENU 20 TO 30

movlw 0x14 ;check menu > 20 (to meet >20 AND =<30)

subwf menu,w

btfss STATUS,C ;compare with 20

goto $+5 ;menucount =< 20 not yet got to 21 jump to NEXT

movlw 0x1E

subwf menu,w

btfss STATUS,C ;compare with 30

call Dispvav ;menucount =< 30

movlw 0x1F ;if it has reached 31 reset menu, before return

xorwf menu,w

btfss STATUS,Z

goto $ +2 ; not 31 goto changewhp1 direct

clrf menu ; is 31, reset menu before changewhp1

Menuend:

; before changewhp jump, check that sec has not updated

; if it has , jump back to changesec routine

movf oldsec, w

xorwf sec,w ; if equal, w= 0 and Z bit=1

btfsc STATUS,2 ; test Z bit

goto Changewhp ; no sec change, check whpulse change

goto Changesec ; a new sec starts measurements

; loop while NOT newsec

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

; End Main

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

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

; ISR, increments TMR0 by 1 every 256 µsec. Basically just ;

; reset the INTCON and TMR0 bits. The FSR,w, STATUS push pop kept ;

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

Isr:

movwf w_temp ; save W

swapf STATUS,W ; save status

movwf status_temp ; without changing flags

swapf FSR,W ; save FSR

movwf fsr_temp ; without changing flags

;256us * 217 * 18 = 0.999936 sec.

;1hr_err = 0.23sec or 1 sec in 4hr

;The time loop starts with TMR0 loaded with (256-217)=39 After 217

;steps interrupt is set, TMR0 rolls to zero and the TMR18 inc +1

movlw D'39' ;39 = 0x27

movwf TMR0

incf TMR18,f

movlw D'18' ; DUMMY18 = 0x12

xorwf TMR18,w ; if equal, w= 0 and Z bit=1

btfss STATUS,2 ; test Z bit

goto restore ; NOT 18 so pop stack and return to main

Firstsec:

clrf TMR18 ; is 18. set TMR18 to zero and INC sec

incf sec,f ; also inc sectot (eventually lo and hi)

incf sectotlo,f ; check sectot lo 00->inc hi

clrw

xorwf sectotlo,w ; if equal, w= 0 and Z bit=1

btfsc STATUS,2

incf sectothi,f ; increases every 256 x sectotlo

movlw 0xA ; check if =10

xorwf sec,w ; if equal, w= 0 and Z bit=1

btfss STATUS,2 ; test Z bit

goto restore ; NOT 10 so pop stack and return to main

clrf sec ; is 10. set sec to zero and inc sec10

incf sec10,f

movlw 0x6 ; = 0x6

xorwf sec10,w ; if equal, w= 0 and Z bit=1

btfss STATUS,2 ; test Z bit

goto restore ; NOT 6 so pop stack and return to main

clrf sec10 ; is 6. set sec10 to zero and INC min

incf min,f

movlw 0xA ; check if =10

xorwf min,w ; if equal, w= 0 and Z bit=1

btfss STATUS,2 ; test Z bit

goto restore ; NOT 10 so pop stack and return to main

clrf min ; is 10. set sec to zero and inc min10

incf min10,f

movlw 0x6 ;= 0x6

xorwf min10,w ; if equal, w= 0 and Z bit=1

btfss STATUS,2 ; test Z bit

goto restore ; NOT 6 so pop stack and return to main

clrf min10 ; is 6. set min10 to zero and INC hr

incf hr,f

movlw 0xA ;check if =10

xorwf hr,w ; if equal, w= 0 and Z bit=1

btfss STATUS,2 ; test Z bit

goto restore ; NOT 10 so pop stack and return to main

clrf hr ; is 10. set hr to zero and inc hr10

incf hr10,f

movlw 0xA ;= 10

xorwf hr10,w ; if equal, w= 0 and Z bit=1

btfss STATUS,2 ; test Z bit

goto restore ; NOT 10 so pop stack and return to main

clrf sec ; is ten (99hr 59min 59sec +1sec) we are at MAX

clrf sec10 ;all reset to zero and start again

clrf min

clrf min10

clrf hr

clrf hr10

clrf TMR18

clrf oldsec

goto restore

restore:

swapf status_temp,W ; get original status back

movwf STATUS ; into status register

swapf fsr_temp,W ; get original fsr back

movwf FSR ; into status register

swapf w_temp,f ; old no flags trick again

swapf w_temp,W ; to restore W

bcf INTCON,T0IF ; clear the TMR0 interrupt flag

retfie ; finished, reset GIE

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

; Initialize the ports ;

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

Init:

clrf PORTA

clrf PORTB

movlw B'00000000' ; Porta all outputs

tris PORTA

movlw B'01010000' ; 7o 6i-Wire 5o-LED 4i-multivib,

tris PORTB ; 0to3lcd

movlw B'00000111' ; opt pull-ups enabled

; opt prescaler assigned to TMR18

; opt prescaler set to 1:256

option ; opt rolls over each 125th second

movlw 0 ; zero out all registers

clrf m

clrf m10

clrf m100

clrf m1000

clrf dm

clrf dm10

clrf dm100

clrf dm1000

clrf dm10000

clrf dm100000

clrf totmshi

clrf totmslo

clrf totms2hi

clrf totms2lo

clrf dist54

clrf hr10

clrf hr

clrf min10

clrf min

clrf oldsec

clrf sec10

clrf sec

clrf sectotlo

clrf dtotlo

clrf dtothi

clrf sectotlo

clrf sectothi

clrf TMR18 ; when this reaches 18, 1 sec has elapsed

; TMR0 has to start at 256-217 :39, so that the first rollover

; with prescaler 256, happens in 217*256us =0.055552sec

; The TMR18 incs each roll and after 18 1 sec has elapsed

movlw 0x27 ; D39

movwf TMR0 ; set to D39 217 counts later 256,

; TMR0 resets and inc TMR18 in Isr loop

clrf INTCON ; START WITH ALL AT 0

; movlw B'10100000' ; GIE set T0IE set, T0IF cleared

movlw B'10100000' ; Set:GIE,T0IE,RBIE Clrd:T0IF,RBIF

movwf INTCON ; ready to detect interrupts in ISR

return

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

; Initialize the LCD ;

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

Initlcd:

movlw D'40'

call nmsec ; Wait 40 msecs before Reset

bcf RS ; send an 8 bit instruction

movlw 0x03 ; Reset Command

call NybbleOut ; Send the Nybble

call Dlay5 ; Wait 5 msecs before Sending Again

call EStrobe

call Dlay160 ; Wait 160 usecs before Sending 2nd Time

call EStrobe

call Dlay160 ; Wait 160 usecs before Sending 3rd Time

bcf RS ; send an 8 bit instruction

movlw 0x02 ; Set 4 Bit Mode

call NybbleOut

call Dlay160

movlw 0x028 ; 4 bit, 2 Line, 5x7 font

call SendINS

movlw 0x010 ; display shift off

call SendINS

movlw 0x001 ; Clear the Display RAM

call SendINS

call Dlay5 ; Note, Can take up to 4.1 msecs

movlw 0x006 ; increment cursor

call SendINS

movlw 0x00C ; display on cursor off

call SendINS

return

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

; Send the character in W out to the LCD ;

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

SendASCII

addlw '0' ; Send nbr as ASCII character

SendCHAR: ; Send the Character to the LCD

movwf temp ; Save the temporary Value

swapf temp, w ; Send the High Nybble

bsf RS ; RS = 1

call NybbleOut

movf temp, w ; Send the Low Nybble

bsf RS

call NybbleOut

return

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

; ES strobe

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

EStrobe: ; Strobe the "E" Bit

bsf E

bcf E

return

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

; Send an instruction in W out to the LCD ;

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

SendINS: ; Send the Instruction to the LCD

movwf temp ; Save w

swapf temp, w ; send Hi Nybble

bcf RS ; RS to 0

call NybbleOut

movf temp, w ; Send Lo Nybble

bcf RS

call NybbleOut

return

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

; Send the nibble in W out to the LCD ;

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

NybbleOut: ; Send a Nybble to the LCD

movwf PORTB

call EStrobe ; Strobe out the LCD Data

bsf E

call Dlay160 ; delay for 160 usec

return

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

; Output the message on the LCD ;

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

OutMessage1:

movwf FSR ; Point at first letter

OutLoop:

movf FSR, w ; Get pointer into W

incf FSR, f ; Set up for next letter

call Dispmsg1 ; Get character to output

iorlw 0 ; At the End of the Message?

btfsc STATUS, Z ; Skip if not at end

return ; Yes - Equal to Zero

call SendCHAR ; Output the ASCII Character

goto OutLoop ; Get the next character

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

; Data for message to be output ;

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

Dispmsg1: ; Message to Output

addwf PCL, f ; Output the Characters

dt "Bike Computer", 0

Dispmsg2: ; Message to Output

addwf PCL, f ; Output the Characters

dt "Dist", 0

Dispmsg3:

addwf PCL,f ; message to output

dt " Av speed:",0 ; output characters

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

; time delay routines ;

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

;Note . The original application needed precise times from the delay code that

; follows. But the Simple Bike application does NOT use the routines for

; any CRITICAL time measurement.

Dlay160:

movlw D'41' ; delay about 160 usec

micro4:

addlw H'FF' ; subtract 1 from 'W'

btfss STATUS,Z ; skip when you reach zero

goto micro4 ; more loops

return

Dlay5:

movlw 5 ; delay for 5 milliseconds

goto $ + 2

msec250:

movlw D'250' ; delay for 250 milliseconds

; --- N millisecond delay routine ---

nmsec:

movwf cntmsec ; delay for N (you put in W) millisec

msecloop:

movlw D'254' ; load takes .9765625 microsec

call micro4 ; by itself CALL takes ...

; about 1ms

nop ; 1usec

decfsz cntmsec, f ; .98 skip not taken, else 1.95

goto msecloop ; 1.95 here: total ~1000 / loop

return ; final time through ~999 to here

; overhead in and out ignored

; this block is functional for tests, but not used in bike

Dlay1sec: ; this is a marker routine to see where

call msec250 ; the prg is at.

; bsf LED

call msec250 ;flash led on portb pin6

;bcf LED

call msec250

; bsf LED

call msec250 ; finishes with green led lit

return

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

; Display the Time ;

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

Disptime:

movlw H'80' ; position at beginning of first line

call SendINS

movf hr10, W ; tens of hours

call SendASCII

movf hr, W ; hours

call SendASCII

movlw ":"

call SendCHAR

movf min10, W ; tens of minutes

call SendASCII

movf min, W ; minutes

call SendASCII

movlw ":"

call SendCHAR

movf sec10, W ; tens of seconds

call SendASCII

movf sec, W ; seconds

call SendASCII

movlw " "

call SendCHAR ; the h m s really not needed

movlw "h"

call SendCHAR

movlw "m"

call SendCHAR

movlw "s"

call SendCHAR

movlw " "

call SendCHAR

Dispend:

RETURN

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

; End of display time

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

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

; Display the Distance , (trip distance at moment) ;

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

Dispdist:

movlw H'C0' ; position at beginning of second line

call SendINS

movf dm100000, W ; 0 of 065km 536m

call SendASCII

movf dm10000, W ; 6 of 065km 536m

call SendASCII

movf dm1000, W ; 5 of 065km 536m

call SendASCII

movlw "k" ; k of 065km 536m

call SendCHAR

movlw "m" ; m of 065km 536m

call SendCHAR

movlw " " ; " " of 065km 536m

call SendCHAR

movf dm100,W ; 5 of 065km 536m

call SendASCII

movf dm10,W ; 3 of 065km 536m

call SendASCII

movf dm, W ; 6 of 065km 536m

call SendASCII

movlw "m" ; m of 065km 536m

call SendCHAR

movlw " " ; " "

call SendCHAR

movlw "D" ; "D "

call SendCHAR

movlw "i" ; " i"

call SendCHAR

movlw "s" ; "s "

call SendCHAR

movlw "t" ; " t"

call SendCHAR

movlw " " ; " " ( to wipe screen)

call SendCHAR

Distend:

RETURN

;

;---------------------------------------------------------------------*

; Multiplication 16x16 Out32

;---------------------------------------------------------------------*

Mult16x16:

clrf mq4

clrf mq3

clrf mq2

clrf mq1

bsf mq2, 7

Mu1:

rrf mah, f

rrf mal, f

skpc

goto Mu2

movf mbl, w

addwf mq3, f

movf mbh, w

skpnc

incfsz mbh, w

addwf mq4, f

Mu2:

rrf mq4, f

rrf mq3, f

rrf mq2, f

rrf mq1, f

skpc

goto Mu1

Endmult16:

clrf mbh

clrf mbl

clrf mah

clrf mal

Return

;---------------------------------------------------------------------*

; End Multiplication 16x16 Out32

;---------------------------------------------------------------------*

; New routine Division 16/16 Out 16

; ---------------------------------------------------------------------*

; Finally:- Result 000AH in reshi/lo, remainder 0096H in rmdrhi/lo

; so, checking end of division A=10 and 96H/E1H= 150/225 =0.666 OK

Div:

call D_divS ; remainder in Rmdr.

Divend:

nop

return

D_divS:

call setup

clrf rmdrhi

clrf rmdrlo

dloop:

bcf STATUS,C

rlf reslo, f

rlf reshi, f

rlf rmdrlo, f

rlf rmdrhi, f

movf denhi,w

subwf rmdrhi,w ;check if a>c

btfss STATUS,Z

goto nochk

movf denlo,w

subwf rmdrlo,w ;if msb equal then check lsb

nochk:

btfss STATUS,C ;carry set if c>a

goto nogo

movf denlo,w ;c-a into c

subwf rmdrlo, f

btfss STATUS,C

decf rmdrhi, f

movf denhi,w

subwf rmdrhi, f

bsf STATUS,C ;shift a 1 into b (result)

nogo:

rlf numlo,f

rlf numhi,f

decfsz temp, f ;loop untill all bits checked

goto dloop

setup:

movlw .16 ; for 16 shifts

movwf temp

movf numhi,w ;move Num to Res

movwf reshi

movf numlo,w

movwf reslo

clrf numhi

clrf numlo

retlw 0

;--------------------------End Div 16 by 16----------------------------

return

;---------------------------------------------------------------------*

; END DIVISION 16/16 OUT 16

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

;---------------------------------------------------------------------*

; START Addition 16-16 OUT 16

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

Add: ; R = q1 + q2

movf q1lo, W

addwf q2lo, W

movwf rlo

movf q1hi, W

btfsc STATUS, C

addlw .1 ; If A Carry Occurred, Add 1

addwf q2hi, W

movwf rhi

;clrf q1hi ; added this to stop next user summing;

;clrf q1lo

;clrf q2hi

;clrf q2lo

Return

;---------------------------------------------------------------------*

; END Addition 16-16 OUT 16

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

;---------------------------------------------------------------------*

; START Subtraction 16-16 OUT 16

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

Sub: ; R = q1 - q2

movf q2lo, W

subwf q1lo, W ; W = q1lo - q2lo

movwf rlo

btfss STATUS, C

Goto Borrow

Goto Sub1

Borrow:

Decf q1hi, F

Sub1:

movf q2hi, W

subwf q1hi, W ; W = q1hi - q2hi

movwf rhi

Return

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

; END Subtraction 16-16 OUT 16

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

; Dist = counting wheel pulses

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

Dist: ; whlcirc = 2.0747, for initial test =2

;

; movlw 0x2 ; <-- don't forget, this is just for 26"wheel

; movwf whlcirc ; start count at 0 and inc till same as whlcirc

; (range will be 1 to 4 m)

clrf count ; count can be 2 or 4 in this 26" case

Whloop: ; although the distance pulses ( in this example) jump in steps of 2m

; the m counter has to increase in 1's to catch the

; decimal rollover from 10 to 0

; so count, here, is stepped from 0 to 2 (whlcirc)

; Also, when the dist54 var increases 54m, COUNT adds an extra 2m

; to the hex and decimal totals, before resetting to zero.

; Note that as dist54 is in the loop it will also receive

; the 2m increase so it really counts to 56 (54 +2).

movlw 0x2 ; wheel circumference of 26 inch

xorwf count,w ; if equal, w= 0 and Z bit=1

btfsc STATUS,2 ; test Z bit

goto DistanceEnd ; they are the same, so jump distanceEnd and return

goto Mcount ; NOT yet = whlcirc, so inc mcount by 1 and return

Mcount: ; Distance to decimal for display , i/p m, o/p 000km 000m

; starts with m, m10, m100, m1000 , m10000, m100000 = 0

; Later correct m every 54m (add 2m ???? )

incf dm,f

movlw D'10'

xorwf dm,w ; if equal, w= 0 and Z bit=1

btfss STATUS,2 ; test Z bit