El Compilador IAR C para los AVR
IAR AVR C y AVR GCC son de lejos los mejores compiladores para los AVR. Entre ellos hay ligeras diferencias. Hay algunos aspectos en que un compilador saca cierta ventaja y otros aspectos en que el otro trabaja mejor. Si nos pusiéramos a compararlos punto a punto, estoy casi seguro de que el veredicto final sería… un empate.
En cursomicros.com se da preferencia a AVR GCC (WinAVR) pero todos los programas están codificados para ser compilados también por IAR C. Esto se consigue gracias al archivo proporcionado por ATmel avr_compiler.h, al cual le añadí pequeñas cosas. No todas las prácticas están compiladas en IAR C pero los programas que tomé al azar compilaron perfectamente a la primera y sin errores. Bueno, a decir verdad tuve un traspié en un programa que utilizaba la función itoa, ya que dicha función no es parte del ANSI C y como estricto seguidor de este estándar, IAR C no la tiene implementada. Fuera de esa anécdota no tuve ningún inconveniente.
El entorno de desarrollo de IAR C se ve bastante sencillo para la potencia que ostenta el compilador. Se llama IAR Embedded Workbench y también sirve de plataforma para los otros compiladores de la empresa IAR Systems. Si bien es cierto que AVR GCC se integra al Studio 5 para aprovechar sus utilidades para las herramientas hardware de ATmel, el entorno de IAR cuenta con sus propias armas de programación, simulación y depuración, incluyendo los drivers para AVR ICE200, AVR JTAG ICE, AVR JTAGICE mkII, AVR Dragon y AVR AVR ONE! Puedes ver una breve descripción de estas herramientas en la presentación del Studio 5.
Creando un Proyecto en IAR AVR
El desarrollo de programas en el IDE de IAR C es muy similar a hacerlo en el Studio 5. Los programas deben integrar un proyecto, el proyecto debe pertenecer a un espacio de trabajo, y un espacio de trabajo puede agrupar varios proyectos. Un espacio de trabajo o Workspace se podría equiparar con las Soluciones del Studio 5.
Así que empezamos por crear nuestro Workspace o espacio de trabajo yendo al menú File > New > Workspace. Sin importar su contenido actual, el IDE de IAR C se limpiará y quedará como se muestra abajo.
Seguidamente pasamos a crear el proyecto seleccionando el menú Project > Create New Project… Para los “pequeños” programas no hay mucha diferencia entre las diversas opciones de proyectos en C (Empty Project, C++ o C). Sin embargo tomaremos Empty Project. Si tienes varios compiladores instalados, debes seleccionar AVR en el deplegable Tool Chain. Con la configuración como se muestra abajo presionamos OK.
Luego tendremos que buscar una carpeta donde guardar el archivo del proyecto creado y escribir su nombre. Como ves, yo le llamé ledflasher3.
Recién ahora podemos guardar el espacio de trabajo que creamos al inicio. Así que vamos al menú File > Save Workspace. El archivo de Workspace también puede tener cualquier nombre, pero yo le llamé otra vez ledflasher3. Si el espacio de trabajo va a contener varios proyectos será preferible que este archivo se ubique en un directorio superior. Como en este caso el espacio de trabajo tendrá un único proyecto, lo guardaré en la misma carpeta del proyecto.
Luego podemos ver que el panel Workspace apenas si contiene el nombre del proyecto. Aún no vemos dónde escribir el código del programa, pero eso viene después.
Asumiendo que estamos creando un proyecto desde cero, pasamos a crear un archivo en blanco que será donde se edite el código del programa. Para esto vamos al menú File > New > File o hacemos clic en ese típico botón blanco.
El nuevo archivo aparece por ahora como Untitled1. Así que pasamos a guardarlo con ese botón de disket. Cuando los proyectos tienen más de un archivo de código fuente al archivo principal se le suele llamar main.c. La siguiente imagen parece indicar que éste es uno de esos proyectos.
Ahora por fin ya podemos editar el código del programa. En esta ocasión vamos a reproducir el programa de la práctica ledflasher3. Por eso estaba insistiendo con ese nombre ;) El código completo se muestra a continuación.
/****************************************************************************** * FileName: main.c * Purpose: LED Flasher 3. Secuenciador de 3 efectos seleccionables vía USART * Processor: ATmega164P * Compiler: IAR-C y AVR-GCC (WinAVR) * Author: Shawn Johnson. http://www.cursomicros.com. * Basado en el led flasher 2 de Seiichi Inoue localizado en * http://hobby_elec.piclist.com/index.htm. * * Copyright (C) 2008 - 2012 Shawn Johnson. All rights reserved. * * License: Se permiten el uso y la redistribución de este código con * modificaciones o sin ellas, siempre que se mantengan esta * licencia y la nota de autor de arriba. *****************************************************************************/ #include "avr_compiler.h" #include "usart.h" /****************************************************************************** Patrón que contiene el patrón de efecto del secuencial led1 111111111111111111111111111111... Prendido 6 de 6 partes led2 100100100100100100100100100100... Prendido 2 de 6 partes led3 100000100000100000100000100000... Prendido 1 de 6 partes - Cada bloque tiene 6 items - Cada bloque se repite 100 veces - Hay una pausa de 150 µs entre los ítems - Hay 12/11 bloques en total -> Cada barrido dura 6 * 100 * 150 * 12 = 1.08 segundos aprox. ******************************************************************************/ PROGMEM char Pattern[] = { // Efecto 1. 12 bloques de 6 items 0x81,0x81,0x81,0x81,0x81,0x81, 0xc3,0x42,0x42,0xc3,0x42,0x42, 0xe7,0x24,0x24,0x66,0x24,0x24, 0x7e,0x18,0x18,0x3c,0x18,0x18, 0x3c,0x18,0x18,0x18,0x18,0x18, 0x18,0x18,0x18,0x18,0x18,0x18, 0x3c,0x24,0x24,0x3c,0x24,0x24, 0x7e,0x42,0x42,0x66,0x42,0x42, 0xe7,0x81,0x81,0xc3,0x81,0x81, 0xc3,0x00,0x00,0x81,0x00,0x00, 0x81,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00, // Efecto 2. 11 bloques de 6 items 0x80,0x80,0x80,0x80,0x80,0x80, 0xc0,0x40,0x40,0xc0,0x40,0x40, 0xe0,0x20,0x20,0x60,0x20,0x20, 0x70,0x10,0x10,0x30,0x10,0x10, 0x38,0x08,0x08,0x18,0x08,0x08, 0x1c,0x04,0x04,0x0c,0x04,0x04, 0x0e,0x02,0x02,0x06,0x02,0x02, 0x07,0x01,0x01,0x03,0x01,0x01, 0x03,0x00,0x00,0x01,0x00,0x00, 0x01,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00, // Efecto 3. 11 bloques de 6 items 0x01,0x01,0x01,0x01,0x01,0x01, 0x03,0x02,0x02,0x03,0x02,0x02, 0x07,0x04,0x04,0x06,0x04,0x04, 0x0e,0x08,0x08,0x0c,0x08,0x08, 0x1c,0x10,0x10,0x18,0x10,0x10, 0x38,0x20,0x20,0x30,0x20,0x20, 0x70,0x40,0x40,0x30,0x40,0x40, 0xe0,0x80,0x80,0xc0,0x80,0x80, 0xc0,0x00,0x00,0x80,0x00,0x00, 0x80,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00 }; /***************************************************************************** * Main function ****************************************************************************/ int main(void) { unsigned int i, j, k, b, bi, ba; char c, Effect; DDRB = 0xFF; // Setup PORTB for output usart_init(); // Initialize USART @ 9600 N 1 puts("\n\r Escoja un efecto "); puts("\n\r (1) Barrido simétrico"); puts("\n\r (2) Barrido a la derecha"); puts("\n\r (3) Barrido a la izquierda"); Effect = '1'; // Por defecto iniciar con efecto 1 while(1) { start: /* Establecer parámetros de barrido del efecto actual */ switch(Effect) { case '1': ba = 0; b=12; break; case '2': ba = 6*12; b=11; break; case '3': ba = 6*(12+11); b=11; break; } /* Iniciar barrido del efecto actual */ for(i=0; i<b; i++) // Para barrer b bloques { for(j=0; j<100; j++) // Cada bloque se repite 100 veces { bi = ba + 6*i; for(k=0; k<6; k++) // Cada bloque tiene 6 items { // PORTB = Pattern[bi+k]; PORTB = pgm_read_byte(&(Pattern[bi+k])); /* Este bloque sondea el puerto serie esperando recibir una * opción válida para cambiar de efecto */ if(kbhit()) // Si hay datos en el USART,.. { c = getchar(); // Leer dato if((c<='3') && (c>='1')) // Si es una opción válida,... { Effect = c; // Tomar opción goto start; // y reiniciar } } delay_us(150); } } } } }
Puedes copiar todo el listado y pegarlo en el editor de IAR C. Deberá quedar algo así.
Observa que el panel Workspace aún no despliega el nombre de main.c. Ese archivo todavía está flotando en el aire. Para que forme parte del proyecto tenemos que incluirlo siguiendo el procedimiento que indica la siguiente captura.
Configurando el Proyecto
El entorno IAR Embedded Workbench está diseñado para trabajar con los múltiples compiladores de IAR Systems así que la configuración predeterminada del proyecto puede variar entre una y otra Toolsuit. A continuación veremos los cambios básicos que normalmente deberemos realizar a través de la ventana Opciones disponible en el menú Project o en el menú emergente del archivo del proyecto como se aprecia abajo.
Aquí el primer paso es cambiar el microcontrolador.
Pasamos a las opciones de C/C++ Compiler y fijamos un nivel de optimización que puede referirse al código más pequeño que deseamos obtener (size) o al más veloz en ejecución (speed).
En algunos modos el proyecto genera por defecto el archivo de salida d90 para la depuración del programa. Si en la pestaña Output del enlazador vemos que esto no es así, deberemos modificar la configuración para que quede como se indica en la imagen. Obviamente no todos los archivos de salida de llamarán ledflasher3. Solo asegúrate de que tenga la extensión d90 (la escribes si fuera necesario) y de que su formato sea ubrof 8 (forced). Observa que el enlazador también puede generar otros archivos de depuración como COFF o ELF, pero no todos los formatos serán igualmente válidos para todos los microcontroladores. Los archivos ELF de IAR, por ejemplo, solo setán disponibles para los 68HC11, 68HC12, 68HC16, ARM, M16C, MC80, M32C, R32C, SH, y V850.
No sé por qué, pero normalmente el archivo HEX no se genera de forma automática. Para ello debemos ubicarnos en la pestaña Extra Output y dejamos la configuración mostrada en la siguiente imagen. Como en el caso anterior debes escribir la extensión HEX si fuera necesario. De hecho, puedes intercambiar el orden y configurar en la anterior ventana la generación del archivo HEX y en esta ventana la del archivo d90.
Añadiendo Archivos o Librerías
Bueno, si se tratara de un programa más sencillo que constara solo de un archivo de código fuente, ya podríamos construirlo. Pero aunque sea ésta una sencilla demostración, quise realizarla con un programa promedio de cursomicros.com. Aquí casi todas las prácticas utilizan el puerto serie para intercambiar datos con el ordenador y para ello se requiere de las librerías del USART respectivas conformadas por los archivos usart.h y usart.c. Además será necesario incluir el archivo avr_compiler.h, que se encarga de mantener la compatibilidad del código para que funcione en los compiladores IAR C y AVR GCC (WinAVR).
Así que ahora procedemos a incluir los archivos descritos. Los puedes encontrar en casi cualquier práctica de cursomicros. Cuando los hayas localizado cópialos en la carpeta de este proyecto, junto al archivo main.c, como se ve abajo.
Que los archivos señalados estén en la misma carpeta del proyecto no significa que ya formen parte de él. Para indexarlos al proyecto hacemos lo que indica la siguiente figura.
En el cuadro de diálogo que surge seleccionamos los archivos a añadir. Podemos seleccionar varios archivos al mismo tiempo.
Ahora por fin el panel Workspace nos muestra todos los archivos del proyecto, debidamente indexados.
Construyendo el Proyecto
No queda más que construir el proyecto. Ya sabemos que en los compiladores C construir implica compilar, enlazar, ensamblar y generar los archivos de salida.
Si la construcción resulta exitosa tendremos el siguiente reporte.
Los archivos de salida incluyen el archivo HEX para grabar el microcontrolador y el archivo d90 que se utiliza en programas depuradores como Proteus. Estos archivos se encuentran en la carpeta Exe que a su vez está dentro de la carpeta Debug.
Simulando el Programa
El entorno de IAR C incluye un buen simulador y un potente depurador que trabaja incluso a nivel hardware llamado C-SPY. La siguiente captura muestra la simulación en Proteus. El procedimiento es sencillo: solo creas un diseño en ISIS y en el AVR cargas el archivo con extensión d90 generado por el compilador. Para una información pormenorizada puedes ir aquí.
Para la simulación con C-SPY de IAR se debe primero reconfigurar la generación del archivo d90 de acuerdo con lo mostrado en la siguiente figura. Ésta era la opción por defecto que tuvimos que cambiar para que el archivo d90 sea aceptado por proteus. La opción Allow C-SPY specific extra output file nos permitirá poder obtener nuestro archivo HEX de costumbre.
Después de reconstruir el proyecto podemos ir al menú Project > Downlod and Debug y estaremos frente a la siguiente interface. Aparecerán varias nuevas opciones en los menús y también nuevas barras de herramientas, entre ellas la que contiene los ya clásicos comandos de simulación como step over, step into, etc.
Descargar la Práctica
Clic aquí.