1.

char CRC5(long value, char poly, char init_value, char

exit_value){
2.
3.

char i;

4.

long res;

5.
6.

res=value;

7.
8.

res^=init_value;

9.
10.

//reacomodado para 11bits de trama

for(i=0;i<11;i++){

11.

if(res & 1){

12.

res>>= 1;

13.

res^=poly;

14.

}else{

15.

res>>= 1;

16.
17.

}
}

18.
19.

res^=exit_value;

20.
//solo quedarse con el byte bajo(solo
sirven los 5 bits de menor peso, el resto deberian ser ceros)
21.

return (int8)res;

22.

23.
24. A simple C implementation of the above polynom is shown in the following code.
Again, you can directly copy the source snippet to your code (distributed under
LGPL):
25.
26. //
=============================================================
=============
27. // CRC Generation Unit - Linear Feedback Shift Register
implementation
28. // (c) Kay Gorontzi, GHSi.de, distributed under the terms of
LGPL
29. //
=============================================================
=============
30. char *MakeCRC(char *BitString)
31.
{
32.
static char Res[9];
//
CRC Result
33.
char CRC[8];
34.
int i;
35.
char DoInvert;
36.
37.
for (i=0; i<8; ++i) CRC[i] = 0;
//
Init before calculation
38.
39.
for (i=0; i<strlen(BitString); ++i)
40.
{
41.
DoInvert = ('1'==BitString[i]) ^ CRC[7];
//
XOR required?
42.
43.
CRC[7] = CRC[6];
44.
CRC[6] = CRC[5];
45.
CRC[5] = CRC[4] ^ DoInvert;
46.
CRC[4] = CRC[3] ^ DoInvert;
47.
CRC[3] = CRC[2];
48.
CRC[2] = CRC[1];
49.
CRC[1] = CRC[0];
50.
CRC[0] = DoInvert;
51.
}
52.
53.
for (i=0; i<8; ++i) Res[7-i] = CRC[i] ? '1' : '0'; //
Convert binary to ASCII
54.
Res[8] = 0;
//
Set string terminator
55.
56.
return(Res);
57.
}

58.
59. // A simple test driver:
60.
61. #include <stdio.h>
62.
63. int main()
64.
{
65.
char *Data, *Result;
// Declare two strings
66.
67.
Data = "1101000101000111";
68.
Result = MakeCRC(Data);
// Calculate CRC
69.
70.
printf("CRC of [%s] is [%s] with P=[100110001]\n", Data,
Result);
71.
72.
return(0);
73.
}

/*Includes of system
headers------------------------------------------------------------*/
#include <pic18.h>
/*Includes of local
headers-------------------------------------------------------------*/
#include "iButton.h"
#include "Display.h"
#include "Timer.h"
#include "Misc.h"
/*Type and constant
definitions---------------------------------------------------------*/
/*Global
variables---------------------------------------------------------------------*/
unsigned char LlaveID[8];
//64bits (8bytes) de ROM
unsigned char LlaveIDHex[17]; //16nibles de texto hexa + null
unsigned char cOneWireCRC;
unsigned char cOneWireCRChex[3];
bit OneWirePresent;
bit OneWireTrigger=0;
/
*Functions----------------------------------------------------------------------------*/

void OneWireMonitor (void);

