Archivo Binario(tambien conocido como secuencial)

[ASTROCAR]

Hola buenos dias, me estoy iniciando en delphi y estoy haciendo una aplicacion para mostrar las data de un archivoi binario  de eeprom de las serie i2c, es decir estoy haciendo un programador de eeprom i2c y los archivos los voy a manejar en formato binario pero la verdad es que no tengo mucho conocimiento esto en una oportunidad lo hice pero en vb6 y para abrir archivos use open pero por lo que he investigado en delphi no se usa esa sentencia poara abrir archivos secuenciales.

Haa lo otro es que esa data de las eeprom la quiero visualizar en un control stringgrid ya que eso maneja filas y colunmas y asi veo mas semejansa con  la estructura de la data de las eeprom que basicamente esta en ese mismo orden de filas y colunmas.

yo ya logre abrir el cuadro de dialogo para halar la data pero nose como abrirla y mostrar en el control stringgrid

saludos y acepto todo tipo de opiniones a los conocedores de este mundo de programacion delphi.
Atten.
Alexander Santana
Barcelona-Venezuela.

[eto]

Hola ASTROCAR, últimamente he trabajado mucho con los stringgrid, y me di un tiempo para hacer un ejemplo espero que te sirva.
Para este ejemplo necesitas colocar en el formulario, un botón (button1), un dialogo abrir (opendialog1), un memo (memo1), y un stringgrid (stringgrid1).
Te adjunto el código fuente junto con un archivo *.HEX para que lo revises y si es lo que necesitas pues bien. Y el código quedaria asi:

Código: [Seleccionar]

procedure TForm1.FormCreate(Sender: TObject);
begin
  memo1.ScrollBars := ssBoth; // COLOCA LAS DOS BARRAS DE DESPLAZAMIENTO
  stringgrid1.ColCount := 5; // INDICA QUE DEBE TENER 5 COLUMNAS
  //CONFIGURACIONES OPCIONALES
  stringgrid1.Options := [goFixedVertLine,goFixedHorzLine,goVertLine,goHorzLine,goRangeSelect,goColSizing];
  stringgrid1.Anchors := [akLeft,akTop,akRight,akBottom];
  memo1.Anchors := [akLeft,akTop,akRight];
end;


Código: [Seleccionar]

procedure TForm1.Button1Click(Sender: TObject);
var
  j: integer;
begin
  { EL PROGRAMA LEE UN ARCHIVO *.HEX DESDE LA UNIDAD C:\
  EL FORMATO DEL ARCHIVO ES EL SIGUIENTE:

  :BBBBBBBB BBBBBBBB BBBBBBBB BBBBBBBB BBBBBBBBBB

  SE VE QUE LA PRIMERA LINEA COMIENZA CON DOS PUNTOS, Y LA ULTIMA FILA TIENE
  10 NUMEROS, Y EL RESTO TIENEN 8 NUMEROS.}
 
  opendialog1.InitialDir := getcurrentdir; //INDICA LA RUTA DEL DIRECTORIO DONDE ESTA EL PROGRAMA
  opendialog1.Filter := 'ARCHIVO HEX|*.hex'; //TIPO DE ARCHIVO QUE VA A ABRIR EL DIALOGO
  if opendialog1.Execute then
  begin
    //LEE EL ARCHIVO Y LO ESCRIBE EN EL MEMO1
    memo1.Lines.LoadFromFile(opendialog1.FileName);

    //CONFIGURA EL NUMERO DE FILAS DEL STRINGGRID1
    stringgrid1.RowCount := memo1.Lines.Count + 1;

    //PARA CADA FILA SE LEE Y SELECCIONA LA PORCION DE TEXTO PARA
    //COLOCARLA EN LAS CELDAS DEL STRINGGRID1
    for j := 0 to stringgrid1.RowCount do
    begin
      stringgrid1.Cells[0,j+1] := ansimidstr(memo1.Lines[j],2,8);
      stringgrid1.Cells[1,j+1] := ansimidstr(memo1.Lines[j],11,8);
      stringgrid1.Cells[2,j+1] := ansimidstr(memo1.Lines[j],20,8);
      stringgrid1.Cells[3,j+1] := ansimidstr(memo1.Lines[j],29,8);
      stringgrid1.Cells[4,j+1] := ansimidstr(memo1.Lines[j],38,10);
    end;

  end;

