AVRFreaks.net

DIV10: LDI B,51
   MUL A,B
   INC R1   ;R1=A/5
   LSR R1   ;R1=(A/5)/2 = A/10
; Luke's insertion
   MOV C, R1
   LDI B, 10
   MUL C, B
   SUB A, R0
   ; 'A' contains the (signed) remainder.
   ; sign of the remainder indicates whether it is an:
   ; - under-estimate (positive remainder), or
   ; - over-esitmate (negative remainder)
   ; 'C' contains the quotient
   ; We can return here with a totally valid and numerically correct result.
   ; But for the sticklers among us, let's convert it
   ; to a "cannonical form".
   SBRS A, 7 ; test the sign of result.
   RJMP PositiveRemainder
; We have a negative remainder; subtract 1 from
; the quotient and add 10 to the remainder.
   DEC C
   ADD A, B
PositiveRemainder
; The result is now in perfect "cannonical" form.
   RET

;-----------------------------------;
; RETRO (SYNTHETIC) DIVISION BY 10  ;
; ANSWER IN R1, R0=REM, A:PRESERVED ;
;-----------------------------------;
DIV10:  PUSH B
        LDI  B,26   ;MUL BY 26
        MUL  A,B    ;R1=A/10
        PUSH R1     ;BRUTE-FORCE CALC OF REMAINDER     
        LDI  B,10   ;CALC REM
        MUL  R1,B   ;R0=10xR1(QUOT)
        POP  R1     ;RESTORE QUOT
        SUB  R0,A   ;SUBTRACT REMx10
NODJST: NEG  R0     ;MAKE POSITIVE
         BRPL NONEG ;STILL NEG?
        ADD  R0,B   ;OOPS MAKE
        DEC  R1     ;ADJUSTMENTS
NONEG:   RET

:ClrHome
:0->G
:0->F
:6554->B
:For(A,1,20000)
:If (iPart(A/10)=iPart((A*B)/65536))
:Then
:G+1->G
:Else
:F+1->F
:If F<4
:Output(F+2,1,A
:End
:Output(1,1,G
:Output(2,1,F
:End

div10:
; put your value in temp
;   ldi temp, 11                ; example value is in temp
ldi mul_constL, low(6554)
ldi mul_constH, high(6554)         ; load multiply value
mul temp, mul_constL            ; mul lower
movw result_M2:result_L2, R1:R0      ; store
mul temp, mul_constH            ; mul higher
clr   result_H2                  
add result_M2, R0               ; add value
adc result_H2, R1
ret
; result is now in result_H2

div10:
; input value in temp
ldi tempL, low(6554)
ldi tempH, high(6554)            ; load multiply value
mul temp, tempL                  ; mul lower
mov tempL, R1                  ; store
mul temp, tempH                  ; mul higher
clr tempH                  
add tempL, R0                  ; add value
adc tempH, R1
ret
; result is now in tempH

uint8_t div10_fp(uint8_t number)
{
    // 1/10th with 11 mantissa bits
    // 1/10th = 0/2 + 0/4 + 0/8 + 1/16 + 1/32 + 0/64 + 0/128 + 1/256 + 1/512 +
    // 0/1024 + 1/2048
    // 0.00011001101
    uint16_t tenth = 0xcd;
    // result with 11 mantissa bits
    uint16_t result = number * tenth;
  9a:   99 27           eor     r25, r25
  9c:   2d ec           ldi     r18, 0xCD       ; 205
  9e:   30 e0           ldi     r19, 0x00       ; 0
  a0:   82 9f           mul     r24, r18
  a2:   a0 01           movw    r20, r0
  a4:   83 9f           mul     r24, r19
  a6:   50 0d           add     r21, r0
  a8:   92 9f           mul     r25, r18
  aa:   50 0d           add     r21, r0
  ac:   11 24           eor     r1, r1
  ae:   ca 01           movw    r24, r20
    // Drop mantissa to round down.
    return result >> 11;
  b0:   89 2f           mov     r24, r25
  b2:   99 27           eor     r25, r25
  b4:   86 95           lsr     r24
  b6:   86 95           lsr     r24
  b8:   86 95           lsr     r24
}
  ba:   99 27           eor     r25, r25
  bc:   08 95           ret

; the input number must be in register "input"
; value/10 is in register "result"
; register temp1 and R1:R0 are clobbered
div10:
   ldi temp1, 205
   mul temp1, input
   lsr R1
   lsr R1
   lsr R1
   mov result, R1
   ret

:ClrHome
:0->G
:0->F
:For(N,0,1200)
:If (iPart(N/10)=iPart((N*205)/2048))
:Then
:G+1->G
:Else
:F+1->F
:If F<5
:Output(2+F,1,N
:End
:Output(1,1,"G="
:Output(1,3,G
:Output(2,1,"F="
:Output(2,3,F
:End

uint8_t div3(uint8_t number)
{
    // Compute the intermediate value, with 9 mantissa bits.
    uint16_t intermediate = (uint16_t) number * 0xab;
    // Return the result, chopping off the mantissa bits.
    return intermediate >> 9;
}

uint8_t div10(uint8_t number)
{
    // Compute the intermediate value, with 11 mantissa bits.
    uint16_t intermediate = (uint16_t) number * 0xcd;
    // Return the result, chopping off the mantissa bits.
    return intermediate >> 11;
}

uint8_t function(void) {
    volatile uint8_t val = 123;
    return val / 10;
}

uint8_t function(void) {
    volatile uint8_t val = 123;
    return ((uint16_t) val * 0xcd) >> 11;
}