【非典】32 bits BIN2BCD "二百五”算法 (164 bytes 341 周期)

1万 · 2009-4-26 22:03

;  SUB_BIN2BCD32:
      ;----------------------------------------------------
      ;  "二百五" 算法        DengMiao 2009-04-26 GuangZhou
      ;  Input:   bin 32:    R7:R6:R5:R4
      ;  Output:  Bcd   : R7:R6:R5:R4:R3
      ;  使用:  R0..R7, B,C,AC,OV       Stack:2 bytes
      ;         Code: 164 bytes  周期: 341
      ;----------------------------------------------------
       ORG 000H
         AJMP START

       ORG 80H
START:
        ; 1234567890 = &h4996 02D2
        ; R7R6R5R4R3     R7R6 R5R4
        MOV R7, #049H
        MOV R6, #096H
        MOV R5, #002H
        MOV R4, #0D2H
                  ;  &hffffffff = 4,294,967,295
        ACALL  SUB_BIN2BCD32

L_STOP:
        SJMP L_STOP ;$

  ORG 100H

SUB_BIN2BCD32:
      ;----------------------------------------------------
      ;  "二百五" 算法        DengMiao 2009-04-26 GuangZhou
      ;  Input:   bin 32:    R7:R6:R5:R4
      ;  Output:  Bcd   : R7:R6:R5:R4:R3
      ;  使用:  R0..R7, A, B, C,AC,OV      Stack:2 bytes
      ;         Code: 164 bytes  周期: 341
      ;----------------------------------------------------
      MOV A, PSW      ; @Ri Index to Rn
      ANL A, #11000B
      ADD A, #7
      MOV R0, A  ; @R0 Index to R7
     ;---------------------------
      ACALL SUB_DIV250  ;  R7:00:00    *250
      MOV R3, A         ;  R3:00:00    *250
                        ;     R6:R5:R4 *  1

      ACALL SUB_DIV250  ;  R7:R6:00    *250
      MOV R2, A         ;  R3:R2:00    *250
                        ;        R5:R4 *  1

      ACALL SUB_DIV250  ;  R7:R6:R5    *250
                        ;  R3:R2: A    *250
                        ;           R4 *  1

      ACALL SUB_R4_GE250

      ADD A,  R5
      XCH A,  R6
      ADDC A, R2
      XCH A,  R7
      ADDC A, R3   ; A:R7:R6 * 250
      RRC A
      XCH A, R7
      RRC A
      XCH A, R6
      MOV R2, A
      ANL A, #11111100B
      RRC A       ; R7:R6:A * 500
      XCH A, R7
      RRC A
      XCH A, R6
      RRC A
      MOV R5, A
      MOV A, R7
      RRC A        ; R6:R5:A  * 1000
      XCH A, R4    ; R6:R5:R4 *1000
      ACALL SUB_DIV10  ; R7 * 1
                       ; A * 100
                       ; B * 10
      MOV R1, A     ; R1 * 100 BCD
      MOV A, B
      SWAP A
      ORL A, R7
      MOV R3, A    ;        BCD  R1:R3 BCD xx xxx xxx 210
                   ;              2 10
      ;----------------------------
      INC R0
      INC R0 ; INDEX TO R6
      ACALL SUB_DIV250  ;     R6:00    *250
      MOV R2, A         ;     R2:00    *250
                        ;        R5:R4 *  1

      ACALL SUB_DIV250  ;     R6:R5    *250
                        ;     R2: A    *250
                        ;           R4 *  1

      ACALL SUB_R4_GE250
      ADD A,  R5
      XCH A,  R6
      ADDC A, R2     ; A:R6 * 250
      RRC A
      XCH A, R6
      MOV R2, A
      ANL A, #11111100B
      RRC A       ;   R6:A * 500

      XCH A, R6
      RRC A       ; A:R6
      MOV R5, A
      MOV A, R6

      RRC A        ;    R5:A  * 1000
      XCH A, R4    ;    R5:R4 *1000

      ACALL SUB_DIV10  ; R7 * 1
                       ; A * 100
                       ; B * 10
                          ;      R1:R3 BCD xx xxx xxx 210
                          ;       2 10
      SWAP A
      ORL A, B
      MOV R6, A           ;
      MOV A, R7           ;    R6:R1:R3 BCD xx xxx xxx 210
      SWAP A              ;    54:32 10
      ORL A, R1
      MOV R1, A
      ;----------------------------
      INC R0 ; INDEX TO R5
      ACALL SUB_DIV250  ;        R5    *250
                        ;         A    *250
                        ;           R4 *  1
      ACALL SUB_R4_GE250

      ADD A, R5      ; A*250
      MOV R2, A
      ANL A, #11111100B
      RRC A       ;        A * 500
      RRC A        ;       A  * 1000
      XCH A, R4    ;       R4 *1000

      ACALL SUB_DIV10  ; R7 * 1
                       ; A * 100
                       ; B * 10
                          ;    R6:R1:R3 BCD xx xxx xxx 210
                          ;    54:32 10

      SWAP A
      ORL A, R4
      SWAP A
      XCH A, R7         ;  R7:R6:R5:R4:R3
                        ;  09
      SWAP A
      ORL A, B
      SWAP A
      XCH A, R6
      MOV R5, A

      MOV A, R1
      MOV R4, A
      RET

