CRC con polinomio 0x131 para DS18B20

[BrunoF]

A la tabla la podés generar a partir del  código que estás usando.

Tenés que iterar desde el 0 al 255 e ir guardando cada resultado en la tabla.

la tabla digamos que viene de hacer:

crc_table[0] = crc(0);
crc_table[1] = crc(1);
crc_table[2] = crc(2);
...
crc_table[255] = crc(255);

Saludos.

[Picuino]

¿Por qué no haces el algoritmo primero con una hoja excel?
Cuando te dé los resultados que quieres, lo codificas en ensamblador.

Saludos.

[groundman]

hola.pues sigo con las mismas.

la trama del numero de identificacion del DS18B20 si que me da correctamente el CRC con la rutina de BrunoF.

28
87
d8
e6
03
00
00
b5-crc.          son 7 bytes los que se toman para calcular el crc en el DS18B20.

y en estas tramas recien leidas con el ICD2.fisicamente sobre un sensor,no me salen bien los crc.

51
01
1e
19
7f
ff
0f
10-    no se usa
c1-    crc



56
01
1e
19
7f
ff
0a
10-no se usa
ee- crc


55
01
1e
19
7f
ff
0b
10- no se usa
ef- crc


no tengo manera de saber si los crc son correctos para estas tramas.o quizas el orden de los bytes no se calculan de esta forma.

[Tisco]

¿estás seguro de que son 7 bytes? Hablo de memoria, pero creo recordar que eran 8.

[groundman]

The ROM code CRC is calculated from the first 56 bits of the ROM code and is contained in the most significant byte of the ROM

es lo que dice el datasheet. ademas el codigo de BrunoF calcula el CRC a partir de 7bytes.

si lo raro es que la trama del numero de serie si que funciona.en el ejemplo que pone y en mi numero de serie de mi sensor.tengo 5 sensores mas.podria hacer
la prueba.y si los numeros de serie si que funcionan.igual no estoy leyendo bien algunos de los bytes del Scratchpad del sensor.

probare con el simulador del proteus en vez de hacerlo con el ICD2 haber si va a haber una mala interpretacion de datos.....

[Tisco]

Echándole un ojo al datasheet:

Byte 8 of the scratchpad is read-only and contains the CRC code for bytes 0 through 7 of the scratchpad.

...

CRC bytes are provided as part of the DS18B20’s 64-bit ROM code and in the 9th byte of the scratchpad
memory. The ROM code CRC is calculated from the first 56 bits of the ROM code and is contained in the
most significant byte of the ROM. The scratchpad CRC is calculated from the data stored in the
scratchpad, and therefore it changes when the data in the scratchpad changes

...

This circuit consists of a shift register and XOR gates, and the
shift register bits are initialized to 0. Starting with the least significant bit of the ROM code or the least
significant bit of byte 0 in the scratchpad, one bit at a time should shifted into the shift register. After
shifting in the 56th bit from the ROM or the most significant bit of byte 7 from the scratchpad, the
polynomial generator will contain the re-calculated CRC. Next, the 8-bit ROM code or scratchpad CRC
from the DS18B20 must be shifted into the circuit.

Lo que tú estás buscando es el scratchpad CRC.

Un saludo!

[groundman]

en el Scratchpad es donde se gestionan todos los datos del DS18B20.y tiene 9bytes que van desde el byte0 al byte8.
el crc esta contenido en el byte 8.y su calculo se realiza con los primeros 7bytes.

eso es lo que he entendido del datasheet y todos los calculos los hago en base a esta informacion.

tanto cuado hago el calculo de la identidad como de la temperatura u otros comandos. espero no estar equivocado.

[groundman]

bueno.sigo atrancado en esto del calculo crc.sigo haciendo pruebas con esta pagina: http://ghsi.de/CRC/index.php?Polynom=100110001&Message=021cb801000000

y he aprendido algo de lo que son los polinomios.pero los calculos no me cuadran.

respecto a la formula ya la entiendo. P(x) = x8+ x5+ x4+ x0 que es el polinomo 131 ='100110001' lo que indica es el bit que va a estar a 1.
asi que '11111111'= P(x) = x7+ x6+ x5+ x4+ x3+ x2+ x1+ x0

