Calcular CRC8 en Cobol

[Dasije]

Hola a tod@s.

Como calcular el valor CRC8 desde un campo de texto.

Os dejo el ejemplo en Delphi, también existe para Java y PHP, pero para COBOL no hay.

const
  CRC8_Table: array[0..255] of Byte = (
    $00, $07, $0E, $09, $1C, $1B, $12, $15,
    $38, $3F, $36, $31, $24, $23, $2A, $2D,
    $70, $77, $7E, $79, $6C, $6B, $62, $65,
    $48, $4F, $46, $41, $54, $53, $5A, $5D,
    $E0, $E7, $EE, $E9, $FC, $FB, $F2, $F5,
    $D8, $DF, $D6, $D1, $C4, $C3, $CA, $CD,
    $90, $97, $9E, $99, $8C, $8B, $82, $85,
    $A8, $AF, $A6, $A1, $B4, $B3, $BA, $BD,
    $C7, $C0, $C9, $CE, $DB, $DC, $D5, $D2,
    $FF, $F8, $F1, $F6, $E3, $E4, $ED, $EA,
    $B7, $B0, $B9, $BE, $AB, $AC, $A5, $A2,
    $8F, $88, $81, $86, $93, $94, $9D, $9A,
    $27, $20, $29, $2E, $3B, $3C, $35, $32,
    $1F, $18, $11, $16, $03, $04, $0D, $0A,
    $57, $50, $59, $5E, $4B, $4C, $45, $42,
    $6F, $68, $61, $66, $73, $74, $7D, $7A,
    $89, $8E, $87, $80, $95, $92, $9B, $9C,
    $B1, $B6, $BF, $B8, $AD, $AA, $A3, $A4,
    $F9, $FE, $F7, $F0, $E5, $E2, $EB, $EC,
    $C1, $C6, $CF, $C8, $DD, $DA, $D3, $D4,
    $69, $6E, $67, $60, $75, $72, $7B, $7C,
    $51, $56, $5F, $58, $4D, $4A, $43, $44,
    $19, $1E, $17, $10, $05, $02, $0B, $0C,
    $21, $26, $2F, $28, $3D, $3A, $33, $34,
    $4E, $49, $40, $47, $52, $55, $5C, $5B,
    $76, $71, $78, $7F, $6A, $6D, $64, $63,
    $3E, $39, $30, $37, $22, $25, $2C, $2B,
    $06, $01, $08, $0F, $1A, $1D, $14, $13,
    $AE, $A9, $A0, $A7, $B2, $B5, $BC, $BB,
    $96, $91, $98, $9F, $8A, $8D, $84, $83,
    $DE, $D9, $D0, $D7, $C2, $C5, $CC, $CB,
    $E6, $E1, $E8, $EF, $FA, $FD, $F4, $F3);
 
 
function Calculate_CRC8(Cadena: String):String;
var
  data: TArray;
  len, i: Integer;
  crc: byte;
begin
  data := TEncoding.UTF8.GetBytes(Cadena);
  len := Length(data);
  crc := 0;
 
  for i := 0 to len-1 do
    crc := CRC8_Table[(crc xor data[i]) and $FF];
 
  Result := Format('%.*d', [3, (crc and $FF)]);
end;

@Kuk,

[Kuk]

@Dasije, hola amigo, hace mucho que no te vemos.

Quieres traducirlo a Cobol? O es un aporte en Delphi?

[Dasije]

Hola Kuk.

Traducirlo a COBOL, aunque el ejemplo se entiende hasta cierto punto, pero hay cosas que no entiendo, como las variables como trabajan en DELPHI, sobre todo el TArray, si es numérico o no, como calcular el XOR, cosas que se me escapan de no haber trabajado con este compilador.

Gracias y saludos.

[Kuk]

como calcular el XOR

Fujitsu: Chapter 10 Logical Operator Routines > 10.6 CBL_XOR
MF: CBL_XOR

@Dasije, tienes algún ejemplo de lo que le pasas y qué tiene que dar en la salida?


