Necesaria la comprobacion de datos en USB?

[mizzard]

Hola a todos, estoy desarrollando un proyecto para el cual utilizo la comunicación USB. El caso es que todo de momento me funciona bien, pero me surge la duda de si debería comprobar con un algoritmo de CRC si los datos que recibe el dispositivo son válidos o no.

Lo que hago por el momento es poner unas cabeceras e indicador de fin de trama y si veo que hay eso supongo q los datos intermedios estarán bien.

¿Sabeís si la libreria del USB (en ccs) o el driver de microchip incorpora algun algoritmo de comprobacion de datos?

¿Debería contemplar un algoritmo CRC o simplemente viendo que en el buffer usb tengo la cantidad de datos que esperaba y que mis cabeceras son correctas seria suficiente?


Muchas gracias y un saludo!

[falflores]

Hola mizzard, idealmente, y con esto me refiero a un ambiente de laboratorio, donde puedes realizarle las pruebas de funcionamiento a tu proyecto, todo el ambiente estará hasta cierto punto "limpio", sin ninguna fuente de ruido muy grande.

Pero si tu proyecto está pensado para ser usado en diferentes lugares, por diferentes personas, sí va a ser necesario que incorpores el CRC, por ejemplo, yo trabajo cerca de un refrigerador y cada que arranca me testerea mis desarrollos que estoy probando.

Te recomiendo que si le incorpores dicho algoritmo, te ayudaría, pero no se como se genera dicha comprobación, ya que en algún momento la quise incorporar a una red de termómetros DS18B20, pero no supe como, si conoces la forma del algorítmo me podrías dar alguna pista?.

Saludos!

[jukinch]

Hola falflores:

acá puedes ver como lo hizo gauchosuizo con tablas.

hola

sin dar muchas explicaciones les dejo un ejemplo de como yo calculo el CRC:

int8  const CRC_HIGHBYTE_TAB1[128] = {0x00,0xC0,0xC1,0x01,0xC3,0x03,0x02,0xC2,0xC6,0x06,0x07,0xC7,0x05,0xC5,0xC4,
                                      0x04,0xCC,0x0C,0x0D,0xCD,0x0F,0xCF,0xCE,0x0E,0x0A,0xCA,0xCB,0x0B,0xC9,0x09,
                                      0x08,0xC8,0xD8,0x18,0x19,0xD9,0x1B,0xDB,0xDA,0x1A,0x1E,0xDE,0xDF,0x1F,0xDD,
                                      0x1D,0x1C,0xDC,0x14,0xD4,0xD5,0x15,0xD7,0x17,0x16,0xD6,0xD2,0x12,0x13,0xD3,
                                      0x11,0xD1,0xD0,0x10,0xF0,0x30,0x31,0xF1,0x33,0xF3,0xF2,0x32,0x36,0xF6,0xF7,
                                      0x37,0xF5,0x35,0x34,0xF4,0x3C,0xFC,0xFD,0x3D,0xFF,0x3F,0x3E,0xFE,0xFA,0x3A,
                                      0x3B,0xFB,0x39,0xF9,0xF8,0x38,0x28,0xE8,0xE9,0x29,0xEB,0x2B,0x2A,0xEA,0xEE,
                                      0x2E,0x2F,0xEF,0x2D,0xED,0xEC,0x2C,0xE4,0x24,0x25,0xE5,0x27,0xE7,0xE6,0x26,
                                      0x22,0xE2,0xE3,0x23,0xE1,0x21,0x20,0xE0};
                                     
int8  const CRC_HIGHBYTE_TAB2[128] = {0xA0,0x60,0x61,0xA1,0x63,0xA3,0xA2,0x62,0x66,0xA6,0xA7,0x67,0xA5,0x65,0x64,
                                      0xA4,0x6C,0xAC,0xAD,0x6D,0xAF,0x6F,0x6E,0xAE,0xAA,0x6A,0x6B,0xAB,0x69,0xA9,
                                      0xA8,0x68,0x78,0xB8,0xB9,0x79,0xBB,0x7B,0x7A,0xBA,0xBE,0x7E,0x7F,0xBF,0x7D,
                                      0xBD,0xBC,0x7C,0xB4,0x74,0x75,0xB5,0x77,0xB7,0xB6,0x76,0x72,0xB2,0xB3,0x73,
                                      0xB1,0x71,0x70,0xB0,0x50,0x90,0x91,0x51,0x93,0x53,0x52,0x92,0x96,0x56,0x57,
                                      0x97,0x55,0x95,0x94,0x54,0x9C,0x5C,0x5D,0x9D,0x5F,0x9F,0x9E,0x5E,0x5A,0x9A,
                                      0x9B,0x5B,0x99,0x59,0x58,0x98,0x88,0x48,0x49,0x89,0x4B,0x8B,0x8A,0x4A,0x4E,
                                      0x8E,0x8F,0x4F,0x8D,0x4D,0x4C,0x8C,0x44,0x84,0x85,0x45,0x87,0x47,0x46,0x86,
                                      0x82,0x42,0x43,0x83,0x41,0x81,0x80,0x40};
                       

