Dallas CRC8 Routines

[Tom Estes]

Three different PBP programs to calculate the Dallas 8bit CRC.


' PIC16F628
' These routines are documented in Dallas Semiconductor Application Note 27
' Understanding and Using Cyclic Redundancy Checks
' This program contains three subroutines for calculating the Dallas 1Wire 8bit CRC.
' The computationally intensive short version is called CRC8. Use this one when
' you don't have enough PIC memory to store the table version (approx 270 words)
' and can afford the processing time.
' The table version CRC8LU is computationally fast since it works on byte at a time
' rather than bit at a time as CRC8 does.
' The Assembly Language version of the computationally intensive version is CRC8AL.
' Times per 8 bit CRCByte:
' CRC8LU 35usec
' CRC8AL 115usec
' CRC8 260usec
DEFINE OSC 4
@ DEVICE XT_OSC
@ DEVICE MCLR_OFF
@ DEVICE LVP_OFF
CMCON = 7

TestBit var Bit ' CRC8
TestByte var Byte ' CRC8AL
CRCData var Byte ' CRC8 & CRC8LU & CRC8AL
CRC var Byte ' CRC8 & CRC8LU & CRC8AL
I var Byte ' CRC8 & CRC8AL
' Test data
CRCData = $02
CRC = 0
'Gosub CRC8
'Gosub CRC8LU
Call CRC8AL
' Test CRC should be $BC
END

' ********** Subroutine CRC8 **********
' PBP Version not using lookup table
' Expects CRC starting value and CRCData
' CRC will be cumulative unless reset externally
' Gives ending CRC value and destroys CRCData
' Uses I-Byte, TestBit-Bit, CRC-Byte, CRCData-Byte
CRC8:
For I = 0 to 7 ' Do for all 8 bits in data byte
TestBit = CRC.0 ^ CRCData.0 ' XOR bit0 of data byte and crc
CRCData = CRCData >> 1 ' Position data byte for next bit test
If TestBit = 0 then Shift ' If test bit not set, just shift CRC
CRC = CRC ^ $18 ' If set, account for EXOR feedback
Shift: ' Shift right the CRC byte
CRC = CRC >> 1 ' CRC bit 0 to bit bucket
CRC.7 = TestBit ' Test bit rotates into CRC bit 7
Next I
Return

' ********** Subroutine CRC8AL **********
' Assembly Language version of Dallas CRC8 calculator
' Expects CRC starting value and CRCData
'CRC will be cumulative unless reset externally to routine
' Gives ending CRC value in CRC and destroys CRCData
' Uses I-Byte, TestByte-Byte, CRC-Byte, CRCData-Byte
ASM
_CRC8AL ; Dallas CRC8 Assembly Language PIC16F628
MOVLW 8
MOVWF _I ; Do this for all 8 bits of CRCByte
CRCLOOP
MOVF _CRC,0 ; Put CRC into W
XORWF _CRCData,0 ; XOR CRC with CRCData
MOVWF _TestByte ; Put results in TestByte
RRF _TestByte,1 ; Shift TestByte.0 into Carry bit
BTFSS STATUS,C ; If Carry = 1, account for EXOR feedback gates
GOTO CRCSHIFT ; Otherwise just shift CRC and CRCByte
MOVF _CRC,0 ; Get latest copy of CRC
XORLW 0x18 ; XOR with 18Hex
MOVWF _CRC ; Keep a copy of results
CRCSHIFT
RRF _CRC,1 ; Rotate CRC incorporating carry
RRF _CRCData,1 ; Rotate CRCData, carry shifts in but not important
DECFSZ _I,1 ; Keep track of #times through loop
GOTO CRCLOOP ; Go to start if not looped through the 8 bits
RETURN ; Return if all 8 bits analyzed
ENDASM

