TODOPIC

Microcontroladores PIC => Todo en microcontroladores PIC => Mensaje iniciado por: RedPic en 07 de Octubre de 2008, 17:31:38

Título: El Fichero .HEX explicado
Publicado por: RedPic en 07 de Octubre de 2008, 17:31:38

Prefacio u introito

Continúo con mi costumbre de publicar lo que aprendo para que otros puedan aprender lo que yo he aprendido durante mi aprendizaje .. (demasiados aprenderes para tan poca frase así que ahí lo dejamos :D)

Como últimamente he estado batallando con la interpretación de estos ficheros .HEX he tenido que enterarme de cómo están construidos así que aquí tenéis un poco de información de ellos, útil sobre todo para los nuevos diseñadores de grabadores de PIC's o para los que estén entrando en el tema de los Bootloadores. Ambos deben empezar por conocer esto de los .HEX

Introducción al asunto

Cada vez que compiláis u ensambláis un programa fuente vuestro compilador u ensamblador genera un fichero .HEX cuyo contenido se corresponde exactamente con lo que ha de ser grabado en la memoria de programa (o EEPROM) del PIC.

Fijaos que he dicho "se corresponde" y no que sea exactamente lo que ha de ser grabado en el PIC, no es una "imagen" de la memoria de programa del PIC, sino una serie de instrucciones que el grabador de PIC's o el Bootloader que utilicemos sabe interpretar y por lo tanto grabar lo que corresponde exactamente en su sitio.

Es la explicación o interpretación de este formato de lo que trata este post.

En fondo un fichero .HEX no es mas que una lista de direcciones de memoria y lo que contiene cada una de estas posiciones.

Mas adelante veremos cómo están codificadas las direcciones y su contenido. Ahora vamos a ver un poco de Historia: El formato .HEX es del fabricante de micros INTEL que lo inventó allá por los años 70 del siglo pasado para usarlo exactamente para lo mismo que nosotros lo estamos usando ahora pero para sus micros 8085 y otros cacharros antediluvianos por el estilo (no reíros pero yo los he programado  :)) y desde entonces está en uso. Muchos otros fabricantes lo han adoptado como propio y otros lo han copiado cambiando esto y aquello para al final hacer lo mismo (por ejemplo el SRecord de Motorola y otros)

Aunque hay tres tipos de ficheros HEX: de 8 bits, de 16 bits y de 32 bits también llamados I8HEX, I16HEX e I32HEX respectivamente vamos a ver solo el de 8 bits que es el que más utilizamos para nuestros PIC's 16F y 18F, el resto son muy parecidos pero no iguales y lo dejamos para otro momento.

Descripción

Un fichero .HEX es un fichero de texto. Por lo tanto puede ser editado con un notepad o similar.

Una muestra de su apariencia es:

:020000040000FA
:1000000043EF00F0EA6A070EE96EEF500DE0060ECE
:10001000016E006A002EFED7012EFBD77B0E006E0C
:10002000002EFED7EF2EF3D7000C0990099208524C
:1000300002E0098001D0098207C003F00650D8B45D
:100040000706060603101EE0000E0AB2010E0B6E34
:10005000000E09B0010E0B24016EE8B002D0819CA5
:1000600001D0818C000E0AB2010E0B6E000E09B297
:10007000010E0B24016EE8B002D0819C01D0818C6E
:100080000A2ADAD7000CF86AD09EEA6AE96AC150F7
:10009000C00B0F09C16E070EB46E040E066EFA0E89
:1000A000076EB0DF062EFBD7076A190E066E086AC8
:1000B000BCDF040E066EFA0E076EA4DF062EFBD719
:1000C000076A190E066E010E086EAFDFE6D7030051
:020000040030CA
:0E000000000C1E1F008381000FC00FE00F4098
:00000001FF
;PIC18F4550


Consiste en una serie de líneas consecutivas que empiezan siempre por el carácter ":" (dos puntos) salvo los comentarios que usan ";" (punto y coma) y terminadas en [0x0D][0x0A] (Fín de línea, Retorno de Carro)

Todos números: Longitudes, direcciones y datos están expresados en HEXADECIMAL mediante sus caracteres ASCII correspondientes.

