;*********************************************************************** ; TEST_ASC_TO_BIN ; Routine to test ascii to 16 binary conversion ; 41 instructions and cycles. TEST_ASC_TO_BIN GLOBAL TEST_ASC_TO_BIN ; load test value MOVLW D'1' MOVWF TenK,B MOVLW D'2' MOVWF Thou,B MOVLW D'0' MOVWF Hun,B MOVLW D'7' MOVWF Ten,B MOVLW D'5' MOVWF Ones,B NOP ; these are not needed only used during dev. test CLRF Hi,B CLRF Lo,B ; bcd to binary conversion 16 bits ( i.e. max input is 65535 ) ; uses nibble math there lowest nibble i calculated first ; the 'overflow' added to the calculation for the second nibble ; etc. upto the third nibble. Then the last additions for the ; fourth nibble which only is affected by ( apart from overflow from lower nibbles ) ; the input byte tenk. ; uses factorisation of the decimal weight contants as per this table: ; 0000000000000001= 1 = 1 ; 0000000000001010= 10 = 8+2 ; 0000000001100100=わ 100 =わ 64+たす32+たす4 ; 0000001111101000=わ 1000 =わ 512+たす256+たす128+たす64+たす32+たす8 ; 0010011100010000=わ 10000 =わ 8192+たす1024+たす512+たす256+たす32 ; ; calculation perform according to the following pseudo code: ; Separate each nibble: ; ; 0000 0000 0000 0001= 1 = 1 ; 0000 0000 0000 1010= 10 = 8+2 ; 0000 0000 0110 0100=わ 100 =わ 64+たす32+たす4 ; 0000 0011 1110 1000=わ 1000 =わ 512+たす256+たす128+たす64+たす32+たす8 ; 0010 0111 0001 0000=わ 10000 =わ 8192+たす1024+たす512+たす256+たす32 ; ; Use the variable lo to calculate the result of the lowest nibble: ; lo = Thou*8 + Hun*4 + Ten*(8+2) + Ones ; the result and overflow ( top nibble ) is saved and calculation is perfromed on the second nibble ; by using the variable hi: ; hi = Tenk + Thou*(8+4+2) + Hun*(4+2) ; The low nibble from the result is added to the high nibble from the ; previous calculation of lo: ; lo = hi<<4 + lo ; etc. etc.. ; MOVF Thou,W ; w = thou ADDWF Ten,W ; w = thou + ten MOVWF Lo ; lo = thou + ten ADDWF Lo,W ; w = 2*(thou + ten) ADDWF Hun,W ; w = 2*(thou + ten) + hun MOVWF Lo ; lo = 2*(thou + ten) + hun ADDWF Lo,W ; w = 2*(2*(thou + ten) + hun) ADDWF Ten,W ; w = 2*(2*(thou + ten) + hun)+ten MOVWF Lo ; lo = 2*(2*(thou + ten) + hun)+ten ADDWF Lo,W ; w = 2*(2*(2*(thou + ten) + hun)) ADDWF Ones,W ; w = 2*(2*(2*(thou + ten) + hun)) + ones MOVWF Lo ; lo = 2*(2*(2*(thou + ten) + hun)) + ones = 8*Thou + 10*ten + 4*hun + ones ; low byte lowest nibble now fully calculated in lo ; now we calculate high nibble lo byte by using hi as temp storage MOVF Thou,W ; w =Thou ADDWF Thou,W ; w = 2 * Thou ADDWF Hun,W ; w = 2 * Thou + hun ADDWF Thou,W ; w = 2 * Thou + hun + thou MOVWF Hi ; hi = 2 * Thou + hun + thou ADDWF Hi,W ; w = 2*(2 * Thou + hun + thou) = 6*thou + 2*hun ADDWF Thou,W ; w = 6*thou + 2*hun + thou ADDWF Hun,W ; w = 6*thou + 2*hun + thou + hun MOVWF Hi ; hi = 6*thou + 2*hun + thou + hun ADDWF Hi,W ; w = 2* ( 6*thou + 2*hun + thou + hun )) = 14*thou + 6*hun ADDWF TenK,W ; w = 14*thou + 6*hun + tenk MOVWF Hi ; hi = 14*thou + 6*hun + tenk ; low byte high nibble fully calculated in hi ; now we need to add the low nibble to previous content in lo ( from low nibble calc. ) SWAPF Hi,W ; swap nibbles ( lownibble->high ) ANDLW 0xF0 ; mask out high nibble ADDWF Lo,F ; add result to lo byte ( note carry checked 4 rows down ! ) SWAPF Hi,W ; swap nibbles ( high nibble->low ) ANDLW 0x0F ; mask out low nibble BTFSC STATUS,C ; now we check the carry from the addition of the lo byte ADDLW 0x01 ; in case of ripple carry we add one to hi byte MOVWF Hi ; Hi = overflow(lo) ; now we have overflow from lo byte caculation in Hi therefor we cannot use the hi byte temporarily ; the following calculation must be performed in w only ( I just whish an temp was available :) ; or one could trash the input....) RLF TenK,W ; w = 2*tenk ADDWF TenK,W ; w = 3*tenk ADDWF TenK,W ; w = 4*tenk ADDWF TenK,W ; w = 5*tenk ADDWF TenK,W ; w = 6*tenk ADDWF TenK,W ; w = 7*tenk ADDWF Thou,W ; w = 7*tenk + thou ADDWF Thou,W ; w = 7*tenk + 2*thou ADDWF Thou,W ; w = 7*tenk + 3*thou ADDWF Hi,F ; add it to the overflow from lo SWAPF TenK,W ; w = 32 * tenk ADDWF Hi,F ; hi = 7*tenk + 3*thou + 32*Tenk ADDWF Hi,F ; hi = 7*tenk + 3*thou + 32*Tenk + 32*Tenk = 7*tenk + 3*thou + 64*Tenk NOP RETURN
.