void OneWireReset (void);
void OneWireTXbyte (unsigned char cByte);
unsigned char OneWireRXbyte (void);
void OneWireCRCcheck(unsigned char cByte);
void OneWireMonitor (void)
{
unsigned char i;
OneWireReset();
if (OneWirePresent) {
GotoXY(3,0);
PutString("Llave presente:");
}
else {
GotoXY(3,0);
PutString("Llave AUSENTE!:");
}
GotoXY(4,0);
OneWireTXbyte(READ_ROM);
cOneWireCRC=0;
for(i=0;i<8;i++) {
LlaveID[i]=OneWireRXbyte();
Char2Hex(LlaveID[i],&LlaveIDHex[2*i]);
if(i<7) OneWireCRCcheck(LlaveID[i]);
}
PutString(LlaveIDHex);
GotoXY(5,0);
PutString("CRC: ");
Char2Hex(cOneWireCRC,cOneWireCRChex);
PutString(cOneWireCRChex);
OneWireTrigger=0;
}
void OneWireReset (void)
{
GIE=0;
OneWireHI();
OneWirePresent=0;
//inicializo flag
OneWireLO();
//mando un low por 500us (tRSTL)
DelayUS(250);
//OneWireHI();
//OneWireLO();
//DelayUS test
DelayUS(250);
OneWireHI();
//levanto el low
DelayUS(70);
//espero 70us (tPDL)
if(!OneWireRXPORT) OneWirePresent=1; //si me responde con low hay llave
DelayUS(200);
//completo con 430us (tRSTH)
DelayUS(230);
GIE=1;
}
void OneWireTXbyte (unsigned char cByte)
{
unsigned char i;
GIE=0;
for(i=0;i<8;++i) {
//8 bits a enviar

OneWireLO();
//mando un low por 3us (tLOW1)
DelayUS(3);
//REVISAR MACRO PARA CLOCK 8MHZ= Ciclos de .5us
(@10MHz= .4us)
if (cByte&0x01) OneWireHI();
//si el 1er bit es '1' mando un '1'
DelayUS(60);
//mantengo el low por 60us (tLOW0)
OneWireHI();
//levanto del low
DelayUS(2);
//REVISAR MACRO PARA CLOCK 8MHZ= Ciclos de .5us
(@10MHz= .4us)
cByte>>=1;
//despazo para enviar siguiente bit
}
GIE=1;
}
unsigned char OneWireRXbyte (void)
{
unsigned char i;
unsigned char cByte=0;
GIE=0;
for(i=0;i<8;++i) {
OneWireLO();
//mando un low por 6us (a partir del low hasta (*) no
deben pasar ms de 15us)
DelayUS(6);
OneWireHI();
//levanto el low
DelayUS(4);
//espero 4us
cByte>>=1;
//desplazo el bit a la derecha
if(OneWireRXPORT) cByte|=0x80; //(*) si leo un '1' lo almaceno (los bits
entran de izq a der)
DelayUS(50);
//espero 50us (tSLOT)
}
GIE=1;
return cByte;
}
//Calcula CRC-8 byte a byte.
//La variable cOneWireCRC se debe incializar el principio del clculo con
el valor '0'.
//El polinomio se carga LSb-first (al revs), y adems como
//el XOR solo se ejecuta cuando el bit ms pesado es '1', el 9no bit del
polinomio
//se elimina porque se sabe que el resultado es '0' (1^1=0); con lo que
el polinomio
//CRC-8-Dallas/Maxim (DOW CRC)= X^8 + X^5 + X^4 + 1 nos queda 10001100
#define POLYNOMIAL 0x8C
void OneWireCRCcheck(unsigned char cByte)
{
unsigned char cbit;
cOneWireCRC ^= cByte;
for (cbit = 0; cbit < 8; cbit++) {
if (cOneWireCRC & 0x01)
//si el 1er bit es 1
cOneWireCRC = (cOneWireCRC >> 1) ^ POLYNOMIAL;//hacer el XOR y desplazar
else cOneWireCRC = (cOneWireCRC >> 1);//no hacer nada y desplazar
}
}
/*
Esto d 0xD0:
#define POLYNOMIAL 0x8C

void OneWireCRCcheck(unsigned char cByte)

{
unsigned char cbit;
cOneWireCRC ^= cByte;
for (cbit = 0; cbit < 8; cbit++) {
if (cOneWireCRC & 0x80)
//si el 1er bit es 1
cOneWireCRC = (cOneWireCRC << 1) ^ POLYNOMIAL;//hacer el XOR y desplazar
else cOneWireCRC = (cOneWireCRC << 1);//no hacer nada y desplazar
}
}
Y esto tambin d 0xD0:
#define POLYNOMIAL 0x8C
void OneWireCRCcheck(unsigned char cByte)
{
unsigned char cbit;
cOneWireCRC ^= cByte;
for (cbit = 0; cbit < 8; cbit++) {
if (cOneWireCRC & 0x01)
//si el 1er bit es 1
cOneWireCRC = (cOneWireCRC >> 1) ^ POLYNOMIAL;//hacer el XOR y desplazar
else cOneWireCRC = (cOneWireCRC >> 1);//no hacer nada y desplazar
}
}
*/