La estructura de una línea es:

• Start code Un caracter, ":" para líneas con contenido, ";" para comentarios.
• Byte count Dos caracteres HEX que indican el número de datos en Data.
• Address Cuatro caracteres HEX para la dirección del primer dato en Data.
• Record typeDos caracteres HEX que indican el tipo de línea, de 00 a 05. (ver mas abajo)
• Data Secuencia de 2 * n caracteres HEX correspondientes a los Byte count datos definidos antes.
• ChecksumDos caracteres HEX de Checksum calculado según el contenido anterior de la línea en la forma: El byte menos significativo del complemento a dos de la suma de los valores anteriores expresados como enteros los caracteres hexadecimales  (sin incluir ni el Start code ni al él mismo)

Cada línea puede expresar según su Record type:

• 00 data record: Línea de datos, contiene la dirección del primer dato y la secuencia de datos apartir de ésa.
• 01 End Of File record: Línea de Fin del Fichero HEX. Indica que se han acabado las líneas de datos. Usualmente es ":00000001FF"
• 02 Extended Segment Address Record: Usado para procesadores 80x86 (No nos interesa aquí)
• 03 Start Segment Address Record: Usado para procesadores 80x86 (No nos interesa aquí)
• 04 Extended Linear Address Record: Si las líneas de datos que sigan a ésta necesitan una dirección mayor que la de 16 bits ésta línea aporta los otros 16 bits para completar una dirección completa de 32 bits. Todas las líneas que sigan a esta deben completar su dirección con hasta los 32 bits con el contenido de la última línea de tipo 04
• 05 Start Linear Address Record: Usado para procesadores 80386 o superiores (No nos interesa aquí)

Nuestro Ejemplo

Podemos así entonces interpretar nuestro ejemplo anterior de la siguiente forma:

: 02 0000 04 0000 FA
-> Línea relevante, con dos bytes de información, de tipo 04 : luego las direcciones siguientes se complementan a 32 bits con 0x0000, 0xFA es el checksum.
: 10 0000 00 43 EF 00 F0 EA 6A 07 0E E9 6E EF 50 0D E0 06 0E CE
-> Línea relevante, con 16 bytes de información, de tipo 00 : así que hay que escribir 0x43 (en 0x00000000), 0xEF (en 0x00000001), ... , 0x0E (en 0x0000000F). 0xCE es el checksum.
: 10 0010 00 01 6E 00 6A 00 2E FE D7 01 2E FB D7 7B 0E 00 6E 0C
-> Línea relevante, con 16 bytes de información, de tipo 00 : así que hay que escribir 0x01 (en 0x00000010), 0x6E (en 0x00000011), ... , 0x6E (en 0x0000001F). 0x0C es el checksum.
...
...
...
: 02 0000 04 0030 CA
-> Línea relevante, con dos bytes de información, de tipo 04 : luego las direcciones siguientes se complementan a 32 bits con 0x0030, 0xCA es el checksum.
: 0E 0000 00 00 0C 1E 1F 00 83 81 00 0F C0 0F E0 0F 40 98
-> Línea relevante, con 14 bytes de información, de tipo 00 : así que hay que escribir 0x00 (en 0x00300000), 0x0C (en 0x00300001), ... , 0x40 (en 0x0030000D). 0x98 es el checksum.
:00000001FF
-> Línea relevante. Fin de Fichero HEX
;PIC18F4550
-> Línea irrelevante. Comentario.

Bueno, y eso es todo por hoy. Espero que os aproveche.  :mrgreen:

Título: Re: El Fichero .HEX explicado
Publicado por: doppel en 08 de Octubre de 2008, 00:18:59

exelente DON DIEGO!!! gracias por compartir este tipo de información  :-/ el articulo está muy interesante.-

saludos

Hernán

Título: Re: El Fichero .HEX explicado
Publicado por: MLO__ en 08 de Octubre de 2008, 11:33:46

MUCHISIMAS GRACIAS MAESTRO DIEGO !!!!!!!!

Saludos

Título: Re: El Fichero .HEX explicado
Publicado por: Cryn en 20 de Octubre de 2008, 17:55:29