' ********** Subroutine CRC8LU **********
' Expects CRC at some starting value with data to CRC
' passed in CRCData.
' Gives ending CRC value and destroys CRCData
' Uses CRCData-Byte, CRC-Byte
CRC8LU:
CRCData = CRCData ^ CRC
Lookup CRCData, [0,94,188,226,97,63,221,131,194,156,126,32,163,253, 31,65,_
157,195,33,127,252,162,64,30,95,1,227,189,62,96,13 0,220,_
35,125,159,193,66,28,154,160,225,191,93,3,128,222, 60,98,_
190,224,2,92,223,129,99,61,124,34,192,158,29,67,16 1,255,_
70,24,250,164,39,121,155,197,132,218,56,102,229,18 7,89,7,_
219,133,103,57,186,228,6,88,25,71,165,251,120,38,1 96,154,_
101,59,217,135,4,90,184,230,167,249,29,69,198,152, 122,36,_
248,166,68,26,153,199,37,123,58,100,134,216,91,5,2 31,185,_
140,210,48,110,237,179,81,15,78,16,242,172,47,113, 147,205,_
17,79,173,243,112,46,204,146,211,141,111,49,178,23 6,14,80,_
175,241,19,77,206,144,114,44,109,51,209,143,12,82, 176,238,_
50,108,142,208,83,13,239,177,140,174,76,18,145,207 ,45,115,_
202,148,118,40,171,245,23,73,8,86,180,234,105,55,2 13,139,_
87,9,235,181,54,104,138,212,149,203,41,119,244,170 ,72,22,_
233,183,85,11,136,214,52,106,43,117,151,201,74,20, 246,168,_
116,42,200,150,21,75,169,247,182,232,10,84,215,137 ,107], CRC
' PBP only handles 255 constants in the list (256 for 18Cxxx). Since table is
' indexed starting at zero, special case for $FF (256th element).
If CRCData = $FF Then
CRC = 53
EndIF
Return

[CocaColaKid]

If I used this line of code:

owin portb.7, 0, [temp.byte0,temp.byte1,SKIP 6,crc_value]

Would the calculated CRC be the same value as crc_value?

[Tom Estes]

More than likely no.

You don't state which and I may not be familiar with the 1 wire device you are using but normally you would not be able to skip any characters it transmits. They would all need to be received and included in the CRC calculation. You will need to read the data sheet for the 1 wire device you are using to see what all is included in the CRC total.

To get that total feed each byte into the CRC routine, The CRC will be calculated and after all bytes that the manufacturer has included in the CRC total have been passed trough it, the CRC should be the same as the CRC received from the 1 wire device.

Tom

[CocaColaKid]

I actually working with the DS18S20 chip. From what I'm reading though it sounds like I calculate the CRC from the bytes read. Is this correct?

[Tom Estes]

I am not familiar with the DS18S20 but a quick look at the data sheet shows the CRC is calculated by reading all 8 bytes of the scratchpad memory, running them through the CRC routine and comparing its output to the 9th byte read from the scratchpad which is the CRC value generated by the DS18S20. See example 3 in the datasheet.

[CocaColaKid]

I think I can now safely say I'm completely lost as this is making no sense to me. Do I calculate the CRC for each bit using bit0 ^ bit1... and then XOR all the bytes one at a time or do I just XOR the bytes themselves? Please excuse my lack of understanding as this is all new to me.

[Norbert]

Found an error in the CRC8LU subroutine when validating CRC byte after doing a 1-wire search.
A CRC of $F0 on a device returns an error.
This is because of a typo in Tom's code, the value 140 highlighted in red in the quote below is incorrect.
From the table of Example 3 in Dallas AN27, the value here should be 240.

Norbert

Three different PBP programs to calculate the Dallas 8bit CRC.
....