esto lo veo sencillo.y tambien veo sencillo conseguir el crc de 2bytes.pero no se como hacerlo con 3 o mas.y he probado todas las combinaciones.


en el anterior calculo:

  

Código: [Seleccionar]

     0xB1      0xA2   0x00   <-    valor inicial"0x00"

    principio ->      101100011010001000000000
    polinomio  0x0131   100110001
_________
    XOR                 001010010
                          101001001      ->eliminamos los ceros de la izquierda.y bajamos del principio dos cifras porque son dos ceros los eliminados
    polinomio             100110001
                          _________
                xor       001111000
                            111100000    ->eliminamos 2 ceros bajamos 2 siguienes cifras
           polinomio        100110001
                            _________
                xor         011010001
                             110100010   ->eliminamos 1 cero bajamos 1 cifra
              polinomio      100110001
                             _________
                  xor        010010011
                              100100111      ->eliminamos 1 cero bajamos 1 cifra
               polinomio      100110001
                              __________
                     xor      000010110
                                  101100000       ->eliminamos 4 ceros bajamos 4 cifras
                   polinomio      100110001
                                  _________
                       xor        001010001
                                    101000100         ->eliminamos 2 ceros bajamos 2 cifras
                      polinomio     100110001
                                    _________
                           xor      001110101
                                      111010100          ->eliminamos 2 ceros bajamos 2 cifras
                        polinomio     100110001
                                      _________
                              xor     011100101
                                       111001010           ->eliminamos 1 cero bajamos 1 cifra
                        polinomio      100110001
                                       _________
                               xor     011111011           resultado: 0xFB


vuelvo a realizar el calculo con 3 bytes:


   

Código: [Seleccionar]

0xb1        0xa2       0xa3       0x00
       principio   ->          10110001101000101010001100000000
         poli                  100110001
                               _________
                               00101001001
                                 100110001
                                 _________
                                 00111100000
                                   100110001
                                   _________
                                   0110100010
                                    100110001
                                    _________
                                    0100100110
                                     100110001
                                     _________
                                     0000101111010
                                         100110001
                                         _________
                                         00100101110
                                           100110001
                                           _________
                                           0000111110011
                                               100110001
                                               _________
                                               0110000100
                                                100110001
                                                _________
                                                0101101010
                                                 100110001
                                                 _________
                                                 00101101100
                                                   100110001
                                                   _________
                                                   00101110100
                                                     100110001
                                                     _________
                                                     00100010100
                                                       100110001
                                                       _________
                                                       000100101  = 0x25
asi que no me cuadra el valor final de crc.cuando en la pagina del enlace el resultado es 0xC7

[groundman]

                                               
por finnnn he encontrado el problema.

resulta que para calcular el crc de la rom del DS18b20 se usan los 7 primeros bytes del Scratchpad.por eso salian bien los calculos que se hacian con
la rutina de BrunoF.
pero para calcular el crc de la temperatura y quizas otros comandos.hay que hacer el calculo con los 8bytes primeros del Scratchpad.

modificare la rutina de BrunoF para el calculo de 8bytes.y cortejar resultados.
ya que he encontrado este calculo del crc online: http://www.datastat.com/sysadminjournal/maximcrc.cgi que parece funcionar perfectmente.

y ahora.me voy de juergaaaaa.que es sabado noche.

[groundman]

bueno.modifique la rutina de BrunoF.que le doy las gracias por esta.y que he adaptado para la gestion del DS18b20.esta rutina genera el crc para
la lectura de la rom"identidad" del DS18B20 de 7bytes  y el  de 8bytes.

aqui pongo el enlace: http://www.todopic.com.ar/foros/index.php?topic=24397.60

[groundman]

y en la misma direccion pongo la rutina para la generacion del crc con el sistema de tabla.he hecho las comprobaciones y hay notables diferencias
en cuanto a la memoria usada y el tiempo de ejecucion.

asi que en el sistema sin tabla es una rutina que ocupa 37bytes con un tiempo de ejecucion de 717uS

y por tabla ocupa 288bytes y tarda 188uS en ejecutarse.en un 18f2550 trabajando a 48Mhz.