SUB_DIV10:
                 ; A * 1    (R2 AND 3) * 250
      MOV B, #10
      DIV AB
      XCH A, R2  ; R2 * 10  B * 1
      ANL A, #3
      XCH A, B
      MOV R7, A  ; R7 * 1
      MOV A, #25
      MUL AB
      ADD A, R2 ; A * 10
      MOV B, #10; R7 * 1
      DIV AB    ; A * 100
      RET       ; B * 10

SUB_R4_GE250:
      XCH A, R4
      ADD A, #6
      JC $+4
        SJMP $ + 4
        INC R4
        NOP
      ADD A, #250
      XCH A, R4
      RET

SUB_DIV250:
      MOV B, #6
      MOV A, @R0 ;   MOV A, R7     R7*250
      MUL AB     ;
      DEC R0
      ADD A, @R0   ; ADD A,  R6
      XCH A, B
      ADDC A, #0 ; A:B

      MOV @R0, A
      ADD A, @R0
      ADD A, @R0
      RL A

      ADD A, B
      JC $ + 4 ;L_INC_PR0
        SJMP $+5 ; L_NOT_INC_PR0
;L_INC_PR0:
      INC @R0
      ADD A, #6
;L_NOT_INC_PR0:
      XCH A, @R0
      RET
;----------------------------------------------------
      END

1万 · 2009-4-26 22:12

优化后,应为8位的51最优算法

1万 · 2009-4-26 22:19

1万 · 2009-4-26 22:33

       "250" 算法说明
                  1000 内数可用 “250进数”十位的低2 bits 加
                                “250进数”个位表示
        250 * 4 = 1000 = 1024 - 24
  256 = 250 + 6                 24 = 3*8 = 6 * 4
              6 = (1+1+1)*2

Rn 的地址为：
  PSW:        C  AC  F0  RS1 RS0  OV  F1   P
  Rn 的地址:  0   0   0  RS1 RS0  n2  n1  n0
                                  -----------

1万 · 2009-4-26 23:26

时间也精确才是稳定的东东

只看该作者 · 2009-4-27 00:41

void bcd32bit(unsigned long value, char bcd[5])
{
  char i;
  for(i=0;i<5;i++)
  {
     bcd=value%250;
     value/=250;
  }
}

先不说多少周期多少字节，看算法对不对，因为我不是很看得懂你的算法说明。
我不知道你们有什么PK，我参与一下技术讨论。

2万 · 2009-4-27 23:33

相关链接:https://bbs.21ic.com/club/bbs/ShowAnnounce.asp?v=&ID=2464366

只看该作者 · 2009-4-28 12:43

只看该作者 · 2009-4-28 15:33

俺写了个C程序转换，都快900周期了。

1万 · 2009-4-28 17:09

