Necesito ayuda para calcular CRC-16

[Automata78]

   Hola a todos !!...antes que nada quería comentar que estuve leyendo sobre este tema en el foro, pero no me ha quedado claro la idea del codigo que se puede ver en http://www.todopic.com.ar/foros/index.php?topic=17709.0 , le codigo es el siguiente :
2.5 CRC16 Calculation Algorithm
Polynomial: x16 + x12 + x5 + 1 Þ CRC_POLYNOM = 0x8408;
Start Value: 0xFFFF Þ CRC_PRESET = 0xFFFF;
C-Example:
unsigned internal CRC = CRC_PRESET;
for (i = 0; i < cnt; i++) /* cnt = number of protocol bytes without CRC */
{
crc ^= DATA;
for (j = 0; j < 8; j++)
{
if (crc & 0x0001)
crc = (crc >> 1) ^ CRC_POLYNOM;
else
crc = (crc >> 1);
}
}

No entiendo por ejemplo que lo que hace "crc ^=DATA;" es como que complementa DATA y lo guarda en crc, lo que quiero entender el la logica de este programa así lo puedo adaptar en assembler con un polinomio CRC-16 bits.

   Espero que no sea mucho pedir, desde ya muchas gracias por la ayuda.  saludos !!!!

[MGLSOFT]

Bueno, aqui te pongo una explicacion de como se obtiene el CRC para Modbus RTU.

Generación del CRC
El Chequeo de Redundancia Cíclica (CRC) está compuesto por dos bytes, conteniendo un valor binario de 16 Bits.

El valor del CRC es calculado por el transmisor y adjuntado al mensaje a transmitir. El receptor calcula un CRC con el mensaje recibido y lo compara con el valor del CRC recibido. Si los valores no coinciden se produce un error.

El CRC comienza cargando un registro de 16 bits con todos 1's. Luego comienza un proceso de aplicación de los sucesivos bytes del mensaje al contenido del registro. Solo los 8 bits de datos son usados para generar el CRC. Los bits de inicio, parada y paridad no se utilizan para el CRC.

Durante la generación del CRC, se ejecuta una operación lógica XOR entre cada byte y el contenido del registro. Luego el resultado es desplazado en la dirección del bit menos significativo (LSB), ingresando un 0 en la posición del bit más significativo (MSB). El bit extraído es examinado. Si es un 1 se ejecuta una XOR entre el contenido del registro y un valor fijo. Si el bit extraído es 0 no se ejecuta la XOR.

Este proceso se repite hasta ejecutarse ocho desplazamientos.

Después del último desplazamiento se ejecuta una XOR entre el próximo byte y el valor del registro de 16 bits, realizando el procedimiento de desplazamientos des cripta anteriormente.
El contenido final del registro, después de aplicarse todos los bytes del mensaje, es el valor del CRC.

El procedimiento para generar el CRC es:

