migración de c18 a xc8

Rev: 1.0

Omar Gurrola

http://www.proprojects.wordpress.com

7/6/2014

Migración de C18 a XC8

Omar Gurrola Migración de C18 a XC8 http://www.proprojects.wordpress.com

Revisión: 1.0 [07/2014]

Contenido

Objetivo de Este Documento ..............................................................................................................1

¿Por Qué Decidí Cambiar de C18 a XC8? .............................................................................................1

Introducción ......................................................................................................................................1

1. Modo de Operación (Extendido o No-Extendido) .........................................................................1

2. Modelos de Memoria .................................................................................................................1

3. Promoción de Enteros .................................................................................................................2

4. Cabeceras ...................................................................................................................................2

5. Rutinas y Macros del Compilador ................................................................................................3

6. Tipos de Datos y Límites .............................................................................................................3

7. Limitaciones de Tamaño .............................................................................................................3

8. Indicadores de Almacenamiento .................................................................................................3

9. Indicadores de Punteros .............................................................................................................4

10. Variaciones de Funciones ............................................................................................................4

11. Estructuras y Uniones .................................................................................................................4

12. Interrupciones ............................................................................................................................4

13. Ubicación de Objetos ..................................................................................................................5

14. Macros Predefinidas ...................................................................................................................6

15. Ensamblador en Línea .................................................................................................................7

16. Ligado (Link) ...............................................................................................................................7

17. Referencias ................................................................................................................................8


Revisión: 1.0 [07/2014] 1

Objetivo de Este Documento

Este documento tiene el objetivo de ofrecer una referencia rápida sobre los cambios que se deben realizar o

considerar en el código fuente al migrar un proyecto realizado en C18 a XC8. Toda esta información está basada en

la guía de migración de microchip (Ver referencias).

¿Por Qué Decidí Cambiar de C18 a XC8?

1. XC8 es el sucesor de C18, por lo tanto tarde o temprano dejaran de darle soporte a C18.

2. XC8 se puede utilizar para todas las familias de 8-bits (PIC10, PIC12, PIC16 y PIC18), mientras C18 solo

funciona para la familia PIC18.

3. XC8 compila C lo que permite utilizar este lenguaje para microcontroladores pequeños (PIC10, PIC12 y

PIC16), antes se tenía que desarrollar el programa en ensamblador o buscar otro compilador C que

soporte el microcontrolador que esté utilizando.

4. XC8 permite declarar variables locales justo antes de utilizarlas, mientras en C18 tenías que declararlas

siempre al inicio del bloque donde se utilizaran.

5. XC8 cumple más especificaciones del estándar ANSI C lo que permite que el código sea más portable.

6. XC8 no añade código de funciones que no se utilicen en el programa, cosa que C18 no hacía.

7. XC8 está basado en el compilador de HI-TECH el cual era muy bueno.

8. XC8 utiliza “xc8.exe” para compilar, ligar y crear librerías, mientras C18 utiliza una aplicación para cada

tarea (mcc18.exe, mplink.exe y mplib.exe).

Introducción

En las siguientes secciones se describe los cambios que se deben considerar cuando se quiere migrar código fuente

de C18 a XC8. La mayoría de los cambios que se deben realizar son a código que no pertenece al estándar ANSI C.

Si estas familiarizado con C18 hay ejemplos de cambios equivalentes que se pueden utilizar con XC8.

1. Modo de Operación (Extendido o No-Extendido)

XC8 no soporta compilar en modo extendido (solo la familia PIC18 cuenta con esta característica).

Solo aplica a la familia PIC18.

El bit de configuración “extended instruction set” debe estar deshabilitado.

Código ensamblador utilizado entre el código C debe utilizar instrucción de modo no-extendido

únicamente.

2. Modelos de Memoria

XC8 no utiliza modelos de memoria ya que el tamaño del puntero de cada variable es designada de modo

independiente y automáticamente, por lo tanto los modelos son ignorados.


Revisión: 1.0 [07/2014] 2

3. Promoción de Enteros

Al realizar operaciones aritméticas C18 utiliza el tamaño del operando más grande mientras XC8 promueve

cualquier operando de tamaño menor a int (short, char y estructuras con campos de 1 bit) a signed int o unsigned

int, lo que puede hacer que el resultado no sea el esperado en la mayoría de los casos.

Ejemplo 1:

unsigned char count, a=0, b=50; if(a – b < 10) count++;

C18: El resultado de a-b = 206 el cual no es menor a 10, por lo tanto no se ejecutara el interior del if.

XC8: Como ambos operadores son convertidos a signed int el resultado de a-b = -50 el cual es menor a 10, por lo

tanto se ejecutara el interior del if.

Si se busca que el resultado de la resta sea unsigned int (para obtener el mismo resultado que C18) entonces se

puede aplicar un cast al resultado de la resta.

Ejemplo 1 con cast:

unsigned char count, a=0, b=50; if((unsigned int)(a – b) < 10) count++;

Otro problema que surge es cuando se utilizan operadores de bits como “~”.