;  SUB_BIN2BCD32B:
      ;----------------------------------------------------
      ;  "二百五" 算法        DengMiao 2009-04-28 GuangZhou
      ;  Input:   bin 32:    R7:R6:R5:R4
      ;  Output:  Bcd   : R7:R6:R5:R4:R3
      ;  使用:  R0..R7, A, B, C,AC,OV      Stack:2 bytes
      ;         Code: 142 bytes  周期: 328
      ;----------------------------------------------------
       ORG 000H
         AJMP START

       ORG 80H
START:
        ; 1234567890 = &h4996 02D2
        ; R7R6R5R4R3     R7R6 R5R4
        MOV R7, #049H
        MOV R6, #096H
        MOV R5, #002H
        MOV R4, #0D2H
    SJMP L_TEST
        MOV R7, #0FFH
        MOV R6, #0FFH
        MOV R5, #0FFH
        MOV R4, #0FFH
L_TEST:
                  ;  &hffffffff = 4,294,967,295
        ACALL  SUB_BIN2BCD32B

L_STOP:
        SJMP L_STOP ;$

  ORG 100H
SUB_BIN2BCD32B:
      ;----------------------------------------------------
      ;  "二百五" 算法        DengMiao 2009-04-28 GuangZhou
      ;  Input:   bin 32:    R7:R6:R5:R4
      ;  Output:  Bcd   : R7:R6:R5:R4:R3
      ;  使用:  R0..R7, A, B, C,AC,OV      Stack:2 bytes
      ;         Code: 142 bytes  周期: 328
      ;----------------------------------------------------
      MOV A, PSW      ; @Ri Index to Rn
      ANL A, #11000B
      ADD A, #7
      MOV R0, A  ; @R0 Index to R7
     ;---------------------------
      ACALL SUB_DIV250B ;  R7:00:00    *250
      MOV R3, A         ;  R3:00:00    *250
                        ;     R6:R5:R4 *  1

      ACALL SUB_DIV250B ;  R7:R6:00    *250
      MOV R2, A         ;  R3:R2:00    *250
                        ;        R5:R4 *  1
      ACALL SUB_DIV250B ;  R7:R6:R5    *250
                        ;  R3:R2: A    *250
                        ;           R4 *  1
                ;----------------------
      ACALL SUB_R4_GE250B
      ;ADD A, R5

      XCH A, R6
      ADDC A, R2
      XCH A, R7
      ADDC A, R3
      ACALL SUB_BCD1000    ;      R7:R6:R5 * 500
                           ;           (R5 and 1) = 0  C = 0
                           ; BCD: A*100  B*10  R2*1   __OK__
      MOV R3, A
      MOV A, B
      SWAP A
      ORL A, R2
      XCH A, R7      ; BCD:  R3 * 100   R7*1
                     ;     C:A:R6:R5 * 500
   ;------------------------------------------
      ACALL SUB_DIV250B_6 ;  R6:00    *250 *1000
      MOV R2, A           ;  R2:00    *250 *1000
                          ;     R5:R4 *  1 *1000
      ACALL SUB_DIV250B   ;  R6:R5    *250 *1000
                          ;  R2: A    *250 *1000
                          ;        R4 *  1 *1000
      ACALL SUB_R4_GE250B
      ; ADD A, R5

      XCH A, R6
      ADDC A, R2
      ACALL SUB_BCD1000_2 ; BCD: A*100 * 1000  R3*100
       ;R6:R5 * 500  C=0  ;      B*10  * 1000
       ;   (R5 and 1) =0  ;     R2*1   * 1000  R7*1
      SWAP A
      ORL A, B
      XCH A, R3           ; BCD:
      SWAP A              ;      R7 * 1
      ORL A, R2           ;      R6 * 100
      SWAP A              ;
      XCH A, R6           ;      R3 * 10000
    ;---------------------------------------
            ;A:R5 * 500
      ACALL SUB_DIV250B_5 ;  R5   *250 *1000000
                          ;   A   *250 *1000000
                          ;     R4*  1 *1000000
      ACALL SUB_R4_GE250B
      ;ADD A, R5

      ACALL SUB_BCD1000_3 ;    A * 100 *1000000
       ; R5 * 500*1000000 ;    B * 10  *1000000
       ; (R5 and 1)=0     ;   R2 * 1   *1000000
      XCH A, R5
      RR A
      SWAP A
      ORL A, R5
      XCH A, R7
      XCH A, R3
      MOV R5, A   ; BCD:
      MOV A, B    ;   R7 *100000000
      SWAP A      ;   R6 *1000000
      ORL A, R2   ;   R5 *10000
      XCH A, R6   ;   R4 *100
      MOV R4, A   ;   R3 *1
      RET

