Hola blackcat!
Cuando uno realiza un CRC en varias etapas, es decir, como por ejemplo en el caso que exponés, el valor de entrada(enter_value en mis algoritmos) es el CRC previo calculado, es decir:
En una trama de 100 bytes, si usas CRC16 deberás primero pactar: El polinomio a utilizar; si se utiliza un valor de entrada inicial distinto de cero y si se utiliza un valor de salida distinto de cero.
Como estamos frente a un CRC16 lo lógico es por ejemplo, tomar de a dos bytes por vez, y someterlos al cálculo del CRC. Supongamos que decido que mi algoritmo utilizará un valor de entrada inicial distinto de cero. Esto quiere decir que, cuando calcule mi primer CRC16(los primeros dos bytes de la trama) haré:
res1= CRC16(byte1byte0, polinomio, 0xFFFF,0x0000)
Fijemonos que aqui le paso los javascript:ChangeEditor(5)argumentos necesarios:
"byte1byte0" serian los primeros 2 bytes de la trama;
el "polinomio" dependería del polinomio elegido(aclaro que mi algoritmo utiliza POLINOMIOS INVERTIDOS(reversed));
"0xFFFF" es un valor con el cual se realizará una XOR con "byte1byte0" al entrar a la rutina del CRC que protegerá a mis bits en caso de que sean ceros.
"0x0000" significa que al terminar de calcular el CRC no modifico el valor obtenido(se realiza la XOR con "byte1byte0" pero no afecta a su valor original);
Como resultado, "res1" contendrá un valor de 16 bits con el CRC calculado, ahora, al calcular el CRC para los próximos dos bytes de la trama, se realizaría así:
res2= CRC16(byte3byte2, polinomio, res1,0x0000)
Si nos fijamos, no solo varian los datos de entrada(que es lógico) sino que además ahora el valor de entrada es el CRC16 calculado previamente("res1").
Esta es la manera en la que se van encadenando los datos y sus respectivos CRC.Si seguimos con la mísma lógica, los próximos dos bytes de la trama se calcularían...(piensenlo y anotenlo y luego corroboren para ver si me van siguiendo....)
.....
........
................
res3= CRC16(byte5byte4, polinomio, res2,0x0000)
¿Bien?
Entonces, básicamente, el algoritmo del CRC consta de 3 partes importantes:
1)Primero se realiza una XOR entre los datos de entrada y un valor("enter_value" en mi algoritmo);
2)Se realiza el cálculo del CRC del valor obtenido en 1);
3)Se realiza otra XOR entre el valor obtenido en 2) y otro valor("exit_value" en mi algoritmo).
Vamos a verificar si lo que dijo tu profe tiene sentido(aunque yo ya sé la respuesta
):
Supongamos una trama de 100 bytes; no entremos en detalles en los valores de los bytes de la trama;supongamos sencillamente que:
"X" representa los 100 bytes de trama
y que el CRC calculado da "C"
Entonces, mi trama estaría compuesta por: "XC"
Método a)
Recibo el paquete "XC" de 102 bytes. Realizo 50 veces(2 bytes por vez) el calculo del CRC16 de la trama "X", y finalmente el CRC que obtengo tiene(o debería tener mejor dicho) un valor "C" si la trama enviada no está corrupta.
Comparo el C obtenido con el C calculado. Son iguales. Perfecto;
Método b)
Recibo el paquete "XC" de 102 bytes. Realizo 50 veces(2 bytes por vez) el calculo del CRC16 de la trama "X", y finalmente el CRC que obtengo tiene(o debería tener mejor dicho) un valor "C" si la trama enviada no está corrupta.
En lugar de compararlo, voy a someter la "C" de la trama recibida con el CRC calculado de la trama "X".
La llamada a la función CRC16 quedaría:
Caso a)
resf= CRC16(C, polinomio, C,0x0000)
La primera "C" corresponde al valor de los dos ultimos bytes de la trama(que sería el CRC recibido), la segunda "C" corresponde al valor CRC final calculado de la trama "X"(porque seguiríamos encandenando los CRCs calculados según lo que expuse más arriba).
Fíjate lo que pasa:
1)Primero se realiza una XOR entre los datos de entrada(C) y un valor(C)("enter_value" en mi algoritmo):
Entonces quedaría
C XOR C = 0 2)Se realiza el cálculo del CRC del valor obtenido en 1):
Expongo aquí la LEY DE LA NADA:
¿De la nada qué sacamos? ¡NADA! Entonces, si el valor del cual calcular el CRC es 0, el CRC dará 0. Esto sucede con todos los CRC. El resto de 0 es 0. Siempre.
Entonces, el resultado de este paso será 0.
3)Se realiza otra XOR entre el valor obtenido en 2) y otro valor("exit_value" en mi algoritmo):
Realizamos entonces ahora la XOR entre lo calculado previamente(0) y el valor de salida(0x0000). La XOR dará 0.
Entonces, podemos asegurar que la trama está correcta porque el CRC final de los 102 bytes dará 0.
Caso b)
Similar al caso a), sólo que cuando se utiliza un valor de 0xFFF para "exit_value", en el último cálculo del CRC la llamada quedaría:
resf= CRC16(C, polinomio, C,0xFFFF)
1) C XOR C = 0
2)CRC 0 = 0
3) 0 XOR 0xFFFF = 0xFFFF
Por lo que tu profesor tiene razón. Puede dar 0x0000 o 0xFFFFF según los parámetros de salida elegidos.
Saludos.