{
utilizar
USES StrUtils
Delphi syntax:
function AnsiMidStr(const AText: AnsiString; const AStart, ACount: Integer): AnsiString;

}
end;
Suerte.

[droky]

Hola,
Si quieres manejar ficheros binarios puros, tienes que usar las funciones blockwrite y blockread para tratarlos como tal.
Un ejemplo con un stringgrid en hexadecimal con las filas para offset y las columnas de direccion al estilo de  WinPic800
El ejemplo lo he hecho solo para 64 bytes, pero es para que veas como se usa.

Código: [Seleccionar]

procedure TForm1.FormCreate(Sender: TObject);
begin
stringgrid1.ColCount:= 17;
stringgrid1.RowCount:= 5;
stringgrid1.DefaultColWidth:=32;
stringgrid1.DefaultRowHeight:=16;

stringgrid1.Cells[0,0]:='Offset';
stringgrid1.Cells[1,0]:='0';
stringgrid1.Cells[2,0]:='1';
stringgrid1.Cells[3,0]:='2';
stringgrid1.Cells[4,0]:='3';
stringgrid1.Cells[5,0]:='4';
stringgrid1.Cells[6,0]:='5';
stringgrid1.Cells[7,0]:='6';
stringgrid1.Cells[8,0]:='7';
stringgrid1.Cells[9,0]:='8';
stringgrid1.Cells[10,0]:='9';
stringgrid1.Cells[11,0]:='A';
stringgrid1.Cells[12,0]:='B';
stringgrid1.Cells[13,0]:='C';
stringgrid1.Cells[14,0]:='D';
stringgrid1.Cells[15,0]:='E';
stringgrid1.Cells[16,0]:='F';
stringgrid1.Cells[0,1]:='$00';
stringgrid1.Cells[0,2]:='$10';
stringgrid1.Cells[0,3]:='$20';
stringgrid1.Cells[0,4]:='$30';

// MyHex := inttohex(255,2);
end;

function TForm1.HexToInt(Value: String): Integer;
 begin
   Result := StrToInt('$' + Value);
end;

procedure TForm1.savebin_buttonClick(Sender: TObject);
//Boton Crear fichero Bin con filtro .bin
begin
savedialog1.InitialDir := getcurrentdir;
savedialog1.Filter := 'ARCHIVO BIN|*.bin';
savedialog1.Execute;
if savedialog1.FileName <> '' then savebin(savedialog1.FileName);
end;

Procedure TForm1.Savebin(sFilename : String);
var
  byteArray : array[1..16] of byte;
  I, J, K, dato_bin : Integer;
  hFile : File;
begin

  Assignfile(hFile, sFileName);
  rewrite(hFile, 16);  //Usamos bloques de 16 bytes

  with StringGrid1 do
    for I := 1 to RowCount - 1 do
     begin
       K := 1;
       for J:= 1 to ColCount - 1 do
        begin
           dato_bin:=hextoint(Cells[J,I]);
           bytearray[K]:= dato_bin;  //cargamos 16 bytes en el array
           K:=K+1;
        end;
        blockwrite(hfile,bytearray,1); // Escribe bloque de 16 bytes
  end;
  CloseFile(hFile);
 End;



procedure TForm1.openBinClick(Sender: TObject);
//Boton Guardar fichero Bin con filtro .bin
begin
 opendialog1.InitialDir := getcurrentdir;
 opendialog1.Filter := 'ARCHIVO BIN|*.bin';
 opendialog1.Execute;
 if opendialog1.FileName<>'' then loadbin(opendialog1.FileName);