Ejemplo 2:

unsigned char count, c; c = 0x55; if(~c == 0xAA) count++;

C18: Se asume que ~c = 0xAA, por lo tanto el if se ejecutaría.

XC8: Como la variable c es cambiada a int el resultado de ~c = 0xFFAA, por lo tanto no es igual a 0xAA y el if no se

ejecutaría.

Lo anterior se puede resolver realizando un cast igual que el ejemplo anterior.

Ejemplo 2 con cast:

unsigned char count, c; c = 0x55; if((unsigned char)(~c) == 0xAA) count++;

NOTA: Se debe analizar cada caso para determinar si el comportamiento es el esperado o si requiere casting.

4. Cabeceras

XC8 utiliza la cabecera <xc.h> para todos los dispositivos, por lo tanto hay que borrar todas las cabeceras que

hagan referencia a un microcontrolador específico como <p18cxxx.h>.


Revisión: 1.0 [07/2014] 3

5. Rutinas y Macros del Compilador

La siguiente tabla muestra la equivalencia de las rutinas y macros integradas en el compilador:

C18: XC8:

Nop() NOP() ClrWdt() CLRWDT() Sleep() SLEEP() Reset() RESET()

Rlcf(), Rlncf(), Rrcf(), Rrncf() Utilizar << y >> Swap() (c >> 4) | (c << 4)

NOTA: XC8 también puede utilizar _delay(), _delaywdt(), __delay_us(), __EEPROM_DATA(), etc.

6. Tipos de Datos y Límites

char: Se debe especificar si es con signo o sin signo ya que C18 por defecto lo maneja con signo, pero XC8

sin signo.

float y double: Para C18 son de 32 bits por defecto, pero para XC8 son de 24 bits y pueden ser

configurados independientemente uno de otro a 32 bits si se requiere (--FLOAT y/o --DOUBLE para

cambiarlos de 24 bits a 32 bits).

NOTA: XC8 permite utilizar un tipo de dato nuevo llamado “bit” (no es estándar) que puede manejar un bit (utiliza

un int de espacio).

7. Limitaciones de Tamaño

El tamaño de un objeto auto (arreglo o estructura) no puede exceder de 100h bytes, que es lo mismo que un

banco de PIC18.

8. Indicadores de Almacenamiento

En C18 se puede definir en qué memoria se desea almacenar un objeto de forma independiente con los

indicadores ram y rom (Indicadores no estándar para ANSI C). En XC8 estos indicadores no existen.

En C18 se puede utilizar el indicador const de forma independiente o en conjunto a ram o rom. Pero XC8 utiliza

const para indicar que un objeto global será de solo lectura (read-only) y que será alojado en la memoria de

programa, que sería lo equivalente a const rom en C18.

Borra todos los indicadores ram, near y far.

Reemplaza todos los indicadores rom y const rom por const para que la variable sea de solo lectura y se

almacene en la memoria de programa.


Revisión: 1.0 [07/2014] 4

9. Indicadores de Punteros

XC8 ignora los indicadores near y far ya que el compilador determina el tamaño del puntero de manera

automática basándose en el uso del puntero y estos pueden ser de 8/16/24 bits.

En XC8 se puede utilizar const y volatile para definir si el puntero es de solo lectura o si no debe optimizarse, el

resto de indicadores no estándar no deben utilizarse y por lo tanto son ignorados.

Borra todos los indicadores de near y far en los punteros.

10. Variaciones de Funciones

En C18 es necesario realizar variaciones de funciones para diferentes tipos de punteros (a ram o rom). Mientras

que en XC8 solo se requiere una función (basado en el estándar ANSI C), sin importar si los datos están en memoria

de programa o en memoria de datos.

Cambia las variaciones de la función por la función principal.

Ejemplo C18:

char *strcpy (auto char *s1, auto const char *s2); char *strcpypgm2ram (auto char *s1, auto const rom char *s2); rom char *strcpyram2pgm (auto rom char *s1, auto const char *s2); rom char *strcpypgm2pgm (auto rom char *s1, auto const rom char *s2);

Cambio con XC8:

char *strcpy (char *s1, const char *s2);

11. Estructuras y Uniones

Estructuras y uniones anónimas siguen siendo soportadas por XC8, pero no es parte del estándar ANSI C por lo que

se recomiendo no utilizarlas.

Cambia campos de 1 bit con signo (signed) a sin signo (unsigned) ya que XC8 no los soporta.

12. Interrupciones

Definir interrupciones en XC8 ahora es más fácil, solo se necesita definir una función para cada interrupción. Se

debe utilizar el indicador interrupt para interrupción de alta prioridad y interrupt low_priority para el de baja

prioridad, el resto de código necesario para mapear las interrupciones es completado por el compilador.

En XC8 no existe restricción sobre la cantidad de código que puede ir dentro del cuerpo de las interrupciones.

Declaración de Interrupciones en C18:

#pragma code high_vector=0x08 void interrupt_at_high_vector(void) { _asm GOTO high_isr _endasm } #pragma code low_vector=0x18 void interrupt_at_low_vector(void) { _asm GOTO low_isr _endasm }


Revisión: 1.0 [07/2014] 5

#pragma code /* return to the default code section */ #pragma interrupthigh high_isr void high_isr (void) { /* service routine body goes here */ } #pragma interruptlow low_isr void low_isr (void) { /* service routine body goes here */ }

Declaración de Interrupciones en XC8:

void interrupt low_priority low_isr (void) { /* service routine body goes here */ } void interrupt high_isr (void) { /* service routine body goes here */ }

13. Ubicación de Objetos

XC8 no maneja la ubicación de objetos de la misma manera que C18, considere los siguientes ejemplos:

Si se desea asignar una variable o una función a una dirección específica (variable/función absoluta) utilice

asignación absoluta. Las variables absolutas en memoria de datos (data memory o RAM) no se pueden inicializar al

declararlas:

Asignación Absoluta en XC8:

int voltage_var @ 0x100; // Se asignara esta variable a la dirección 100h en la memoria de datos. const int array[] @ 0x200 = {1,2,3,4,5}; // Se asignara esta constante a la dirección 200h en la memoria de programa. int calc_temp(params…) @ 0x1500 {…} // Se asignara esta función a la dirección 1500h en la memoria de programa.

Si se requiere que la variable está definida dentro de un banco específico se utiliza bankX pero antes se debe

cambiar el la opción --ADDRQUAL a request, de lo contrario se ignorada la especificación del banco. XC8 solo

permite asignar variables en los primeros cuatro bancos únicamente.

Asignación a Banco en XC8:

bank1 int speed; // Se asignara esta variable al banco 1 en la memoria de datos.

Si se necesita que la variable se asigne a una sección específica se debe utilizar __section(“MySection”). La

dirección y nombre de la sección no se puede definir en código, este debe especificarse con la opción:

-L-pMySection=0100h.

También puede definirse primero una “clase de liga” (linker class) y utilizar ese nombre para definir un rango o

varias áreas de memoria:

-L-AMYSPACE=50h-0ffh,100h-1ffh -L-pMySection= MYSPACE


Revisión: 1.0 [07/2014] 6

Asignación a una Sección en XC8:

-L-pMyData=0100h -L-AMYCODE=1000h-1500h -L-pMyCode=MYCODE

int __section(“MyData”) power_var; // Se asignara esta variable a la sección MyData en la memoria de datos. int __section(“MyCode”) read_temp(params…){…} // Se asignara esta función a la sección MyCode en la memoria de programa.

Reemplaza todas las variables definidas con sectiontype pragma con variables absolutas, asignación a

bancos o en una sección definida utilizando __section().

Reemplaza todas las funciones definidas con sectiontype pragma con funciones absolutas o asígnelas a

una sección definida utilizando __section().

Si se utilizan áreas definidas añadir las opciones requeridas al compilador.

Confirme que los datos son colocados en las áreas deseadas.

Borrar todas las estancias de la directiva #pragma tmpdata.

14. Macros Predefinidas

Las macros predefinidas para C18 se muestran en la siguiente tabla y su equivalente en XC8:

C18: XC8: Descripción:

__18CXX __XC, __XC8 Define el compilador utilizado __PROCESSOR __PROCESSOR Dispositivo en específico: __18F4550

__SMALL__ N/A - __LARGE__ N/A -

__TRADITIONAL18__ __TRADITIONAL18__ Se utiliza el modo no extendido __EXTENDED18__ N/A -

XC8 no soporta macros con lista de argumentos variable, por lo tanto se deben cambiar a funciones o implementar

una macro para cada combinación necesaria.


Revisión: 1.0 [07/2014] 7

15. Ensamblador en Línea

XC8 ofrece dos maneras adicionales para introducir código ensamblador dentro de C:

1. La primera forma es utilizar al función asm(“instruction”) para cada instrucción.

2. La segunda forma es utilizar #asm para iniciar y #endasm para terminar.

16. Ligado (Link)

XC8 no utiliza ningún archivo de ligado de memoria (linker file), si se requiere crear una sección o definir la

ubicación de alguna variable, se debe implementar basándose en la sección de “Ubicación de Objetos”.


Revisión: 1.0 [07/2014] 8

17. Referencias

Microchip, “MPLAB C18 to XC8 C Compiler Migration Guide”, 2013

http://ww1.microchip.com/downloads/en/DeviceDoc/50002184A.pdf

Microchip, “MPLAB XC8 C Compiler User’s Guide”, 2013

http://ww1.microchip.com/downloads/en/DeviceDoc/MPLAB_XC8_C_Compiler_User_Guide.pdf

http://ww1.microchip.com/downloads/en/DeviceDoc/50002184A.pdf

http://ww1.microchip.com/downloads/en/DeviceDoc/MPLAB_XC8_C_Compiler_User_Guide.pdf

http://www.proprojects.wordpress.com

migración de c18 a xc8

Documents