Gracias Maestro Rojo, muy buena explicación, y ademas de util, es muy bueno aprender con ud.

muchas gracias :-/ :-/ :-/

Título: Re: El Fichero .HEX explicado
Publicado por: migsantiago en 04 de Noviembre de 2008, 17:56:06

Hola Redpic

Estoy estudiando tu tutorial para ver si puedo generar un programa que convierta archivos hex a una lista de instrucciones dadas en binario, pero me atoré en la parte en donde dices...

Citar

-> Línea relevante, con 16 bytes de información, de tipo 00 : así que hay que escribir 0x43 (en 0x00000000), 0xEF (en 0x00000001), ... , 0x0E (en 0x0000000F). 0xCE es el checksum.

Me atoré porque comentas que se escribe 1 byte de información (0x43) en la primera dirección y luego otro byte de información en la segunda dirección.

El pic16 tiene instrucciones de 14 bits de largo, las cuales son mayores que un byte, ¿0x43 correspondería al byte menos significativo de la primera dirección y 0xEF al byte más significativo de la primera dirección? Es decir...

Dirección - Contenido
0x0000      0xEF43

¿o es al revés?

Dirección - Contenido
0x0000      0x43EF

Parece tener más sentido en la última combinación ya que los bits 15 y 14 de una instrucción de pic16 no existen y se consideran como ceros, por lo que 0xef43 no existe como instrucción pic.

Gracias  :mrgreen:

Título: Re: El Fichero .HEX explicado
Publicado por: RedPic en 04 de Noviembre de 2008, 18:48:18

Ufff Santiago .. me pillas en fuera de juego.

Lo que si puedo decirte es que el bootloader trata es información exactamente como la describo: escribe el byte correspondiente en la dirección dada.

Así "trasladado" a C de bootloader esta línea

:1000000043EF00F0EA6A070EE96EEF500DE0060ECE

sería

int8 buffer[0x10] = {0x43, 0xEF, 0x00, 0xF0, 0xEA, 0x6A, 0x07, 0x0E, 0xE9, 0x6E, 0xEF, 0x50, 0x0D, 0xE0, 0x06, 0x0E}
write_program_memory(0x0000, &buffer, 0x10);

sabiendo que write_program_memory admite como parámetros Address, dataptr y Count y entonces escribe consecutivamente, a partir de la dirección Address, un número Count de bytes tomados a partir de dataptr.

Lo que signifique cada byte escrito en esas posiciones y como se conjugan para dar instrucciones de mas de un byte en los PIC's simplemente lo desconozco. Mi experiencia con estos temas es con otros tipos de micros en los que las instrucciones son solo de un byte seguidos por el número oportuno de argumentos ( Z80, 8081 y otros por el estilo) y la implementación en PIC's no la he estudiado (por ahora). Lo siento.

Título: Re: El Fichero .HEX explicado
Publicado por: migsantiago en 04 de Noviembre de 2008, 18:59:57

No hay problema Diego.  :mrgreen:

Esto amerita una investigación más profunda. Estoy simulando un pic16 con código vhdl y para el banco de pruebas (memoria de programa) debo crear un archivo de texto con los códigos de operación en binario.

Voy a ver si puedo aportar algo después de hacer ingeniería inversa a un hex.  :o

Título: Re: El Fichero .HEX explicado
Publicado por: migsantiago en 04 de Noviembre de 2008, 19:20:58

Dando una revisión rápida a un ejemplo que compilé...

Código ASSEMBLER

efe equ 0x00
org 0x0000
nop
return
retfie
movwf efe
clrw
clrf efe
subwf efe,1
decf efe,1
iorwf efe,1
andwf efe,1
xorwf efe,1
addwf efe,1
movf efe,1
comf efe,1
incf efe,1
decfsz efe,1
rrf efe,1
rlf efe,1
swapf efe,1
incfsz efe,1
bcf efe,1
bsf efe,1
btfsc efe,1
btfss efe,1
call 0
goto 0
movlw efe
retlw efe
iorlw 0
andlw 0
xorlw 0
sublw 0
addlw 0
end


Código Máquina (checado con winpic800)

nop    0000
return 0008
retfie 0009
movwf  0080
clrw   0103
clrf   0180
subwf  0280
...


