¿El compilador MPLAB XC16 genera archivos HEX de 8 bits para PIC24?

Estoy tratando de entender un archivo HEX que compilé con Microchip MPLAB X IDE utilizando el compilador Microchip MPLAB XC16 .

Con respecto a la MCU, estoy apuntando a PIC24EP512GU814. Sin embargo, el alcance de esta pregunta debe aplicarse al menos a todas las MCU PIC24.

Para compilar el HEX de ejemplo a continuación, durante el asistente "Nuevo proyecto", seleccioné Muestras > Microchip integrado > Plantilla PIC24 C y elegí la configuración XC16_24EP512GU814 .

Según la hoja de datos PIC24EP / dsPIC33 sección 4.1.1 página 48, la memoria está segmentada en palabras de 16 bits, de modo que cada posición (0x0000, 0x0001, ...) contiene 16 bits. En la misma página de la hoja de datos, se dice que las instrucciones del programa son de 24 bits y abarcan 2 palabras, de modo que el byte más significativo de la palabra más significativa es cero (00000000b).

Esto no parece ser coherente con el archivo HEX compilado. Aquí están las primeras 5 líneas del archivo, numeradas y con las diferentes partes espaciadas según las especificaciones Intel HEX .

1. :02 0000 04 0000                             fa
2. :08 0000 00 0002040000000000                 f2
3. :02 0000 04 0000                             fa
4. :10 0008 00 c8020000ce020000e4020000d4020000 92
5. :10 0018 00 da020000e8020000ec020000e0020000 42

Considere las líneas 4 y 5. El primer campo cuenta correctamente 0x10 (16) bytes en el campo de datos. Sin embargo, el segundo campo que indica la ubicación en la memoria salta de 0x0008 a 0x0018 o 0x0010 (16) posiciones.

Según mi interpretación, esto significa que este archivo HEX en particular es de 8 bits en lugar de 16 bits porque cada posición está ocupada por un byte.

  • ¿Hay alguna manera de hacer que el compilador genere un archivo de 16 bits?
  • ¿Este archivo sigue siendo válido para una MCU de 16 bits? ¿Cómo puedo interpretar el archivo HEX para poder flashear manualmente la MCU?

Respuestas (3)

Los archivos HEX de Intel siempre tienen direcciones de bytes. Esto no significa que no puedan manejar información para otros tamaños de palabras, solo que debe haber una convención sobre cómo se asignan esas palabras a los bytes del archivo HEX.

Al igual que con todos los demás PIC direccionados sin bytes (PIC 10, 12 y 16), las direcciones se duplican en el archivo HEX. El software del programador PIC lo sabe e interpreta las direcciones del archivo HEX en consecuencia. Por supuesto, todo esto está bien documentado en la especificación de programación para cualquier parte que desee programar.

Dices que quieres hacer tu propio programador. Eso está bien, siempre y cuando comprenda que esto llevará mucho más tiempo y frustración que simplemente obtener uno que sepa que funciona. Si el punto es la experiencia y el aprendizaje de hacer uno propio, entonces está bien, pero de lo contrario ve a comprar uno.

Si realmente quieres hacer el tuyo propio, deberías mirar el código para mis programadores PIC. Todo el código host y el firmware están abiertos y disponibles en la versión del software de desarrollo en http://www.embedinc.com/picprg/sw.htm . Al mirar el código fuente del host, puede ver cómo hay indicadores que indican si las direcciones de archivo HEX se duplican para varias partes de la memoria del PIC.

Si hace que su programador sea compatible con mi protocolo de programadores PIC , entonces puede hacer uso de todas mis herramientas del lado del host. Esto podría ser muy útil al iniciar su sistema, ya que conoce el código de trabajo en el otro lado. La especificación del protocolo puede parecer intimidante al principio, pero mire con cuidado y verá que gran parte es opcional, especialmente si planea admitir solo un PIC.

Estuve cerca de comprar el Pickit. Sin embargo, no quiero estar atado a un solo fabricante. Tengo otros proyectos en fila que pueden o no usar chips Atmel. En lugar de comprar un nuevo programador para cada fabricante, también podría aprender a hacerlo yo mismo. También lo considero una experiencia enriquecedora.

Los archivos Intel HEX siempre especifican bytes y las direcciones en el archivo se miden en bytes. Es solo un formato conveniente que se usa para transferir datos binarios entre su enlazador y su software de programación. Depende del software de programación que esté utilizando interpretar los datos y sus direcciones y mostrarlos correctamente en el PIC.

Entiendo que se supone que el software de programación debe interpretar el archivo HEX, sin embargo, mi proyecto actual es hacer mi propio software de programación. Estoy usando un Arduino para interactuar con la MCU. Hasta ahora tengo codificado el firmware de Arduino y el shell de la GUI. Todo lo que me falta ahora es interpretar el archivo HEX para poder enviar la información correcta al Arduino. Conozco otros proyectos de programadores Arduino->PIC, sin embargo, ninguno de estos es compatible con PIC24.

Aunque Olin Lathrop respondió la pregunta, estoy complementando su respuesta con un ejemplo de cómo se aplicaría a la plantilla que pegué en mi publicación original.

Después de investigar más a fondo el IDE, encontré el visor de memoria accediendo a Window > PIC Memory Views > Program Memory .

ingrese la descripción de la imagen aquí

Comparando la tabla presentada en esta ventana con el archivo HEX, podemos notar cómo están estructuradas las instrucciones. Para el siguiente ejemplo, divido cada campo de dirección por dos y espacio las instrucciones:

1. :02 0000 04 0000                                fa
2. :08 0000 00 00020400 00000000                   f2
3. :02 0000 04 0000                                fa
4. :10 0004 00 c8020000 ce020000 e4020000 d4020000 92
5. :10 000C 00 da020000 e8020000 ec020000 e0020000 42

Dado que los datos están en formato big endian, los bytes aparecen en orden inverso a un literal hexadecimal. Por lo tanto, cambiar los datos a literales hexadecimales produce lo siguiente:

1. :02 0000 04 0000                                        fa
2. :08 0000 00 0x00040200 0x00000000                       f2
3. :02 0000 04 0000                                        fa
4. :10 0004 00 0x000002c8 0x000002ce 0x000002e4 0x000002d4 92
5. :10 000C 00 0x000002da 0x000002e8 0x000002ec 0x000002e0 42
El único cambio que haría en las líneas hexadecimales convertidas es cambiar la dirección a direcciones pic24 de 24 bits.
1. :02 0000 04 0000                                                                                                                                                         fa 2. :08 0000 00 0x00040200 0x00000000                                                                                       f2 3. :02 0000 04 0000                                                                                                                                                         fa 4. :10 0002 00 0x000002c8 0x000002ce 0x000002e4 0x000002d4 92 5. :10 0006 00 0x000002da 0x000002e8 0x000002ec 0x000002e0 42
¿El compilador MPLAB XC16 genera archivos HEX de 8 bits para PIC24?
RespuestasAquíPolítica de privacidad1y, 1v