CRC Calculation - Need a little help

[Steve43]

Hi all,

I need to calculate a CCITT-16 reversed (0x8408) checksum in PBP but need a little assistance. I've uncovered an assembly routine that would seem to do what I need ( see http://www.dattalo.com/technical/software/pic/crc.php ) but I'm not very familiar with the integration of assembly routines into a PBP program and am hoping someone can help me out a little here.

What I need to do is send an array of bytes to this routine and come up with a two-byte checksum as a result. An example would be to send the bytes 'AA 05 01' to the routine and have the checksum 'D5 50' returned. Problem is that I don't know how to pass the variables back and forth between the BASIC program and the assembly routine, etc.

Sorry if this is a bit elementary... (or perhaps it isn't..?)

Anyway, would greatly appreciate any help...

Thanks,
Steve

[Bruce]

Just place an _underscore before any BASIC variables you want to access in assembler,
and an _underscore in front of the assembler label you want to call from BASIC.

Give this a shot.

crc_hi  VAR BYTE bank0
crc_lo  VAR BYTE bank0
temp    VAR BYTE bank0
ToCrc   VAR BYTE bank0
CRC     VAR WORD
X       VAR BYTE
Space   CON " "

Main:
    crc_lo = 0
    crc_hi = 0
    ToCrc = $ff
    CALL crc_8408

    ' Show HEX value
    HSEROUT ["Input = ",IHEX2 ToCrc,Space,"Output = ",_
    IHEX4 (crc_hi << 8 | crc_lo),13,10]
    
    ' Show ASCII values
    FOR X = 2 to 8
      ToCrc = X + "0" ' Convert X val to ASCII
      CALL crc_8408
      GOSUB Show
    NEXT X
    PAUSE 1000
    GOTO Main
    
Show:
    HSEROUT ["Input = ",DEC ToCrc-"0",Space,"Output = ",_
    IHEX4 (crc_hi << 8 | crc_lo),13,10]
    RETURN

ASM
_crc_8408
    movf	_ToCrc,W	;Load value into W
    xorwf	_crc_lo,W	;W = CD ^ ab ==> xy
    movwf	_temp		;temp = xy
    swapf	_temp,F		;W = yx
    rrf		_temp,w
    andlw	0x78		;y<<3
    xorwf	_crc_hi,W	;W = AB ^ (y<<3)
    movwf	_crc_lo		;LO = AB ^ (y<<3)
    swapf	_temp,W		;W = xy
    xorwf	_temp,W		;W = (y^x) | (x^y) = kk
    movwf	_crc_hi		;HI = kk
    andlw	0x0f		;W = 0k
    xorwf	_crc_lo,W	;W = AB ^ (y<<3) ^ k
    btfsc	_crc_hi,0	;
    xorlw	0x80		;W = AB ^ (y<<3) ^ k ^ (k<<7)
    movwf	_crc_lo		;LO = AB ^ (y<<3) ^ k ^ (k<<7)
    swapf	_temp,W		;W = xy
    andlw	0xf0		;W = x0
    xorwf	_crc_hi,F	;W = y<<4 | x^y
    rrf		_crc_hi,W	;W = (y<<4 | x^y) >> 1
    andlw	7		    ;W = x^y >> 1
    swapf	_crc_hi,F	;W = x^y<<4 | y
    xorwf	_crc_hi,F	;HI = kx ^ k>>1 = (k<<4) ^ y ^ (k>>1)
    return
ENDASM

Just be aware of bank & page switching as your program grows.

[Steve43]

Bruce,

Thanks so much for your help! Your example is quite clear and I am able to execute it properly on my device.

One more question if you don't mind... the CRC calculation algorithm seems to want to be passed one byte at a time, but I need to calculate a checksum for a series of bytes (as a complete set, not individually) and I'm not sure how to accumulate the result of each one-byte cycle through the checksum routine.

As a real-world example, I need to be able to send the three bytes $AA $05 $01 into the routine and obtain the resultant accumulated checksum for all three bytes, which should produce a result of $D5 $50 (I am using a PC-based checksum program to determine what the proper output should be), but no matter what I do I can't seem to achieve this result.

I then need to append this checksum (with the high and low order bytes reversed) to the original three-byte command for a final result of $AA $05 $01 $50 $D5 to go out the serial port.

Once again, the help is really appreciated...

[Bruce]

The result is already cumulative. If you compare the results
to the assembly version in your link, you'll see the last version
I posted outputs the same values. crc_hi & crc_lo are only
cleared at the start - so they are cumulative until cleared.

If you change any value, the final result will also change since
crc_hi & crc_low hold the cumulative values from every byte
passed to the assembly routine.

To change the order of the final result, simply change the order
you send them out in. crc_hi holds the high byte. crc_lo holds the
low byte. You can send them both out serially in any order you
need.

crc_hi  VAR BYTE bank0
crc_lo  VAR BYTE bank0
temp    VAR BYTE bank0
ToCrc   VAR BYTE bank0
C_Vars  VAR BYTE[3] ' Holds byte data passed to crc_8408
X       VAR BYTE

Main:
    crc_lo = 0
    crc_hi = 0
    FOR X = 0 TO 2
      LOOKUP X,[$AA,$05,$01],ToCrc
      C_Vars[X] = ToCrc ' Stash each value for Show output
      CALL crc_8408
    NEXT X
    GOSUB Show
    PAUSE 1000
    GOTO Main
   
Show:
    HSEROUT [IHEX2 C_Vars[0],IHEX2 C_Vars[1],_
    IHEX2 C_Vars[2],IHEX crc_lo,IHEX2 crc_hi,13,10]
    RETURN

ASM
_crc_8408
    movf	_ToCrc,W	;Load value into W
    xorwf	_crc_lo,W	;W = CD ^ ab ==> xy
    movwf	 _temp		;temp = xy
    swapf	_temp,F		;W = yx
    rrf	_temp,w
    andlw	0x78		;y<<3
    xorwf	_crc_hi,W	;W = AB ^ (y<<3)
    movwf	 _crc_lo		;LO = AB ^ (y<<3)
    swapf	_temp,W		;W = xy
    xorwf	_temp,W		;W = (y^x) | (x^y) = kk
    movwf	 _crc_hi		;HI = kk
    andlw	0x0f		;W = 0k
    xorwf	_crc_lo,W	;W = AB ^ (y<<3) ^ k
    btfsc	_crc_hi,0	;
    xorlw	0x80		;W = AB ^ (y<<3) ^ k ^ (k<<7)
    movwf	 _crc_lo		;LO = AB ^ (y<<3) ^ k ^ (k<<7)
    swapf	_temp,W		;W = xy
    andlw	0xf0		;W = x0
    xorwf	_crc_hi,F	;W = y<<4 | x^y
    rrf	_crc_hi,W	;W = (y<<4 | x^y) >> 1
    andlw	7                        ;W = x^y >> 1
    swapf	_crc_hi,F	;W = x^y<<4 | y
    xorwf	_crc_hi,F	;HI = kx ^ k>>1 = (k<<4) ^ y ^ (k>>1)
    return
ENDASM

This doesn't return crc_hi = $D5 & crc_lo = $50 though. I get
crc_lo = $4F & crc_hi = $7F.

The above returns: $AA$05$01$7F$4F with your hi & lo bytes
swapped around.

If you change it, and plug-in the same values shown in the assembly
version, it returns eactly the same results as the assembly version
shows for each value passed to crc_8408.

Maybe there's a difference in your PC version & the PIC version?

[Steve43]

The result is already cumulative. If you compare the results to the assembly version in your link, you'll see the last version I posted outputs the same values. crc_hi & crc_lo are only cleared at the start - so they are cumulative until cleared.

Yes, that's what I thought by looking at it, but I guess I was thrown by the fact that the results weren't as expected. However, some more experimentation shows that the results aren't as expected even when calculating the CRC for a single byte, so it would indeed appear that the algorithm in the assembly routine above and the one used by the PC-based program are not identical (although they both are supposed to be CCITT-16 reversed (0x8408)).

I have the C source code for the algorithm used in the PC program. I will try to compare this against the PIC assembly routine and see where the difference might be, although unfortunately I'm no expert in either.

Thanks again for your assistance. This forum is an incredible resource thanks to you and all of the people who contribute.

[Steve43]

Well, I'm just not able to get anywhere with this. I have attached C source code for a CCITT-16 Reversed (0x8408) algorithm that gives me what I need, but unfortunately the PIC assembly routine I found doesn't provide the same output. I don't know if anyone is kind enough to take this on but I could really use the assistance. I'd be willing to buy a PIC CRC library to do this but I haven't been able to find such a thing.

Would someone like to take a stab at implementing this in PBP? It doesn't really have to be in assembly because speed isn't much of an issue in my application.

Thanks (much) again.

(Note: the attached file is in .RTF format to preserve the source code formatting but has an extension of .txt so I could attach it. Best to open it with Wordpad or other .RTF-aware application.)

[Bruce]

Here ya go..!

Poly    con $8408   ' CRC polynomial
I       VAR BYTE
pData   VAR BYTE
X       VAR BYTE
CRC     VAR WORD
C_Data  VAR WORD
VAL     VAR BYTE[3] ' Holds 3 values passed to CRC routiine

VAL[0] = $AA
VAL[1] = $05
VAL[2] = $01

Begin:
    CRC = $FFFF
    for X = 0 TO 2
      pData = VAL[X]
      gosub Calc_CRC
    next X
    CRC = ~CRC
    hserout [IHEX CRC.LowByte,IHEX CRC.HighByte,13,10]
    pause 1000
    goto Begin
    
Calc_CRC:
    C_Data = $00FF & pData
    CRC = CRC ^ C_Data
    for I = 0 to 7
        if CRC.Bit0 = 1 then
         CRC = (CRC >> 1) ^ Poly
        else
         CRC = CRC >> 1
        endif
    next I
    return

I'll let you figure out how to send your original data with the final result, but there's your C-to-BASIC
conversion. Much easier than the assembly routine, but still easier in C....;o]

[Steve43]

Works perfectly! Thanks Bruce, I once again find myself in your debt. Your solution is simple and elegant and is actually a better option for me than what I started out with (although I did learn something by playing with the assembly integration examples.)

Again, this forum is a great resource and thanks to you and the others who help the rest of us over the rough spots...

[Bruce]

You're very welcome. Glad I could help...;o]

I learn a lot here myself. Great resource.