Ya no tengo el Fujitsu Cobol instalado, pero esto funciona en MF y debe funcionar en Fujitsu:

       program-id. CRC as "CRC".
 
       environment division.
       configuration section.
 
       data division.
       working-storage section.
       
       01  CRC8-Table.
           05  filler occurs 256.
               10  tb-char  PIC X(1).
       
       01  cadena           PIC X(256) value "Hola amigo".        
       01  len              PIC 9(4) COMP-5.
       01  crc              PIC X(1).
       01  crcNum redefines crc pic 9(2) comp-5.
       
       01  idx-1            PIC 9(4) COMP-5.
       
       01  tmpChar          PIC X(1).
       01  tmpIdx redefines tmpChar pic 9(2) comp-5.
       
       procedure division.
           
           perform chargeTable
           perform getLen
           
           move 1 to idx-1
           
           perform until idx-1 > len
               move cadena(idx-1:1) to tmpChar
               
               call "CBL_XOR" using crc tmpChar by value 1
               call "CBL_AND" using X"FF" tmpChar by value  1
               
               move tb-char(tmpIdx) to crc
               
               add 1 to idx-1
           end-perform
           
           display crcNum
           
           goback
           .
       
       
       chargeTable.
           string X"00", X"07", X"0E", X"09", X"1C", X"1B", 
             X"12", X"15",
        X"38", X"3F", X"36", X"31", X"24", X"23", X"2A", X"2D",
        X"70", X"77", X"7E", X"79", X"6C", X"6B", X"62", X"65",
        X"48", X"4F", X"46", X"41", X"54", X"53", X"5A", X"5D",
        X"E0", X"E7", X"EE", X"E9", X"FC", X"FB", X"F2", X"F5",
        X"D8", X"DF", X"D6", X"D1", X"C4", X"C3", X"CA", X"CD",
        X"90", X"97", X"9E", X"99", X"8C", X"8B", X"82", X"85",
        X"A8", X"AF", X"A6", X"A1", X"B4", X"B3", X"BA", X"BD",
        X"C7", X"C0", X"C9", X"CE", X"DB", X"DC", X"D5", X"D2",
        X"FF", X"F8", X"F1", X"F6", X"E3", X"E4", X"ED", X"EA",
        X"B7", X"B0", X"B9", X"BE", X"AB", X"AC", X"A5", X"A2",
        X"8F", X"88", X"81", X"86", X"93", X"94", X"9D", X"9A",
        X"27", X"20", X"29", X"2E", X"3B", X"3C", X"35", X"32",
        X"1F", X"18", X"11", X"16", X"03", X"04", X"0D", X"0A",
        X"57", X"50", X"59", X"5E", X"4B", X"4C", X"45", X"42",
        X"6F", X"68", X"61", X"66", X"73", X"74", X"7D", X"7A",
        X"89", X"8E", X"87", X"80", X"95", X"92", X"9B", X"9C",
        X"B1", X"B6", X"BF", X"B8", X"AD", X"AA", X"A3", X"A4",
        X"F9", X"FE", X"F7", X"F0", X"E5", X"E2", X"EB", X"EC",
        X"C1", X"C6", X"CF", X"C8", X"DD", X"DA", X"D3", X"D4",
        X"69", X"6E", X"67", X"60", X"75", X"72", X"7B", X"7C",
        X"51", X"56", X"5F", X"58", X"4D", X"4A", X"43", X"44",
        X"19", X"1E", X"17", X"10", X"05", X"02", X"0B", X"0C",
        X"21", X"26", X"2F", X"28", X"3D", X"3A", X"33", X"34",
        X"4E", X"49", X"40", X"47", X"52", X"55", X"5C", X"5B",
        X"76", X"71", X"78", X"7F", X"6A", X"6D", X"64", X"63",
        X"3E", X"39", X"30", X"37", X"22", X"25", X"2C", X"2B",
        X"06", X"01", X"08", X"0F", X"1A", X"1D", X"14", X"13",
        X"AE", X"A9", X"A0", X"A7", X"B2", X"B5", X"BC", X"BB",
        X"96", X"91", X"98", X"9F", X"8A", X"8D", X"84", X"83",
        X"DE", X"D9", X"D0", X"D7", X"C2", X"C5", X"CC", X"CB",
        X"E6", X"E1", X"E8", X"EF", X"FA", X"FD", X"F4", X"F3"
           delimited by size into CRC8-Table
           .
           
       getLen.
           
           move 10 to len
           
           *> Fujitsu: function stored-cahr-length
           *> Otros: un bucle, unstring con x"00" o NOT = SPACES etc.
           .
           
       end program CRC.

