>
> Or what is it:
>
> I just added new routines in the project from where i pulled out the code
> for MOMA filter i posted here recently.



> Sum16:  ;commented in english
> ;Summs a interval of 2-byte variables to 3-byte T4:T3:T2
> ;MSB at adress of LSB +1.
> ;Before call, state in W the total number of 2byte variables to sum.
> ;And set FSR to point to the low byte of first variabe to sum.
> ;(FSR may point in bank 0 or 1 regardless of back select :) )
> ;FSR get incremented by two for each variable summed
>
>         movwf T1        ;store number of variables to temp reg T1
>          movlw  4          ;Preload destination with 000004h
>         movwf T2           ;(New; for correct rounding in this application
>         clrf T3    ;where we sum 8 variables;
>         clrf T4    ;For normal SUM use we clear all T4:T3:T2)
> Sum16loop:
>         movf INDF,W     ;Get low byte,
>         addwf T2,F      ;and add to low byte result
>         ifcs            ;If carry,
>           incf T3,F     ; inc middle byte result
>         ifzs            ;If wrapped to Zero,
>           incf T4,F     ; inc high byte result

>         incf FSR,F      ;Point to next variable low byte
>         decfsz T1,F     ;Decrease counter for variables to add,
>           goto Sum16loop;if not done add next variable
>         return      ;the sum +4 is now in T4:T3:T2
>
> ;and after this routine:
> ;Divide by 8 = shift logical left 3 steps
>         STL 3, T1
> FilAdiv8loop:
>         cc              ;clear carry
>         rrf T4, F
>         rrf T3, F
>         rrf T2, F
>         decfsz T1, F
>           goto FilAdiv8loop
>
>         ;And the averaged result is in T3:T2
>

> for the shift right 3, you might want to just unroll the loop:
>
>     rrf   T4,F        ; DEVIDE BY 2
>     rrf   T3,F
>     rrf   T2,F
>
>     rrf   T4,W        ; DEVIDE AGAIN, (NOW EQUAL TO DEVIDE BY 4)
>     andlw 00011111b   ; Mask bit '11000000' and delete Bit '00100000' ?????
>     movwf T4          ; ...
>     rrf   T3,F
>     rrf   T2,F
>
>     rrf   T4,F        ; DEVIDE AGAIN, (...)
>     rrf   T3,F
>     rrf   T2,F
>
> It's 3 instructions longer, but twice as fast (11 cycles vs 23 cycles)
>
> Scott

>     rrf   T4,F
>     rrf   T3,F
>     rrf   T2,F
>
>     rrf   T4,F
>     rrf   T3,F
>     rrf   T2,F
>
>     rrf   T4,W        ; T4 now devided by 8
>     andlw 00011111b   ; remove what4s got from Carry
>     movwf T4
>     rrf   T3,F
>     rrf   T2,F

>However, since you're doing something like:
>        sum = sum + sample[i]
>
>where sum is 24 bits, and sample[i] is 16 bits, it might be better to do
>this:
>
>        movf    INDF,W     ;Get low byte,
>        incf    FSR,F
>
>        addwf   T2,F
>        movf    INDF,W
>
>        skpnc
>         incfsz INDF,W
>          addwf T3,F
>
>        skpnc
>         incf   T4,F
>
>        incf    FSR,F      ;Point to next variable low byte
>        ...
>
>This way you only have to deal with the carry once. (I think this is
>right, but it's not tested.)

>for the shift right 3, you might want to just unroll the loop:
>
>    rrf   T4,F
>    rrf   T3,F
>    rrf   T2,F
>
>    rrf   T4,W
>    andlw 00011111b
>    movwf T4
>    rrf   T3,F
>    rrf   T2,F
>
>    rrf   T4,F
>    rrf   T3,F
>    rrf   T2,F
>
>It's 3 instructions longer, but twice as fast (11 cycles vs 23 cycles)