Cobol Foro

Cobol Foro (https://www.cobolforo.es/index.php)
-   PowerCOBOL y COM/OLE (https://www.cobolforo.es/forumdisplay.php?f=32)
-   -   [Sintaxis] Calcular CRC8 en Cobol (https://www.cobolforo.es/showthread.php?t=1379)

Dasije 28 de septiembre de 2021 18:43

Calcular CRC8 en Cobol
 
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.

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

@Kuk,

Kuk 28 de septiembre de 2021 20:27

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

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

Dasije 28 de septiembre de 2021 20:40

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 29 de septiembre de 2021 00:29

Cita:

Citación del post de Dasije (Mensaje 7065)
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:

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

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

Dasije 29 de septiembre de 2021 18:16

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 30 de septiembre de 2021 11:15

@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 30 de septiembre de 2021 14:27

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

Código COBOL:
  1.        01  crc              PIC X(1).
  2.        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 30 de septiembre de 2021 16:03

@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 :bien:

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 30 de septiembre de 2021 16:26

Cita:

Citación del post de Kuk (Mensaje 7078)
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 :

Código COBOL:
  1.        id division.
  2.        program-id. Comp5.
  3.  
  4.        environment division.
  5.        configuration section.
  6.  
  7.        data division.
  8.        working-storage section.
  9.        
  10.        
  11.        01  crc              PIC X(1).
  12.        01  crcNum redefines crc pic 9(2) comp-5.
  13.        
  14.        
  15.        procedure division.
  16.        inicio.
  17.            move 205 to crcNum
  18.            display crcNum
  19.      
  20.             STOP RUN.
  21.  

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.

:losiento:

Kuk 30 de septiembre de 2021 17:19

@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

[table]Digits in PICTURE clause|Storage occupied
1 through 4 |2 bytes (halfword)
5 through 9 |4 bytes (fullword)
10 through 18 |8 bytes (doubleword)
[/table]


La franja horaria es GMT +2. Ahora son las 13:03.

Powered by: vBulletin, Versión 3.8.7
Derechos de Autor ©2000 - 2026, Jelsoft Enterprises Ltd.