;---------------------------------------
SUB_R4_GE250B:
      XCH A, R4
      ADD A, #6
      JNC R4_GE250_JNC
        INC R4
        XCH A, R4
        ADD A, R5
        RET
R4_GE250_JNC:
      ADD A, #250
      XCH A, R4
      ADD A, R5
      RET
;---------------------------
SUB_DIV250B_6:
      INC R0                 ;
      RRC A
      XCH A, R6
SUB_DIV250B_5:
      INC R0
      RRC A
      XCH A, R5
      RRC A
      MOV R4, A            ;   R6:R5:R4  * 1000
                           ; BCD:  R7*100

SUB_DIV250B:
      MOV B, #6
      MOV A, @R0 ;   MOV A, R7     R7*250
      MUL AB     ;
      DEC R0
      ADD A, @R0   ; ADD A,  R6
      XCH A, B
      ADDC A, #0 ; A:B
      MOV @R0, A
      ADD A, @R0
      ADD A, @R0
      RL A
      ADD A, B

      JC DIV250B_JC
        SJMP DIV250B_JNC
DIV250B_JC:
        INC @R0
        ADD A, #6
DIV250B_JNC:
      XCH A, @R0
      RET
;--------------------------

SUB_BCD1000:
      RRC A
      XCH A, R7

SUB_BCD1000_2:
      RRC A
      XCH A, R6
SUB_BCD1000_3:
      MOV R5, A
      RRC A
      XCH A, R5  ; R7:R6:R5 * 250 * 2

      ANL A, #3  ; A * 250
                    ;       R4    * 1
      MOV B, #25
      MUL AB        ; A * 10  B = 0

      XCH A, R4   ; R4 * 10
      MOV B, #10
      DIV AB      ; B * 1 A * 10
      ADD A, R4

      MOV R2, B   ; R3 BCD * 1
      MOV B, #10
      DIV AB      ; A BCD * 100
                  ; B BCD * 10
      RET
;---------------------------------------
      END

只看该作者 · 2009-4-28 18:25

给hotpower改一下
unsigned char DataAdd1(unsigned char *DataOneDptr,unsigned char *DataTwoDptr,unsigned char DataLend)
{
unsigned char Tmp;
unsigned char data *ptrOne=DataOneDptr+DataLend-1,*ptrTwo=DataTwoDptr+DataLend-1;
unsigned int Sum=0;
  while(DataLend){
    DataLend--;
    Tmp = (*ptrOne & 0x0f) + (*ptrTwo & 0x0f)+Sum;//为半进位做准备
    if(Tmp>9)
       Tmp+=6;
    Sum=(*ptrOne & 0xf0) + (*ptrTwo & 0xf0)+Tmp ;

if (Sum >= 0xa0) {//BCD码高4位调整
  Sum += 0x60;

}
*ptrTwo=Sum;
ptrOne--;
ptrTwo--;
Sum>>=8;

}

return Sum;

}

1万 · 2009-4-28 20:34

;典型算法要 987周期

       InPut EQU  30H ; 30H..33H
       OutPut EQU 40H ; 40H TO 44H ; [44H]:[43H]....:[40H] BCD

       ORG 000H
         AJMP START

      ORG 100H

START:
        MOV R1, #INPUT
        MOV R2, #4
        MOV A, #0FFH

L05:     MOV @R1, A
         INC R1
        DJNZ R2, L05

        ACALL BIN2BCD32

L_STOP:
        SJMP L_STOP ;$