Código .HEX generado con mplab

:020000040000FA
:1000000000000800090080000301800180028003D5
:10001000800480058006800780088009800A800BA4
:10002000800C800D800E800F801080148018801C42
:10003000002000280030003400380039003A003C2D
:02004000003E80
:00000001FF


Código .HEX separado por bytes

:02 0000 04 0000FA
:10 0000 00 00 00 08 00 09 00 80 00 03 01 80 01 80 02 80 03 D5
:10001000800480058006800780088009800A800BA4
:10002000800C800D800E800F801080148018801C42
:10003000002000280030003400380039003A003C2D
:02004000003E80
:00000001FF

Interpretación
Segunda línea
:10 0000 00 00 00 08 00 09 00 80 00 03 01 80 01 80 02 80 03 D5

16 bytes de info
Dirección de inicio 0x0000
Data record
Dir 0x0000 00
dir 0x0001 00
dir 0x0002 08
dir 0x0003 00
dir 0x0004 09
dir 0x0005 00
...

Interpretando para el pic (14 bits por dirección)...

dir 0x0000 0000
dir 0x0001 0008
dir 0x0002 0009
dir 0x0003 0080
dir 0x0004 0103
dir 0x0005 0180
dir 0x0006 0280

Sólo hay que invertir la posición de los bytes. El primero que aparece es el menos significativo; el segundo que aparece es el más significativo.

El programa para la conversión parece simple, espero poder escribirlo en estos días.  :mrgreen:

Gracias Diego (http://www.todopic.com.ar/foros/Themes/babylon/images/post/thumbup.gif)

Título: Re: El Fichero .HEX explicado
Publicado por: migsantiago en 11 de Noviembre de 2008, 02:08:32

Ya terminé el programa para la conversión de .hex a .txt.

El programa recibe un .hex generado con mplab o ccs y extrae la memoria de programa y la vuelca en un archivo .txt en código ascii.

Por ejemplo, si se tiene el programa:

Código: [Seleccionar]

efe equ 0x00
org 0x0000
nop
return
retfie
movwf efe
clrw
clrf efe
subwf efe,1
decf efe,1
iorwf efe,1
andwf efe,1
xorwf efe,1
addwf efe,1
movf efe,1
comf efe,1
incf efe,1
decfsz efe,1
rrf efe,1
rlf efe,1
swapf efe,1
incfsz efe,1
bcf efe,1
bsf efe,1
btfsc efe,1
btfss efe,1
call 0
goto 0
movlw efe
retlw efe
iorlw 0
andlw 0
xorlw 0
sublw 0
addlw 0
end
El archivo.txt que genera el programa es el siguiente:

Código: [Seleccionar]

00000000000000
00000000001000
00000000001001
00000010000000
00000100000011
00000110000000
00001010000000
00001110000000
00010010000000
00010110000000
00011010000000
00011110000000
00100010000000
00100110000000
00101010000000
00101110000000
00110010000000
00110110000000
00111010000000
00111110000000
01000010000000
01010010000000
01100010000000
01110010000000
10000000000000
10100000000000
11000000000000
11010000000000
11100000000000
11100100000000
11101000000000
11110000000000
11111000000000
11111111111111
11111111111111
En donde cada línea representa la instrucción del pic16 en modo binario, teniendo por ejemplo a NOP = 00000000000000 o teniendo a SUBLW 0x00 = 11110000000000. Se respeta la posición en la memoria como en org 0x05, dejando las líneas sin código como 11111111111111, que equivale a un pic nuevo o a una instrucción ADDLW 0xFF.

¿Qué no hace el programa? No lee la EEPROM ni los fusibles de configuración del pic; tampoco identifica al pic para el que fue ensamblado.

Al programa se le puede meter más mano, incluso teniendo el txt ya convertido se puede hacer un desensamblador muy básico, pero eso ya existe en otros programas como en Winpic800.

Adjunto el código fuente y el programa para quiénes lo vean útil.  :mrgreen:

http://www.4shared.com/file/70640741/6ec22da6/Hex2TxtSan.html

Hay un bug que no supe corregir: si generan un archivo.txt con el mismo nombre por segunda vez les marca error. Solo hay que quitarle la propiedad de Solo Lectura al archivo y listo :D

Título: Re: El Fichero .HEX explicado
Publicado por: MLO__ en 11 de Noviembre de 2008, 02:14:32

 :shock: :shock: :shock:

Felicitaciones mig .... eres grande!!!!

Saludos

Título: Re: El Fichero .HEX explicado
Publicado por: RedPic en 11 de Noviembre de 2008, 05:18:53

Muy bueno, Santiago, tu análisis. Me gusta.  :mrgreen:

Título: Re: El Fichero .HEX explicado
Publicado por: migsantiago en 11 de Noviembre de 2008, 14:55:36

Gracias compañeros.  :mrgreen:

Título: Re: El Fichero .HEX explicado
Publicado por: Cryn en 21 de Julio de 2009, 17:20:18

una pregunta, como están los fuses dentro del .hex??

saludos

Título: Re: El Fichero .HEX explicado
Publicado por: migsantiago en 21 de Julio de 2009, 18:30:04

Leyendo la guía de Diego los puedes encontrar.

Te adjunto las últimas líneas del HEX de un PIC16F88:

Código: [Seleccionar]

:1003B000831605118312E029831605158312E0299F
:1003C000952963000A148A100A118207CA29D029C4
:0403D000D629DC2925
:04400E00222EFF3F20
:00000001FF
;PIC16F88
;CRC=AB3F  CREATED="05-Jul-09 11:39"

Viendo la datasheet del mismo te indica que los configuration bits están en 0x2007 y 0x2008.

Sabiendo que las palabras del PIC en su memoria de programa toman 14 bits, entonces cada palabra toma 2 bytes. Hay que multiplicar 0x2007 por 2.

0x2007 * 2 = 0x400E

Buscando la palabra se encuentra al final...

Código: [Seleccionar]

:04400E00222EFF3F20
Lo que dice es:

04 bytes de datos
400E dirección de inicio
00 data record
222E es el contenido de 0x2007 (invertidos)
FF3F es el contenido de 0x2008 (invertidos)
20 Checksum de la línea

Y si aún así no lo puedes encontrar, puedes usar WinPic800 para corroborarlo:

(http://img518.imageshack.us/img518/4271/confbits.jpg)

Título: Re: El Fichero .HEX explicado
Publicado por: Cryn en 21 de Julio de 2009, 18:53:24

ok entendido, supongo q siempre los fuses o config siempre están en la ultima linea antes de terminar con 1FF

y en un bootloader quizá no siempre sea necesario cambiarlos no?

saludos, gracias por la respuesta

Título: Re: El Fichero .HEX explicado
Publicado por: migsantiago en 21 de Julio de 2009, 18:58:15

Los fuses pueden estar en cualquier lugar del archivo hex, pero los compiladores acostumbran colocarlos al final. Solo busca la dirección hexadecimal y multiplícala por 2 para encontrarlos. Esa dirección debe aparecer en el 4to, 5to, 6to y 7o caracter de una línea:

:04400E00222EFF3F20

Nunca he usado bootloaders, no sabría contestarte.

Título: Re: El Fichero .HEX explicado
Publicado por: Cryn en 21 de Julio de 2009, 19:13:26

y lo mismo con la EEPROM verdad? multiplicar por 2 y se verían los datos a continuación

como es que funciona el Record type 04? no lo logro entender

Título: Re: El Fichero .HEX explicado
Publicado por: RedPic en 21 de Julio de 2009, 20:13:48

Cryn, los registros de tipo 00, de datos, tienen el Address inicial del primer byte a colocar con solo 16 bits, cuatro dígitos en hexadecimal ... sin embargo hay direcciones en los PIC's mayores que 0xFFFF por lo que entonces se usan los registros de tipo 04, sirven para completar direcciones mayores, hasta 32 bits. Es como añadirle un Offset a todas las direcciones de los registros que vengan a continuación.

Así si tenemos dos registros como estos (separo los dígitos significativos):

:02 0000 04 0030 CA
:0E 0000 00 00 0C 1E 1F 00 83 81 00 0F C0 0F E0 0F 40 98

El primero, el de tipo 04, indica que la dirección de los que le siguen deben completarse con  0030 para formar una dirección de 32 bits.

El siguiente registro, el de tipo 00, indica que hay que poner 0E bytes a partir de la dirección 0000, pero como tenemos un offset anterior dado por el registro de tipo 04, la dirección real será 00300000 para el primer byte, 00300001 para el segundo, 00300002 para el tercero .... etc.

Fíjate que los HEX acostumbran a empezar por un registro de tipo 04 en la forma:

:020000040000FA

que indica que lo que viene a continuación debe empezar en 0000. Esto sirve para prevenir que el PIC pueda haberse quedado con un offset anterior y que al recibir una nueva linea de datos lo envíe a cualquier sitio. Es como inicializar el puntero de memoria para empezar a recibir datos.  :mrgreen:
  


  

Título: Re: El Fichero .HEX explicado
Publicado por: migsantiago en 21 de Julio de 2009, 22:01:45

Cita de: Cryn en 21 de Julio de 2009, 19:13:26

y lo mismo con la EEPROM verdad? multiplicar por 2 y se verían los datos a continuación

como es que funciona el Record type 04? no lo logro entender

Según una prueba que hice con un hex, es cierto, se multiplica también por 2...

Código: [Seleccionar]

:10 4200 00 6400 6600 6700 6800 6A00 6B00 6C00 FF00 D5
y desperdician un byte poniéndolo a 0x00. Esto equivale a:

(http://img9.imageshack.us/img9/6953/eeprom.jpg)

en donde 0x2100 es donde empieza la memoria eeprom en los PIC16.

Sobre el 04 creo que Redpic ya te lo explicó muy bien. El 04 no hace falta en ningún PIC16 porque no superan las 2^16 direcciones en ninguna de sus memorias.

Título: Re: El Fichero .HEX explicado
Publicado por: Cryn en 22 de Julio de 2009, 12:52:23

aaaah ok,entonces un  04 viene de la mano con un 00, si hay un 04 se usa la siguiente linea con ese offset, ahora si. Gracias redpic

ok, entonces con la EEPROM, gracias mig

ahora a meterle mano al bootloader, que no se esta dejando

saludos amigos.

Título: Re: El Fichero .HEX explicado
Publicado por: ramiroreal en 10 de Septiembre de 2009, 06:35:15

Disculpen, ya he escrito otro post y ahora encontre este, lo curioso es que no lo encontre por el buscador del foro( que si  busque) sino de rebote en una busqueda (la numero 100000) en google.
Pido disculpas por el doble post, pero alguien podria explicar el proceso de checksum???
No lo entiendo ni de lejos. Muchisimas gracias

Título: Re: El Fichero .HEX explicado
Publicado por: J1M en 11 de Septiembre de 2009, 08:20:34

Ramiro, te pego un código (extraido del bootloader usb de CCS) que calcula el CHKSM de cada línea, quizá así entiendas mejor el proceso:

checksum = 0;  // Sum the bytes to find the check sum value
for (i=1; i<(buffidx-3); i+=2)
checksum += atoi_b16 (&buffer);
checksum = 0xFF - checksum + 1;

saludos

Título: Re: El Fichero .HEX explicado
Publicado por: ramiroreal en 12 de Septiembre de 2009, 06:47:37

Muchisimas gracias!
Sos un genio!
Con esto creo que puedo terminar mi aplicación!

Título: Re: El Fichero .HEX explicado
Publicado por: aitopes en 24 de Octubre de 2009, 17:16:31

Cita de: RedPic en 07 de Octubre de 2008, 17:31:38

Bueno, y eso es todo por hoy. Espero que os aproveche.  :mrgreen:

Me ha venido DE MARAVILLAS. Puedo leer los malditos HEX, y hasta me he hecho un primitivo "descompilador" que genera de nuevo el código ASM original (o casi, los nombres de las etiquetas y demas son irrecuperables).

Pero....me ha surgido un problemita....  :(

La linea que esta marcada en la siguiente imagen tiene como dir de memoria.....16398 en decimal...Como puede ser?

(http://www.ucontrol.com.ar/forosmf/programacion-en-asm/formato-de-los-archivos-hex/?action=dlattach;attach=2368)

Yo razono de la siguiente manera, tal como explicaste en el primer post: en cada linea, los ":" indican que son datos. Los dos digitos siguientes la cantida de datos (02 en este caso). Los 4 siguientes la dir de memoria (400E en este caso, 16398 en decimal), "00" es que es una linea de datos de memoria, el "703F" son los dos bytes que efectivamente hay que "meter" en la memoria del PIC, y finalmente, dos digitos mas son el checksum ("01" en este caso).

Obviemente, cuando el programa intenta cargar esa linea, se va al demonio.   :oops:

¿Que puede estar pasando?

Título: Re: El Fichero .HEX explicado
Publicado por: RedPic en 24 de Octubre de 2009, 18:36:02

Querido Ariel.

Tampoco lo comprendo exactamente ... pero es altamente sospechoso que esa dirección es el doble de la dirección donde el 16F628A tiene los fuses (bits de configuración) que según su Datasheet (http://ww1.microchip.com/downloads/en/DeviceDoc/40044F.pdf) (Revisión F, pagina 97) dice que estos se almacenan en 0x2007 y como 0x2007 * 2 = 0x400E ... pues imagino que tiene algo que ver con ellos.

14.1 Configuration Bits
The configuration bits can be programmed (read as ‘0’) or left unprogrammed (read as ‘1’) to select various device configurations. These bits are mapped in program memory location 2007h.
 
The user will note that address 2007h is beyond the user program memory space. In fact, it belongs to the special configuration memory space (2000h-3FFFh), which can be accessed only during programming. See “PIC16F627A/628A/648A EEPROM Memory Programming Specification” (DS41196) for additional information.

Título: Re: El Fichero .HEX explicado
Publicado por: aitopes en 24 de Octubre de 2009, 19:24:04

Cita de: RedPic en 24 de Octubre de 2009, 18:36:02

Querido Ariel.

Tampoco lo comprendo exactamente ... pero es altamente sospechoso que esa dirección es el doble de la dirección donde el 16F628A tiene los fuses (bits de configuración)

Tan sospechoso es, que justamente se trata de eso. :)

GRACIAS!!!!!!!!!

Título: Re: El Fichero .HEX explicado
Publicado por: RedPic en 25 de Octubre de 2009, 05:16:50

Si descubres por qué la dirección es el doble en lugar de la que debería ser no dejes de pasarte por aquí y dejarnos la explicación.  :mrgreen:

Título: Re: El Fichero .HEX explicado
Publicado por: MGLSOFT en 25 de Octubre de 2009, 12:33:15

A ver si pueden ayudarme un poco.
Intentando aprender sobre CanOpen, se me ocurrio ver que pasaba si leia el software de un dispositivo simple que usa ese protocolo.
Lo conecte a mi GTP-USB+ y este lo leyo "completo", e aqui mi duda:

Esto que pego aqui es la parte inicial del codigo que baje, y segun mi entendimiento faltan al menos dos lineas completas del codigo leido por Winpic800, no entiendo porque!!

Código: [Seleccionar]

:1000000027D01ED01200FFFF04EF01F01200FFFF07
:100018000CEF01F01200FFFFFFFFFFFFFFFFFFFFE4
:100040000400550EA76EAA0EA76EA682000012002D
:100050000F0EC16E80B200EF01F093988198949CCE
:10006000948E900EAB6E670E260EAC6E080EB86EB8
:10007000FF0EAF6E010EB06EAE50AAD80F0AFDE1B2
:10008000A7D80F0AFAE100EE08F0006A016AA0D8CA
:100090000F0AF6E00450040A0AE00450050A01E1E0
:1000A00097D804500026EE6E014EE7D7F0D70052E5
:1000B000E4E10A50F66EA96E0B50F76EAA6E0CC002
:1000C000F8FF00EE0DF00950016ED8B4FF000850A3
:1000D0000708D3E3FA6AFB6A0844F92607D00CD074
:1000E00013D022D02CD036D007D040D0000E0A6ECC
:1000F000010E0B6E040E45D00900F5CFEEFF012E68
:10010000FBD70950050F3DD0F80EF616080EEECFBE
:10011000F5FF0D00E82EFBD70A00840EA66E90DFD7
:100120000900012EF1D72CD0940EA66E89DF400E67
:10013000F626E86AF722F822012EF6D721D0A66A21
:10014000A680A8CFEEFFA94AAA2A012EF8D7095007
:10015000050F17D0EECFA8FF040EA66E71DFA6B272
:10016000FED7A94AAA2A012EF5D70AD0C40EA66E38
:10017000EECFF5FF0C0064DF0900012EF7D700D0A9
:10018000010E016E81880F0E1ED81DD8006A00EE88
:1001900008F0EE5000260BD8012EFBD7006C005063
:1001A00006D8040E10D8ACA2FED7819866D7056E8B
:1001B0000F0A06E00550040A03E00550050A02E1B3
Entiendo mal o faltan las lineas 0002 y la 0003???

Desde ya gracias por su ayuda.

Título: Re: El Fichero .HEX explicado
Publicado por: aitopes en 25 de Octubre de 2009, 16:56:51

No entiendo NADA de ASM, pero en algunos HEX que que abierto, hay "huecos".

Por ejemplo, en el que postee antes, hay 4 o 5bytes en blanco. La razon? Hay una rutina de interrupcion o algo asi al principio del programa, que empieza con un "GOTO xxx" para saltearla. El "salto" es mas largo de lo necesario (seguramente previendo que esa rutina sea alguna vez mas larga), entonces quedan espacios en blanco.

No estoy seguro, pero en este trozo de código, si mal no recuerdo

;**** Inicio del Micro ****
   org      0x00   
   goto   Inicio   

   org      0x04
   nop
   retfie

Inicio
   clrw
   clrf   PORTA
   clrf   PORTB
   bsf      STATUS,RP0
        clrf   TRISA
   clrf   TRISB
   bcf      STATUS,RP0
...
...
...


pasaba algo asi. El hex correspondiente


:020000040000FA
:020000000628D0
:0800080000000900030185015D
:1000100086018316850186018312AA30A000A107FC
:10002000A0052109A003A10AA004A102A00EA10617
:10003000A00DA10C05181A282120851D1A2828209A
:100040001A28061406160000061006120000080002
:02005000CC34AE
:02400E00703F01
:00000001FF


No tiene informacion para los Bytes 1 al cuatro inclusive:

(http://www.ucontrol.com.ar/forosmf/programacion-en-visual-basic/simupic-un-simulador-de-pics-para-linux/?action=dlattach;attach=2374)

¿Podrá ser eso?  :shock:

Título: Re: El Fichero .HEX explicado
Publicado por: gary_servin en 08 de Noviembre de 2009, 23:52:19

Excelente Post!! Era justamente lo que estaba necesitando estos dias!! Muchisimas Gracias por la info!!!   :)

Título: Re: El Fichero .HEX explicado
Publicado por: jeremylf en 08 de Marzo de 2011, 04:57:19

Gran aparto RedPic, muchas gracias!

Título: Re: El Fichero .HEX explicado
Publicado por: jeremylf en 12 de Marzo de 2011, 00:30:23

Una pregunta, si el checksum sale erroneo quiere decir que habra que enviar nuevamente la trama o linea para corregir eso?

Título: Re: El Fichero .HEX explicado
Publicado por: BrunoF en 12 de Marzo de 2011, 01:21:08

Claro que si. Este formato encapsula cada linea por separado, de manera que reenviando solo esa linea deberia ser suficiente para eliminar errores.

Saludos.

Título: Re: El Fichero .HEX explicado
Publicado por: luisnaranjo en 27 de Agosto de 2014, 19:36:09

Hola!
Estoy en un proyecto desarrollando un bootloader para el PIC18F2620. Pero al momento de analizar el archivo .HEX me entro una duda con las lineas donde su Record Type es 04.
Hasta donde tengo entendido este PIC tiene un direccionamiento de 16 bits, pero en mi archivo .HEX si tiene una linea con Record Type de 04, mi pregunta es, si el direccionamiento de este PIC es de 16 bits, ¿cual es la función de direccionar datos a 32 bits? ¿o solamente parsea la dirección y toma los 16 bits menos significativos?
Saludos.