Para la cadena "Hola amigo" en la salida tengo 023 o lo que es lo mismo X'17'

[Dasije]

Hola buenas tardes.

Lo he probado, y tiene errores al utilizar un string con determinadas letras, como ejemplo funciona correctamente.

Este es el string que tengo que utilizar:

TBAI-00000006Y-251019-btFpwP8dcLGAF-

Y el resultado debe ser: 237

Saludos.

[Kuk]

@Dasije, estás seguro que el código Delphi es correcto?

En todo caso el XOR y AND en Cobol se hacen como en el ejemplo, o sea que tienes el mecanismo de cómo hacerlo. Puedes intentar partir de otro ejemplo.

Si te surgen más dudas, ya sabes

[JCantero]

@Kuk por curiosidad he probado tu ejemplo pero creo que no puede funcionar.

       01  crc              PIC X(1).
       01  crcNum redefines crc pic 9(2) comp-5.

crcNum esta definido como pic 99 pero puede llegar a 256 con lo que hace falta un pic 999.

@Dasije, dame un ejemplo mas corto para poder comprobar. Con el ejemplo que indicas es demasiado largo para depurar.

La cadena
"TBAI-00000006Y-251019-btFpwP8dcLGAF-" me da 130
"Hola amigo" me da 153


Dame resultado para la cadena: "123" y poder depurar si hay algun error

[Kuk]

@JCantero, es un COMP-5 o sea binario nativo y por lo tanto no obedece al PIC de Cobol sino al tamaño físico

Para que te hagas una idea, declara un campo como PIC 9(4) COMP-5 y hazle un MOVE de 54321 y luego hazle un DISPLAY, ya verás

COMPUTATIONAL-5 or COMP-5 (native binary): Computational items

En cuanto al resultado: el problema de @Dasije eran las operaciones sobre Bits. En realidad, según lo que vi por los internetes, no estoy para nada seguro que el código Delphi es correcto. Por lo pronto la tabla difiere de las que he visto por ahí. Y el código pues también. Pero es lo de menos porque se puede jugar con ello hasta dar con lo que se desea o simplemente ver el algoritmo en sí y crear código propio.

[JCantero]

es un COMP-5 o sea binario nativo y por lo tanto no obedece al PIC de Cobol sino al tamaño físico

En RM/Cobol un pic 99 es un numero de 2 digitos.

Si hago esto :

       id division.
       program-id. Comp5.
 
       environment division.
       configuration section.
 
       data division.
       working-storage section.
       
       
       01  crc              PIC X(1).
       01  crcNum redefines crc pic 9(2) comp-5.
       
       
       procedure division.
       inicio.
           move 205 to crcNum
           display crcNum
     
            STOP RUN.
 

El resultado del display es 05


He probado en OpenCobol y funciona igual.

Ya no se en otros cobol, pero en los que he probado es asi.

[Kuk]

@JCantero, tendrás que poner una directiva de compilación porque seguramente los COMP-5 se traten de igual manera que los COMP (que son los binarios BigEndian, independientes de máquina y sí que obeden a las reglas PIC de Cobol).

En IBM, Fujitsu y MF los COMP-5 por defecto son binarios nativos.

---------- Post añadido : 17:19 ---------- Post anterior : 16:31 ----------

@JCantero,

Computational items