end;

procedure TForm1.loadbin( Nom_Fichero:string);
var
Fichero:file;
I, J: Integer;
dato_bin : array[1..16] of byte;
begin

  assignfile(fichero, Nom_Fichero);
  reset(fichero,16);  //Cargamos 16 bytes de cada vez ( 1 fila )


  with StringGrid1 do
    for I := 1 to RowCount - 1 do
     begin
       blockread(fichero,dato_bin,1); //Lee 1 bloque de 16 bytes
       for J:= 1 to ColCount - 1 do
        begin
           Cells[J,I]:= inttohex(dato_bin[J],2); //Pone 16 bytes en la fila
        end;
  end;
  closefile(fichero);
  end;


end.


Como puedes ver, hago lectura y escritura del fichero en bloques de 16 bytes porque así cargo por offsets de $10
Te dejo los fuentes y el ejecutable :
Fuentes y ejecutable

Salu2

[eto]

Hola droky muy buen ejemplo, no conocía esas funciones (blockread, blockwrite) a mi tambien me va a servir mucho tu ejemplo, pero más adelante con un proyecto que tengo pendiente. 

[ASTROCAR]

oye que buenos ejemplo mejor imposible ya tendre para los dos formatos  bin y hex mi  agradecido y eso era exactamente la informacion que no manejaba en delphi los reviso al detallado y hago mi propio codigo y se los muestro aunque les digo que ya llevos mis avances.

Saludos y Nuevamentes gracias por su tiempo y valiosa colaboracion prestada.
Atten.
Alexander Santana.
Barcelona-Venezuela.

[ASTROCAR]

Hola antes que todo Feliz Navidad y que el niño dios le respare todos los exitos posible y lo mejor salud  para todos los seres vivientes. Ahora paso a el tema en un principio inicie este post con el fin de manipular ficheron bin en un control Stringgrid pero por recomendaciones de un colega de este mismo foro empecea trabajar e investigar sobre el componente MPHexEditor que no es mas que un editor hexadecimal muy potente y aca les muestro los avance de el desarrollo de mi aplicacion el cual esta muy bueno aunque aun le falta y acepto todo tipo de recomendaciones.

En estos momentos estoy investigando varios puntos entre ellos con abrir ficheron con el formato intel hex lo otro es que una ves teniendo abierto un fichero en el formato que sea como hacer swap en el componente MPHexEditor.

Saludos y aca les subo una imagen y el ejecutable de como esta quedando mi aplicacion.
Atten.
Alexander santana.
Barcelona-Venezuela.

[droky]

Hola Astrocar,
Muy interesante este componente para un editor Hex.
HAcer un swap, ¿te refieres a cada byte del fichero? es decir si tienes en $0001 un byte de valor $FE, hacerle un swap y convertir el valor en $EF ¿no?
En ese caso lo más sencillo es coger el valor, convertirlo a string, cambiar de posición los dos caracteres y convertirlo al formato de origen en el componente (integer o hex). En caso de un swap a todo el bin, usar un bucle con un contador bidimensional tipo contador[i,j]

Te está quedando muy bien la aplicación. Ya nosmostrarás algo del programador   
Salu2

[ASTROCAR]

Hola Astrocar,
Muy interesante este componente para un editor Hex.
HAcer un swap, ¿te refieres a cada byte del fichero? es decir si tienes en $0001 un byte de valor $FE, hacerle un swap y convertir el valor en $EF ¿no?
En ese caso lo más sencillo es coger el valor, convertirlo a string, cambiar de posición los dos caracteres y convertirlo al formato de origen en el componente (integer o hex). En caso de un swap a todo el bin, usar un bucle con un contador bidimensional tipo contador[i,j]

Te está quedando muy bien la aplicación. Ya nosmostrarás algo del programador   
Salu2