BIN2BCD32:
        CLR A
        MOV OUTPUT, A
        MOV OUTPUT+1, A
        MOV OUTPUT+2, A
        MOV OUTPUT+3, A
        MOV OUTPUT+4, A

        MOV R1, #(INPUT+3)
        MOV A, @R1
        MOV B, #2
        ACALL BIN2BCD5_2
        DEC R1
        MOV A, @R1
        ACALL BIN2BCD5
        DEC R1
        MOV A, @R1
        ACALL BIN2BCD5
        DEC R1
        MOV A, @R1
BIN2BCD5:
          INC B
BIN2BCD5_2:
          SETB C
          RLC A
L20:
          MOV R0, #OUTPUT
          MOV R2, B

L30:
            XCH A, @R0
            ADDC A, ACC
            DA A
            XCH A, @R0
            INC R0
           DJNZ R2, L30
           RLC A
         JNZ L20
         RET

       END

只看该作者 · 2009-4-28 20:46

C程序也要不了987周期呀。

1万 · 2009-4-28 21:03

1万 · 2009-4-28 21:44

       InPut EQU  30H ; 30H..33H
       OutPut EQU 40H ; 40H TO 44H ; [44H]:[43H]....:[40H] BCD

       ORG 000H
         AJMP START

      ORG 80H

START:
         MOV R1, #INPUT
         MOV R2, #4
         MOV A, #0FFH

         MOV R2, #4
L05:     MOV @R1, A
         INC R1
        DJNZ R2, L05

        ACALL BIN2BCD32

        SJMP $
   ORG 100H

BIN2BCD32:
        MOV R0, #OUTPUT
        MOV R2, #5   ;  5 BYTES BCD
BCD_R2A:
          MOV @R0, #0
          INC R0
        DJNZ R2, BCD_R2A

        MOV R2, #(4*8)  ; 32 bits bin
BCD_R2B:
          MOV R0, #INPUT

          MOV R3, #4  ; 4 BYTES BIN
BCD_R3A:    MOV A, @R0
            RLC A
            MOV @R0, A
            INC R0
          DJNZ R3, BCD_R3A

          MOV R0, #OUTPUT

          MOV R3, #5  ; 5 BYTES BCD
BCD_R3B:
            MOV A, @R0
            ADDC A, @R0
            DA A
            MOV @R0, A
            INC R0
          DJNZ R3, BCD_R3B

       DJNZ R2, BCD_R2B
       RET

      END

1万 · 2009-4-28 21:51

1万 · 2009-4-28 22:00

        250算法   标准算法  改进的标准算法
BYTES     142       35           49
CYS       328     2105          987

1万 · 2009-4-28 22:14

1万 · 2009-4-28 22:34

终结！！！！！

1万 · 2009-5-1 14:37

       InputBIN   EQU 8H ;    200 BYTES  .... 8 TO 207  (08H to 0CFH)
       InputLen   EQU 200 ; 200 Bytes
       OutputBCD  EQU 8H ;    241 BYTES  .....8 TO 248  (08H to 0f8h)
       STACK      EQU 249 ;   7 BYTE     .. 249 TO 255  (0F9H to 0ffh)

       ORG 000H
         AJMP START

       ORG 30H
START:
        MOV SP, #(STACK-1)

        CLR A
        MOV PSW, A
        MOV R0, A
CLR_RAM:
          MOV @R0, A
        DJNZ R0, CLR_RAM
;------------------------------------------
; TEST DATA INPUT:   200 Bytes 0ffh
        MOV R0, #InputBin
        MOV R2, #InputLen

        MOV A, #0FFH   ; 200 BYTES 0FFH
LLLP_R2:
          MOV @R0, A
          INC R0
        DJNZ R2, LLLP_R2
;-----------------------------------
; CALL SUB
        MOV R0, #InputBin
        MOV A,  #InputLen
        MOV R1, #OutputBCD
        ACALL SUB_BIN2BCD_N

L_STOP:
        SJMP L_STOP ;$

;-------------------------------------------------
   ORG 100H