' ********** Subroutine CRC8LU **********
' Expects CRC at some starting value with data to CRC
' passed in CRCData.
' Gives ending CRC value and destroys CRCData
' Uses CRCData-Byte, CRC-Byte
CRC8LU:
CRCData = CRCData ^ CRC
Lookup CRCData, [0,94,188,226,97,63,221,131,194,156,126,32,163,253, 31,65,_
157,195,33,127,252,162,64,30,95,1,227,189,62,96,13 0,220,_
35,125,159,193,66,28,154,160,225,191,93,3,128,222, 60,98,_
190,224,2,92,223,129,99,61,124,34,192,158,29,67,16 1,255,_
70,24,250,164,39,121,155,197,132,218,56,102,229,18 7,89,7,_
219,133,103,57,186,228,6,88,25,71,165,251,120,38,1 96,154,_
101,59,217,135,4,90,184,230,167,249,29,69,198,152, 122,36,_
248,166,68,26,153,199,37,123,58,100,134,216,91,5,2 31,185,_
140,210,48,110,237,179,81,15,78,16,242,172,47,113, 147,205,_
17,79,173,243,112,46,204,146,211,141,111,49,178,23 6,14,80,_
175,241,19,77,206,144,114,44,109,51,209,143,12,82, 176,238,_
50,108,142,208,83,13,239,177,140,174,76,18,145,207,45,115,_
202,148,118,40,171,245,23,73,8,86,180,234,105,55,2 13,139,_
87,9,235,181,54,104,138,212,149,203,41,119,244,170 ,72,22,_
233,183,85,11,136,214,52,106,43,117,151,201,74,20, 246,168,_
116,42,200,150,21,75,169,247,182,232,10,84,215,137 ,107], CRC
' PBP only handles 255 constants in the list (256 for 18Cxxx). Since table is
' indexed starting at zero, special case for $FF (256th element).
If CRCData = $FF Then
CRC = 53
EndIF
Return

[Charlie]

found 2 more typos for total of 3...

line with 35,125,159,193,66,28,"154", Dallas has 254
line with 101,59,217,135,4,90,184,230,167,249,"29", Dallas has 27
line with 50,108,142,208,83,13,239,177,"140", but Dallas example is 240 (as noted above)

[Mike, K8LH]

Has anyone ever converted Scott Dattalo's method (1-Wire Polynomial) to PBP?

;
;  Scott Dattalo's version (20 words, 23 cycles per byte)
;
crc_8
        xorwf   CRC,F           ;
        clrw                    ;
        btfsc   CRC,0           ;
        xorlw   0x5E            ; 
        btfsc   CRC,1           ; 
        xorlw   0xBC            ; 
        btfsc   CRC,2           ; 
        xorlw   0x61            ; 
        btfsc   CRC,3           ; 
        xorlw   0xC2            ; 
        btfsc   CRC,4           ; 
        xorlw   0x9D            ; 
        btfsc   CRC,5           ;
        xorlw   0x23            ; 
        btfsc   CRC,6           ; 
        xorlw   0x46            ; 
        btfsc   CRC,7           ; 
        xorlw   0x8C            ; 
        movwf   CRC             ; 
        return                  ;

It seems like a pretty good compromise between size and performance.

Regards, Mike

[Ioannis]

If your concern is size and speed, why not use it as is with he addition of _ before CRC variable (_CRC)?

I think it will work just fine.

Ioannis

[Mike, K8LH]

If your concern is size and speed, why not use it as is with he addition of _ before CRC variable (_CRC)?

I think it will work just fine.

Hi Ioannis:

Since the Dattalo method wasn't mentioned in the thread, I simply wanted to pass it along, hoping it might be useful or helpful to PBP users. I'm afraid I don't know how you would implement it in PBP.

While I've tried all of the methods discussed in this thread in the past, now days in my C programs I use bit level cumulative CRC built into my low level 1-Wire read/write bit driver. Total cost for doing it this way is 8 words of program memory, 1 byte of RAM, and 0 cycles processing overhead since the CRC code executes during a portion of the delay required to fill out the 60 usec read slot timing.

Cheerful regards, Mike