1.   Cargar un registro de 16 bits con FFFFH (todos 1's). Este registro toma el nombre de registro CRC.

2.   Ejecutar una XOR entre el primer byte del mensaje y el byte menos significativo del registro CRC, dejando el resultado en el registro CRC.

3.   Desplazar el registro CRC un bit a la derecha (hacia el LSB), ingresando un 0 en el MSB. Extraer y examinar el LSB.

4.   Si el LSB fue 0 repetir el paso 3 (otro desplazamiento).   Si el MSB fue 1 realizar una XOR entre el registro CRC y el valor A001H (1010 0000 0000 0001 B).

5.   Repetir los pasos 3 y 4 hasta completar ocho desplazamientos, dando como procesado un byte.

6.   Repetir los pasos 2 a 5 para el próximo byte del mensaje. Continuar hasta que todos los bytes han sido procesados.

7.   El contenido final del registro CRC es el valor CRC. Cuando el CRC (dos bytes) es transmitido en el mensaje, el byte menos significativo debe ser transmitido primero, seguido del byte más significativo.

[Automata78]

hola MGLSOFT !!!!!!!  ........... muchas gracias .... me parece excelente la explicacion, esta noche misma me voy a poner a programar la ruitna, y cuendo tenga el resultado te cuento !!!!
   Muchisimas gracias por tu aporte MGLSOFT !!!!  saludos !!!!

[Automata78]

hola MGLSOFT !!!

  Te cuento que hice un programilla en C y assembler, .... el resultado no es muy satisfactorio, ya que para valores de datos "1,2,3,4,5,6,7,8,9"

  me devuelve crc_H = 0xB1 y crc_L = 64 en vez de 0xB1 y 0x29 respectivamente...
  Aqui te cuelgo el código por si ves algo raro, lo unico que queria señalar es que yo roto el registro crc a la izquierda y no a la derecha y compruebo  el bit mas significativo, o sea bit 7 del crc_H ! ya que en los datos, el bit mas significativo se encuentra a la izquierda, te pido por favor si este razonamiento es el correcto o estoy cometiendo un error.

   Muchisimas gracias a vos y a cualquiera que quiera ayudar en esta consulta  !   saludossss !!!


#include "D:\Medidor_Agua\CRC_Prueba\CRC16.h"

#BYTE STATUS = 0X03


byte DATA[]={'1','2','3','4','5','6','7','8','9'};
byte i,j;

byte crc_H,crc_L;
byte cnt = 9;





void Ini_Port(void)
{
 set_tris_a(0);
 set_tris_b(0x0);
 output_a(0);
 output_b(0);
}

void Ini_Var(void)
{
 

}

void main()
{

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
//Setup_Oscillator parameter not selected from Intr Oscillotar Config tab

   // TODO: USER CODE!!
   
   Ini_Port();
   
   

crc_L = 0xff;
crc_H = 0xff;

for (i = 0; i < cnt; i++) // cnt = number of protocol bytes without CRC
    {
     crc_L ^= DATA;

     for (j = 0; j < 8; j++)
         {
          if ((crc_H & 0x80) == 0x80)
             {
              #asm
              bcf         STATUS,0     //borro carry
              rlf          crc_L,F
              rlf          crc_H,F
              movlw    0x10
              xorwf     crc_H,F
              movlw    0x21
              xorwf     crc_L,F
              #endasm
             }
          else{
              #asm
              bcf         STATUS,0     //borro carry
              rlf          crc_L,F
              rlf          crc_H,F
              #endasm
               }
         }
    }
   
   

}

[Automata78]

Hola nuevamente..... les cuento que sigo intentandolo pero no tengo buenos resultados, y por lo que he leido, los pasos no son demasiados complicados. Se los explico con mis palabras lo que entiendo.
 
cargo variable CRC con 0xFFFF

luego:

P1 : desplazo una pocisión a la izquierda,

P2 :verifico si el bit mas significativo es igual a '1',   si es '1'  realizo una operacion XOR entre la variable CRC y 0x1021 y el resultado lo guardo en CRC.
, y si en la verificación anterior no fuera uno, no hago nada,

P3 : realizo los pasos P1 y P2 por los 16 bits !

Sobre lo que he leido en internet, lo que no entiendo es eso de cargar a la variable CRC con 0xFFFF en vez de comenzar en cero.
 y lo otro que tambien no entiendo es si debo agregarle a mi cadena de datos 2 bytes mas cargados con 'cero' antes de realizar la operacion para hallar el CRC-16.

 Espero que me puedan aclarar este problema, ya que le he dedicado mucho tiempo y sigo parada en el mismo lugar ! je je je
 muchas gracias a todos, nos estamos leyendo. saludos !

[Javicho]

Hola:

Hace tiempo también tuve el dilema del CRC16 y por ahi encontré un código, aquí está zipeado, no lo llegué a probar porque solucioné el impase por otro método.

Espero te sirva.

Javicho

[pctecnologia]

Buenas, tengo la siguiente especificación para aplicar el CRC16 a una cadena de texto, pero no me queda claro como hacerlo, por favor si alguiente puede ayudarmen:

VoiceCode Specification
A VoiceCode is a 4 digit number computed using the GTIN, Lot, and optional Date from a PTI Case Label representing a hash of this information. This computation is performed
as follows:

1) Compute  PlainText
a. PlainText is the 14 digit GTIN appended by the Lot Code and the Date (where present) in that order.
b. Do not include the application identifier, prefixes or parentheses
c. There are no spaces between the GTIN, Lot and Date fields.
d. Date if present is represented as YYMMDD with zero packing and no “/” characters
2) Compute ANSI CRC-­‐16 Hash of the PlainText ASCII bytes using the standard ANSI CRC-­‐16 hash with the polynomial of X16 + X15 + X2 + 1
3) Compute the VoiceCode by from the Hash by taking the 4 least significant digits in decimal form (Hash mod 10000).
4) Print the two least significant digits large, and the two most significant digits small Example:

GTIN = (01)10850510002011
Lot = (10)46587443HG234
PlainText=1085051000201146587443HG234
CRC-­‐16 Hash=26359
VoiceCode=6359
Large Digits = 59
Small Digits= 63

[Suky]

Lee por aquí: http://www.todopic.com.ar/foros/index.php?topic=25627.0


Saludos!

[EDURET]

Hola!!!! Estos días he estado investigando acerca del tema CRC-16 y en particular como se aplica a una línea de texto tal como lo mensionas en tu post...

Justamente eso es lo que ando buscando... Agradecería si tuvieras información y me pudieras compartir.... Soy nuevo en el foro, pero acá es donde he encontrado información valiosisima, y ya llevo días peleandome con esto.

Enserio agradecería cuaquier ayuda!

[Diego E.]

Hola amigos, ya verifiqué bien, el procedimiento descrito por MGLSOFT está correcto y es fácil de entender, acá pongo el código de una función para calcular el CRC-16 para modbus

Código: C

1. #include <16F628a.h>
2.  
3. #use delay(clock=4000000, restart_wdt)
4.  
5. #byte status = 0x03
6. #define carry bit_test(status,0)
7.  
8. int dato_modbus[9] = {0x01,0x05,0x10,0x00,0x00,0x00,0xc9,0xa0};
9. long crc_16;
10.  
11. long crc_modbus(int dir_buffer, int bytes);
12.  
13. ///////////////////////////////////////////////////////////////////////////////
14. //*****************************************************************************
15. //*****************************************************************************
16. //*****************************************************************************
17. ///////////////////////////////////////////////////////////////////////////////
18.  
19. #zero_ram       //Borrado de la memoria ram
20.  
21. void main()
22. {
23.  
24.         while(true)            
25.         {
26.                 crc_16 = crc_modbus(&dato_modbus[0], 6);
27.         }
28. }
29. ///////////////////////////////////////////////////////////////////////////////
30. long crc_modbus(int dir_buffer, int bytes)
31. {
32.         int byte_1;
33.         int bit_1;     
34.         long res_crc_16 = 0xffff;
35.        
36.         for(byte_1=0; byte_1<bytes; byte_1++)
37.         {
38.                 res_crc_16 ^= *dir_buffer;
39.                        
40.                 for(bit_1=0; bit_1<8; bit_1++)
41.                 {              
42.                         res_crc_16 = res_crc_16 >> 1;
43.                                        
44.                         if(carry)
45.                         {
46.                                 res_crc_16 ^= 0xa001;
47.                         }
48.                 }
49.                 dir_buffer++;          
50.         }
51.        
52.         return(res_crc_16);
53. }

Lo comprobé con el On-line CRC calculation and free library

Saludos

[Tirlano]

Hola MGLSOFT y demas participantes, queria agradecer vuestra ayuda, me fue de gran utilidad. Un cordial saludo.