SUB_BIN2BCD_N:
      ;----------------------------------------------------
      ;  "二百五" 算法        DengMiao 2009-05-01 GuangZhou
      ;  Input:     @R0:  Input Bin data (LSB)
      ;              A:   BYTES of INPUT
      ;  Output:    @R1:  Output BCD Data
      ;              A:   BYTES OF OUTPUT
      ;  使用:  R0..R7, A, B, C,AC,OV,F0   Stack:2 bytes
      ;    Code:260 bytes  周期: 200bytes 0ffh==693,351周期
      ;----------------------------------------------------
      ACALL  BIN2BCD_BYTE_NUM  ; A == BCD LEN  R5==BIN_LEN
      MOV R2, A      ; R2: BCD LEN

      MOV A, R5
      XCH A, R1      ; R1: BIN LEN
      MOV R7, A      ; R1_BAK

      SUBB A, R0
      JZ L_R0_EQ_R1
        MOV A, R7
        JNC L_R1_GT_R0
           MOV R1, A
           MOV A, R5
           MOV R3, A
LP_R3_COPY:
             MOV A, @R0
             MOV @R1, A
             INC R0
             INC R1
           DJNZ R3, LP_R3_COPY
           SJMP L_R0_EQ_R1

L_R1_GT_R0:
           ADD A, R1
           XCH A,  R1
           MOV R3, A
           ADD A, R0
           MOV R0, A
LP_R3_COPY_V:
             DEC R0
             DEC R1
             MOV A, @R0
             MOV @R1, A
           DJNZ R3, LP_R3_COPY_V

L_R0_EQ_R1:
       MOV A, R7
       ADD A, R5
       MOV  R0, A
       MOV A, R2
       SUBB A, R5
       MOV R3, A
LP_R3_CPY:
         MOV @R0,#0
         INC R0
      DJNZ R3, LP_R3_CPY
      MOV A, R7
      MOV R1, A
      MOV A, R2
      RR A
      ANL A, #07FH
      MOV R3, A

LP_R3_SWAP:
        DEC R0
        MOV  A, @R1
        XCH A, @R0
        MOV @R1, A
        INC R1
      DJNZ R3, LP_R3_SWAP
;---------------------------------------------
     MOV A, R7
     ADD A, R2
     SUBB A, R5
     DEC A
     MOV R1, A
     CLR F0           ; R1 = 43H  ; R7=40H  R2 = 14H  R5=10H
     MOV R4, #0FFH
     DEC R5

LP_R5:  ;<<<<===============
       MOV A, R5
       MOV R3, A
       ;DEC R3

LP_R5B:
       INC R1
       MOV A, @R1
       JNZ LP_R3B2
         CJNE R3, #1, $ + 5
           SJMP LP_R3B2
           DEC R5
           DJNZ R3, LP_R5B
           SJMP $

LP_R3B:
        MOV A, @R1
LP_R3B2:
        MOV B, #6
        MUL AB
        INC  R1
        ADD A, @R1
        XCH A, B
        ADDC A, #0
        MOV @R1, A
        ADD A, @R1
        ADD A, @R1
        RLC A
        ADD A, B
        JNC $ + 5
          ADD A, #6
          INC @R1
        XCH A, @R1
        XCH A, R0
        MOV A, R1
        XCH A, R0
LP_CA:
          DEC R0
          ADDC A, @R0
          MOV @R0, A
          CLR A
       JC LP_CA
     DJNZ R3, LP_R3B

LP_R3B_EXIT:
     MOV A, R5   ;0K
     INC A
     MOV R3, A

     CPL A
     INC A
     ADD A, R1
     MOV R0, A

       MOV B, #0
       MOV A, @R0
LP_R3C:
        MOV C, B.0
        RRC A
        MOV B.0, C
        MOV C, B.1
        RRC A
        MOV B.1, C
        INC R0
        XCH A, @R0
    DJNZ R3, LP_R3C ; OK
    ; (B AND 3) * 250 + A*1
    ANL B, #3 ; B * 250 + A
    ACALL SUB_999
    MOV A, R1
    SUBB A, R5
    MOV R1, A
   DJNZ R5, LP_R5