Hola gracias por su comentario y en cuanto al swap si me refiero hacerlo a todo el fichero o en su defecto selecionar una parte del fichero y hacerle swap y el swap es algo como usted mismo mensiono pero no a un byte sino a  dos byte de la data ejemplo ff ee al hacerle swap quedaria de la siquiente manera ee ff.

Saludos y nuevamente gracias por dar su opinion y estar al pendiente de este post.
Atten.
Alexander Santana.
Barcelona-Venezuela.

[ASTROCAR]

Buenas noches aca subo nuevamente el desarrollo de la aplicacion ya con el problema de swap resuelto y una que otras funciones para manipular la data que se carga en el componente.
Ahora el tema siguiente por atacar es el formato intel si tienes recomendaciones en cuando a dicho formato en delphi y presentarlo en el componente que estoy operando seria de gran ayuda.

Saludos y aca le subo como llevo la aplicacion.
Atten.
Alexander Santana.
Venezuela-Barcelona.

[droky]

Hola Alexander,
A ver si puedo ayudarte,
    
Formato general de un fichero en formato Intel HEX (8 bit)
Consta de sucesivos RECORDs (líneas a partir de ahora) que almacenan datos e información de como y donde van esos datos.
Cada línea comienza con un RECORD MARK que es un campo conteniendo 03AH, el código ASCII de los dospuntos (colon ) (’ : ’) .

Cada línea tirne un campo RECLEN que especifica el número de bytes de información o datosque siguen al campo RECTYPE (tipo de registro, o tipo de información contenida en la línea). Cada byte de datos se representa con dos caracteres ASCII y el valor máximo de RECLEN es de 255 o 'FF'.

Cada línea tiene un campo OFFSET (Load OFFSET) o dirección (ADDRESS) que especifica la dirección de 16 bit donde comienzan los datos que contiene la línea. Esto si la línea contiene datos, en caso de que no los contenga y contenga otros campos informativos entonces tiene que tener el valor '0000' o '30303030' hexadecimal.

Cada línea tiene un campo RECTYPE que indica el tipo de datos que contiene la línea. Este campo es usado para interpretar el resto de la línea. Los tipos de RECTYPE son:

’00’ Linea conteniendo datos <=Es el que usaremos
’01’ EOF fin de datos <=Tambien lo vamos a usar
’02’ Extended Segment Address Record ->De este pasamos
’03’ Start Segment Address Record ->De este tambien
’04’ Extended Linear Address Record -> Y de este
’05’ Start Linear Address Record -> y de estelo mismo

Cada linea tiene un numero variable de datos que pueden contener cero  o más bytes codificados en pares de dígitos hexadecimales . La interpretación de estos datos se hace según lo que indique el campo RECTYPE.

Cada línea termina con un campo CHECKSUM que contiene la representación hexadecimal en ASCII del complemento a 2 en 8 bits resultante de convertir cada par de códigos ASCII en su correspondiente número hexadecimal desde el campo RECLEN hasta el último byte de datos de la línea.Asímismo la suma de todos los datos de una línea, desde RECLEN e incluyendo el Checksum es igual a cero.

Ejemplo:

:1005AA00000102030405060708090A0B0C0D0E0F88
       ^----- calculo del checksum -----^^^
                                         ||
                              Check sum__|
RECLEN = 0x10 = 16
ADDRESS = 0x05AA
RECTYPE = 00
DATA = 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
CHKSUM = 0x88 = 256 -sum(0x00+..+0x0F)= 256- 0x78

Esta podría ser una rutina de lectura:

Código: Delphi

