www.motorkontrolle.de

Code: Alles auswählen

(...)
***************************************************************************
**
** Computation of RPM
**
**   Result left in accumulator.
**
**     rpmk:rpmk+1
**     ----------- = rpm
**     rpmph:rpmpl
**
**  rpmk:rpmK+1 = RPM constant = (6,000 * (stroke/2))/ncyl
**  rpmph:rpmpl = period count between IRQ pulsed lines, in 0.1 ms resolution
**
****************************************************************************

CalcRPM:
; 50% re-written in 026i with aim of better odd-fire averaging

        brset     running,engine,dorpmCalc
        ldhx      rpmph
        bne       dorpmCalc		; If zero then jump over calculation
					; - prevent divide by zero
        jmp       rpmCalcZero           ; previous branches out of range

dorpmCalc:
;tmp12,13,14 used to hold average iTime or avg iTime
        sei                    ; must block ints for this little period
        mov       iTimeX,tmp12
        mov       iTimeH,tmp13
        mov       iTimeL,tmp14

        mov       iTimepX,tmp15
        mov       iTimepH,tmp16
        mov       iTimepL,tmp17
        cli

; If odd-fire is set (bit zero of Config13), then average RPM values
        lda       config13_f1
        and       #$01
        beq       NO_ODD_FIRE

YES_ODD_FIRE:
;average previous period with previous previous
        lda       tmp17    ; add together
        add       tmp14
        sta       tmp14
        lda       tmp16
        adc       tmp13
        sta       tmp13
        lda       tmp15
        adc       tmp12
        lsra               ; divide by 2
        sta       tmp12
        ror       tmp13
        ror       tmp14

NO_ODD_FIRE:
        lda       tmp12
        beq       rpmCalcFast		; If we have only 8-bit denominator,
					; then use native divide

;note, udvd32 re-written so that it uses
;tmp1,2,3,4 as intacc1
;tmp5,6,7,8 as intacc2
;tmp9,10,11 as temp storage instead of extra stack

rpmCalcSlow:
;need to divide period (tmp12,13,14) by 100 to obtain period time in 0.1ms
        ldx       #100T
        clrh
        lda       tmp12
        div				; A rem H = (H:A) / X
        sta       tmp12
        lda       tmp13
        div				; A rem H = (H:A) / X
        sta       tmp13
        lda       tmp14
        div				; A rem H = (H:A) / X
        sta       tmp14

        lda       tmp12
        bne       rpmCalcZero           ; if tmp12>0 then very slow indeed (<100rpm)


        clr       intacc1
        clr       intacc1+1

        mov       tmp13,intacc2
        mov       tmp14,intacc2+1

        lda       rpmk_f1
        sta       intacc1+2
        lda       rpmk_f1+1
        sta       intacc1+3

        jsr       udvd32		; 32 / 16 divide

        lda       intacc1+3		; get 8-bit RPM result
        bra       rpmCalcDone

rpmCalcFast:
;This (new) slower code takes the time between IRQs in 1us accuracy to calc the rpm
;this should eliminate the jumpiness at high rpm where one 0.1ms step > 100rpm
;
;Multiply rpmk x 100 then do 32/16 divide using 1us time
        lda      #100T
        ldx      rpmk_f1+1			; LSB of multiplicand.
        mul
        sta      intacc1+3			; LSB of result stored.
        stx	 intacc1+2			; Carry on stack.
        lda      #100T
        ldx      rpmk_f1			; MSB of multiplicand.
        mul
        add      intacc1+2			; Add in carry from LSB.
        sta      intacc1+2		; MSB of result.
        bcc      nox_of
        incx
nox_of:
        stx      intacc1+1
        clr      intacc1
;rpmk x 100 now dividend
;make iTime the divisor
        mov      tmp13,intacc2
        mov      tmp14,intacc2+1
        jsr      udvd32         ; 32/16 divide

        lda      intacc1+3		; get 8-bit RPM result
        bra      rpmCalcDone

rpmCalcZero:
        clra

rpmCalcDone:
        sta       rpm
(...)