LP_R5_EXIT:
;----------------LP_R5_EXIT
   MOV A, @R1
   MOV B, A
   INC R1
   MOV A, @R1
   ACALL SUB_999
   MOV A, R1
   SUBB A, R0
   JZ L_EXIT_SUB
     INC R0
     XCH A, R4
     MOV @R0, A
     CJNE R4, #2, L_EXIT_SUB
       INC R0
       MOV A, R6
       MOV @R0, A
L_EXIT_SUB:
   MOV A, R2
   RET

;======================================
BIN2BCD_BYTE_NUM:
     ; INPUT:  A   == BIN BYTE NUM
     ; OUTPUT: R5  == BIN BYTE NUM
     ;          A  == BCD BYTE NUM
     ;-----------------------------
     MOV R5, A     ;      K = I * 84&  (256 * 16)
                   ;      K = (I + K)  5 + I + 1
     MOV B, #84
     MUL AB

     MOV A, #5
     XCH A, B
     ANL A, #0F0H
     SWAP A
     ADD A, R5
     DIV AB
     ADD A, R5
     INC A
     RET
;========================================
SUB_999:
    ; B * 250 + A * 1
    MOV R3, A
    MOV A, #25
    MUL AB

    XCH A, R3
    MOV B, #10
    DIV AB     ; B * 1

    ADD A, R3
    MOV R3, B   ; R3 * 1
    MOV B, #10
    DIV AB

    CJNE A, #10, L_NE10
      SETB C
L_EQ10:
        CLR A
        ADDC A, @R0
        MOV @R0, A
        DEC R0
     JC L_EQ10
     CLR A
L_NE10:

      MOV R0, A
      MOV A, R7
      XCH A, R0
             ; R3 * 1  B*10 A*100
    JBC F0, L_F0_1
      SETB F0
      CJNE R4, #0FFH, L_R4_NE255
        MOV R4, A
        SJMP L_R4_NE255B
L_R4_NE255:
        XCH A, R4
        MOV @R0, A
        INC R0
        INC R7
        MOV A, R6
        MOV @R0, A
        INC R7

L_R4_NE255B:
        MOV A, B
        SWAP A
        ADD A, R3
        XCH A, R4
        MOV R6, A
        RET ; R6:R4 BCD  C = 0

L_F0_1:
       SWAP A
       ADD A, B
       XCH A, R3
       SWAP A
       ADD A, R6
       XCH A, R4     ; R3:R4 BCD
       MOV @R0, A
       INC  R7
       MOV A, R3
       MOV R6, A    ; R6:R4 BCD  C=0
     RET

     END

【非典】32 bits BIN2BCD "二百五”算法 (164 bytes 341 周期)

相关下载

相关帖子

上面asm未优化及test, 请C人改写为C

这个好象是LZ大侠与热动力大侠PK的那段吧代码吧。

计算方法说明

我一般写“等时间”模块：包括调用精确341周期

250算法

上次是N位压缩BCD加法~~~俺最喜欢邓苗的250算法~~~

好帖要顶，呵呵，牛人啊~~！

还是汇编快

【非典】BIN2BCD32 "二百五”算法 (142 bytes 328 周期)(优化)

压缩BCD加法

改进的标准算法: 987周期 49 bytes

不会那么慢吧

1K也无所谓了

标准算法: 35 byte 2105 周期

还是在程序结构是花点工夫吧

250算法比标准算法 快 6.4 倍 (2105/328=6.4)

『原创』250算法 与 改进的标准算法 为原创算法,版权仅归本

用 250 bytes 实现 “250算法”，把速度推到极限，才250。

200 bytes bin to BCD(十进数482位) 51 ASM 要693,351周期

技术奇才奖章

核心会员奖章

伴坛终老

湍急之河流

技术导师奖章

十世金身

坚毅之洋流

突出贡献奖章

荣誉元老奖章

技术领袖奖章

上次是N位压缩BCD加法~俺最喜欢邓苗的250算法~

250算法比标准算法快 6.4 倍 (2105/328=6.4)

『原创』250算法与改进的标准算法为原创算法,版权仅归本