1. type buffer=array of byte;  //Asignamos una matriz dinámica
2. var HexBuf:buffer;
3.  
4. function readline(HexLine:string; var Buf:buffer):integer;
5. var ADDR,count:integer;
6.  CHKSUM,SUMLINE,RECLEN,RECTYPE,DATA:byte;
7.  t:shortstring;
8. begin
9.  // Longitud de la matriz (100000) se puede cambiar
10.  SetLength(HexBuf,100000);
11.  if HexLine[1]=':' then begin
12.   t:='$'+copy(HexLine,2,2);   // lee longitud (RECLEN)
13.   RECLEN:=strtoint(t);
14.   CHKSUM:=0;
15.   CHKSUM:=CHKSUM+RECLEN;
16.   t:='$'+copy(HexLine,4,4); // lee offset
17.   ADDR:=strtoint(t);
18.   CHKSUM:=CHKSUM+lo(ADDR)+hi(ADDR);
19.   t:='$'+copy(HexLine,8,2);
20.   RECTYPE:=strtoint(t);
21.   CHKSUM:=CHKSUM+RECTYPE;
22.   case RECTYPE of
23.    0:begin             // Bloque de datos
24.      count:=0;
25.      while (count < RECLEN) do begin
26.       t:='$'+copy(HexLine,10+2*count,2);
27.       DATA:=strtoint(t);
28.       CHKSUM:=CHKSUM+DATA;
29.       Buf[ADDR+count]:=DATA;
30.       inc(count);
31.      end;
32.      t:='$'+copy(HexLine,10+2*count,2);
33.      SUMLINE:=strtoint(t);
34.      end;
35.    1:begin                      // EOF o fin de fichero
36.       t:='$'+copy(HexLine,10,2);
37.       SUMLINE:=strtoint(t);
38.       result:=1;
39.      end;
40.      else
41.      begin
42.         result := -2;  // tipo de record inválido
43.         exit;
44.      end;
45.     end; //fin de bloque case
46.   // test checksum
47.   DATA:=SUMLINE+CHKSUM;
48.   if (DATA<>0) then result:=-3; // checksum error
49.  end
50.  else result:=-1; // no hay record
51. end;

Y un ejemplito de uso:

Código: Delphi

1. procedure TForm1.Button1Click(Sender: TObject);
2. var Fname,line:string;
3.     Fp : textfile;
4.     ErrorCode:integer;
5. begin
6.     Fname:='test.hex';
7.     AssignFile(Fp,Fname); //fichero test.hex
8.     Reset(Fp);
9.     while not eof(Fp) do
10.     begin
11.       Readln(Fp, line);//lee primera línea del fichero
12.       ErrorCode := readline(line,HexBuf);
13.       if (ErrorCode=0) then
14.       begin
15.        // Linea leída OK
16.        // aquí va el código a pegar Hexbuf en tu control
17.       end
18.       else
19.       begin
20.        // Manejo de errores
21.        //  0 = No error
22.        // -1 = Fichero no es Intel Hex
23.        // -2 = Tipo de record inválido
24.        // -3 = Checksum error
25.        break;  // fin loop
26.       end;
27.     end;
28.     CloseFile(Fp);
29. end;

Esto en cuanto a la lectura, para la escritura, puedes usar esta función:

Código: Delphi

1. function writeline(ADDR,RECLEN,RECTYPE:integer;
2.             var buf:buffer):string;
3. var i:integer;
4.  CHKSUM:byte;
5.  
6. begin
7.  CHKSUM:=0;
8.  result:=':'+inttohex(RECLEN,2)+
9.             inttohex(ADDR,4)+inttohex(RECTYPE,2);
10.  CHKSUM:=RECLEN+lo(ADDR)+hi(ADDR);
11.  for i:=0 to RECLEN-1 do begin
12.   result:=result+inttohex(buf[ADDR+i],2);
13.   CHKSUM:=CHKSUM+buf[ADDR+i];
14.  end;
15.  result:=result+inttohex(256-CHKSUM,2);
16. end;
17.  
18. function write_eof:string;
19. begin
20.  result:=':00'+'0000'+'01'+'FF';  // :00000001FF fin de fichero
21. end;

Y un ejemplo de uso:

Código: Delphi