int8  const CRC_LOWBYTE_TAB1[128] = {0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,
                                     0x40,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,
                                     0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,
                                     0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,
                                     0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,
                                     0x40,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,
                                     0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,
                                     0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
                                     0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41};
                                       
int8  const CRC_LOWBYTE_TAB2[128] = {0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,
                                     0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,
                                     0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,
                                     0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,
                                     0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,
                                     0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,
                                     0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,
                                     0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
                                     0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40};


void CalcCrc(int8  data_str_len)
{
   int8 Index;
      int8 Cnt = 0;
      CrcLsb = 0xFF;
      CrcMsb = 0xFF;
      while (Cnt < data_str_len)
    {
       Index = CrcLsb ^ modbus.Buffer[Cnt];//Buffer[Cnt];
         if (Index < 128)
        {
           CrcLsb = CrcMsb ^ CRC_LOWBYTE_TAB1[Index];
            CrcMsb = CRC_HIGHBYTE_TAB1[Index];
        }
         else
        {
            CrcLsb = CrcMsb ^ CRC_LOWBYTE_TAB2[Index-128];
           CrcMsb = CRC_HIGHBYTE_TAB2[Index-128];
        }
         ++Cnt;
    }
}



En el link que te transcribo más abajo hay mucha información de varios algoritmos.
http://www.lammertbies.nl/comm/info/crc-calculation.html#intr
y en este otro link las librerias en ansi c.
http://www.lammertbies.nl/comm/software/index.html

[RICHI777]

Hola, en el mismo protocolo USB la integridad de datos esta garantizada, no es necesario colocarle un checkeo externo.

Saludos !

[mizzard]

Ok, muchas gracias! Un saludo!

[falflores]

acá puedes ver como lo hizo gauchosuizo con tablas.

Gracias por la info, pero siempre me he preguntado para qué se necesitan tantos datos en la tabla?, no se supone que lo que se busca es ahorrar memoria en los programas?

[Suky]

acá puedes ver como lo hizo gauchosuizo con tablas.

Gracias por la info, pero siempre me he preguntado para qué se necesitan tantos datos en la tabla?, no se supone que lo que se busca es ahorrar memoria en los programas?

El CRC es para comprobación de error, no ahorro en espacio de programa. También busca las rutinas que a realizado BrunoF, están para CRC5, CRC8, CRC16, ect....


Saludos!

[RICHI777]

Hola, aunque nos apartamos un poco de tema central de este thread. Como comento Suky, el propósito de los CRCs es la comprobación de errores de datos. Existen dos métodos para implementarlos:

• Por tablas
• Calculo on the fly ( en vuelo )

El primer método los valores se precalculan en una tabla, esto permite velocidad a expensas de tamaño de código, el segundo método no utiliza tablas, es eficiente en el tema de tamaño de código pero deficiente en la velocidad de ejecución.

Saludos !

[falflores]

Hola, aunque nos apartamos un poco de tema central de este thread. Como comento Suky, el propósito de los CRCs es la comprobación de errores de datos. Existen dos métodos para implementarlos:

• Por tablas
• Calculo on the fly ( en vuelo )

El primer método los valores se precalculan en una tabla, esto permite velocidad a expensas de tamaño de código, el segundo método no utiliza tablas, es eficiente en el tema de tamaño de código pero deficiente en la velocidad de ejecución.

Saludos !

Muchas gracias RICHI777 ahora si me queda claro, es que yo me preguntaba por qué eran necesarias las tablas, y si no había una forma de calcularlo, pero ahora que mencionas que hay dos métodos, me queda más claro.

Entonces, para hacer un CRC de 64 bits, menos los 8 del CRC (es decir, de 56 bits), me sirven las tablas que dejo más arriba el amigo jukinch?, o acaso necesito otras?

[RICHI777]

Hola, existen métodos documentados para el calculo de CRC, yo conozco de 8, 16 y 32. No es bueno improvisar con estas cosas, en la web hay mucho código C con buenas implementaciones ya sea calculo on the fly o por tablas.

Saludos !

[Suky]

Además cada CRC implementa su polinomio, entrada y salida... Busca el tema de BrunoF, seguro te va ayudar 


Saludos!