1. procedure TForm1.Button2Click(Sender: TObject);
2. var Fname,line:string;
3.     Fp : textfile;
4.     ErrorCode,StartAddr,ByteCnt:integer;
5.     A_Line,EOF_HEX:string;
6. begin
7.  
8.     StartAddr:=$0000;  //Direccion de inicio 0000
9.     ByteCnt:=3;    // 3 bytes
10.     SetLength(HexBufOut,ByteCnt);
11.     HexBufOut[0]:=$01;
12.     HexBufOut[1]:=$02;
13.     HexBufOut[2]:=$03;
14.  
15.     Fname:='test1.hex';
16.     AssignFile(Fp,Fname); //Guarda fichero test1.hex
17.     Rewrite(Fp);
18.     // escribe 16 bytes en HexBuf
19.     A_Line:=writeline(StartAddr,ByteCnt,$00,HexBufOut);  
20.     EOF_HEX:=':00'+'0000'+'01'+'FF';// escribe EOF del fichero hex
21.     writeln(Fp,A_Line);
22.     writeln(Fp,EOF_HEX);
23.     closefile(Fp); //cierra el fichero
24. end;

Ahora solo necesitas implementar el poner los datos de Hexbuf a tu control y sacarlos para hexbuf antes de escribir el fichero, incorporar un cuadro de diálogo de abrir fichero o guardar y ya está. ¿sencillo, no?
Espero haberte ayudado,

Salu2

[ASTROCAR]

Ok droky muchas gracias por tu pronta respuesta y muy explicito lo del formato intel hex, ahora me toca que desarrole un codigo en delphi para que pueda interpretar el formato y asi representa la data en el componente editor como se quiere y lo otro seria ya guardar la data tambien manteniendo el formafo intel hex.

Saludos y voy hacer un codigo a mi manera lko que si tengo que investigar mejor es como manejar esos archivos binarios porque siguen siendo binario solo que ahora tiene un formato de identificacion como el caso del intel hex y asi otros formatos que ahora no los tocare como son el e2p que lo usa el software de ponyprog y el s19 que lo usa la gente de motorola y pare de contar pero como ya les indique siguen siendo binarios secuenciales lo otro es llevarlo o interpretarlo conm un formato tal.

Atten.
Alexander Santana.
Barcelona-Venezuela.

Este link tambiern puede ayudar: http://www.sixca.com/delphi/article/readhex.html

[Nocturno]

No deberíais perderos la novela del amigo Diego: "El fichero .HEX explicado"

[jacrmr]

Saludos y voy hacer un codigo a mi manera lko que si tengo que investigar mejor es como manejar esos archivos binarios porque siguen siendo binario solo que ahora tiene un formato de identificacion como el caso del intel hex y asi otros formatos que ahora no los tocare como son el e2p que lo usa el software de ponyprog y el s19 que lo usa la gente de motorola y pare de contar pero como ya les indique siguen siendo binarios secuenciales lo otro es llevarlo o interpretarlo conm un formato tal.

En efecto como dices cualquier archivo es binario, pero la forma de apertura y de manejo no necesariamente lo es. Para el caso de archivos con formato .HEX, Tecktronix, S19, y similares deberías tratarlos como archivos de texto (que es lo que son en realidad), con lo cual se te facilita toda la manipulación de los datos.

[droky]

No deberíais perderos la novela del amigo Diego: "El fichero .HEX explicado"

Interesante post, no lo habia visto,
Gracias Nocturno.
Salu2

[ASTROCAR]

No deberíais perderos la novela del amigo Diego: "El fichero .HEX explicado"

Interesante post, no lo habia visto,
Gracias Nocturno.
Salu2

Yo si lo habia leido de hecho de ese post es que tengo claro el formato intel mi drama es llevar eso a delphi.

Ahora lo que comenta el colega jacrmr  tiene mucha razon pero recuerda que estoy usando un componente editor hex y por eso quiero representar mi  formato intel en ese dicho componente.

Saludos y nuevamente gracias por su opiniones.
Atten.
Alexander Santana.
Venezuela-Barcelona.