Arduino Como Programador AVR

Tarea 1 Taller de Microcontroladores “Cómo usar Arduino como Programador AVR ISP” Carlos Flores Meléndez Ingeniería Mecatrónica, Facultad de Ingeniería, Universidad de Talca [email protected]

Resumen— Este documento es una guía paso a paso para el uso de placas arduino como programadores de microcontroladores AVR. Adicionalmente se explica cómo programar estos mismos usando el lenguaje e IDE de arduino. Palabras Claves— Arduino, Programador, AVR, ISP, SPI, Avrdude.

I. INTRODUCCIÓN En este documento se explica paso a paso el procedimiento necesario para convertir una placa arduino UNO en un programador AVR ISP STK500v1 compatible. Mencionando también algunos de los procedimientos más comunes para programar microcontroladores AVR usando el lenguaje AVR-GCC y su respectiva conversión a archivos HEX y consecuente “quemado” de estos en el microcontrolador. Adicionalmente se presenta un método para facilitar la programación de microcontroladores AVR usando el lenguaje propio de arduino y la IDE de este, de tal forma de evitar la programación usando AVR-GCC y permitir la creación de “placas arduino” en un solo chip, grabando el bootloader de la plataforma arduino en un microcontrolador AVR independiente y sin la necesidad de un reloj externo.

II. ARDUINO COMO PROGRAMADOR AVR El proceso para convertir cualquier placa arduino en un programador AVR consta de 4 etapas básicas: 1.

Cargar el Sketch “Arduino ISP” en la placa arduino

2.

Armar circuito de estado del programador

3.

Conectar un microcontrolador AVR compatible

4.

Compilar y quemar archivo HEX en el microcontrolador

A continuación el detalle de cada etapa: A. Sketch “Arduino ISP” Para usar una placa arduino como programador AVR es necesario cargar en esta un sketch que tenga todas las instrucciones necesarias para que el arduino actúe como programador. Este sketch se puede encontrar en la sección de ejemplos del propio IDE de arduino con el nombre de “ArduinoISP” (ver fig. 1).

Fig. 1

Una vez abierto el sketch, se puede apreciar en el apartado comentado las instrucciones básicas para el uso del mismo (ver fig. 2).

Fig. 2

Como se aprecia en la figura 2, nos dicen que el programa utiliza los pines 10, 11, 12 y 13 (Arduino UNO) para la programación AVR usando el protocolo SPI, el cual utiliza 6 conexiones para programar un microcontrolador AVR, 4 de las cuales son: RESET, MOSI, MISO y SCK respectivamente. Las 2 conexiones restantes son las de alimentación (VCC y GND) las cuales corresponden a la salida de 5v y GND en el arduino respectivamente. Además de indicarnos cuáles serán los pines utilizados para programar, nos recomiendan conectar 3 LED a los pines 7, 8 y 9, los cuales servirán para indicar el estado del programador.

B. Circuito de estado del programador Una vez cargado el sketch “ArduinoISP” en el Arduino UNO, debemos conectar un capacitor de 10uF entre los pines Reset y GND para evitar el reinicio del arduino mientras lo utilizamos como programador. Es importante recordar conectar este capacitor después de grabado el sketch en el arduino. Adicionalmente debemos conectar los 3 LED de estado a los pines 7, 8 y 9 y conectar un cristal de cuarzo y sus respectivos capacitores al microcontrolador que queremos programar. Esto es solo necesario en caso de que se quiera utilizar un reloj externo (ver fig. 3). De lo contrario se puede utilizar el reloj interno del microcontrolador, para lo que se deben quemar adecuadamente los fuses del microcontrolador. Este ajuste se realiza en el programa que utilicemos para programar (Avrdude por ejemplo) y lo profundizaremos más adelante.

Fig. 3 También es posible desarrollar un “Shield” para el arduino (ver fig. 4), que contenga los LED de estado, el capacitor y los cables de las salidas para la programación mediante SPI.

Fig. 4

Fig. 5

Una vez encendido el arduino el LED conectado al pin 9 parpadeará suavemente indicando que el programador está funcionando (ver fig. 5). A su vez mientras se esté programando un microcontrolador se encenderá el LED conectado al pin 7 y cuando surja un error al programar se encenderá el LED conectado al pin 8 del arduino.

C. Conexión SPI Una vez cargado el sketch de programador y conectados los respectivos LED de estado y el capacitor de 10uF, debemos conectar las salidas de programación de nuestro arduino

a

los

pines

correspondientes

en

el

microcontrolador, según el estándar SPI (ver fig. 6) proporcionando las 6 conexiones de este protocolo a los Fig. 6

pines correspondientes según el microcontrolador que queramos programar.

En la figura 7 se pueden apreciar las 6 conexiones del protocolo SPI conectadas a un microcontrolador Atmega 328P, las cuales son válidas también para los modelos Atmega48, Atmega168 y Atmega328.

PIN 1

RESET

PIN 7

VCC

PIN 8

GND

SCK

PIN 19

MISO

PIN 18

MOSI

PIN 17

Fig. 7

D. Compilado y quemado de archivo HEX Habiendo conectado correctamente el arduino que usaremos como programador al microcontrolador solo queda compilar el programa que queremos grabar y convertirlo en un archivo HEX. Esto se puede realizar utilizando diversas suites de programación que soporten AVR-GCC, como CodeBlocks, AVR Studio o incluso el IDE de arduino el cual también genera un archivo HEX. Una vez generado el archivo HEX podemos quemar este en un microcontrolador usando el arduino que tenemos como programador. Para esto es necesario utilizar algún programa compatible con el protocolo STK500v1 al cual pertenece el programador que hemos creado con el arduino, como por ejemplo AVRDUDE.

Para “quemar” un archivo HEX usando AVRDUDE, es necesario instalar en el caso de Windows la aplicación WinAVR y luego utilizar la terminal de comandos de Windows para utilizar los comandos de AVRDUDE (ver fig. 8), a través de los cuales se deben determinar los siguientes parámetros: 1.

Microcontrolador a programar (comando “-p”)

2.

Programador a utilizar (comando “-c”)

3.

Puerto a utilizar (comando “-P”)

4.

Velocidad en baudios del programador (comando “-b”)

5.

Ubicación del archivo HEX a quemar (comando “-U”)

Fig. 8

En este caso se programó un microcontrolador atmega328p utilizando un programador compatible con el protocolo STK500v1 (Arduino ISP) y se quemó el archivo “Blink.cpp.hex” a 19200 baudios a través del puerto COM23. Al apretar la tecla ENTER se “quema” el archivo en el microcontrolador y el programa nos muestra diversas barras de progreso y el estado en que finalizó el “quemado” del microcontrolador (ver fig. 9).

Fig. 9

III. ARDUINO IDE PARA PROGRAMAR AVR Una de las ventajas de utilizar la plataforma arduino, es su lenguaje simplificado para programar microcontroladores AVR, el cual es ampliamente más amigable que C# propiamente tal usando AVR-GCC. El problema es que para utilizar este lenguaje simplificado es necesario utilizar únicamente placas arduino debidamente cargadas con el bootloader de la plataforma arduino. Impidiendo aparentemente la programación de microcontroladores directamente usando el IDE y lenguaje de arduino. Una solución a esto es utilizar la IDE de arduino para compilar los sketches y luego buscar los archivos HEX generados y quemarlos en un microcontrolador AVR usando algún programador (como se vio en la sección anterior de este documento). Pero este proceso es engorroso ya que debemos utilizar un programador AVR y un programa adicional al IDE de arduino para quemar los archivos HEX. Para evitar los problemas mencionados es posible editar el IDE de arduino para que reconozca microcontroladores solos como si se tratasen de placas arduino. De esta forma no solo se consigue programar directamente microcontroladores AVR usando el lenguaje arduino sino que además es posible quemar el bootloader adecuado para cada microcontrolador y convertir este en una placa arduino completamente funcional. Incluso es posible configurar el microcontrolador para que utilice el reloj interno de 8Mhz (las placas arduino utilizan relojes externos de 16Mhz) logrando así un arduino en un solo chip, reduciendo considerablemente el tamaño y costo de esta “placa arduino”, ya que es solo un microcontrolador AVR que básicamente fue convertido en un arduino.

Por lo tanto, para convertir un microcontrolador AVR en un arduino completamente funcional, es necesario realizar 3 pasos básicos: 1.

Editar el IDE de arduino agregando una nueva tarjeta para que reconozca el microcontrolador

2.

Quemar el bootloader en el microcontrolador usando un programador

3.

Utilizar un programador o convertidor serial para programar el nuevo arduino usando el IDE de la plataforma arduino.

A. Agregar nueva “Board” Para que el IDE de arduino reconozca al microcontrolador que queremos programar, debemos agregarlo como una tarjeta o “board” al sistema. Para ello nos dirigimos a la carpeta de instalación del IDE siguiendo la siguiente ruta (considerando a “Arduino” como la carpeta donde se encuentra el IDE de arduino): Arduino\hardware\arduino\boards.txt Buscamos el archivo boards.txt y lo abrimos con algún editor de texto. Una vez abierto el archivo boards.txt podremos apreciar los parámetros de cada tarjeta que puede reconocer el IDE de arduino, empezando por la placa “Arduino UNO” y seguida de otras placa como la “Arduino Duemilanivove” y otras. A cada una de las placas o “boards” se les asignan diferentes parámetros para que puedan ser reconocidas correctamente por el IDE de arduino (ver fig. 10).

Algunos de los parámetros definidos son:  Nombre de la tarjeta  Memoria máxima  Velocidad de programación  Configuración de fuses  Microcontrolador utilizado  Velocidad de reloj

Para que el IDE reconozca al microcontrolador que queremos programar como otra tarjeta más, debemos agregar en este archivo todos los parámetros requeridos para que este pueda reconocerlo Fig. 10

correctamente y nos permita programarlo.

Como una mala configuración de fuses en un microcontrolador puede estropearlo fácilmente, es importante introducir cada uno de los parámetros correctamente, haciendo hincapié en configurar correctamente los fuses de acuerdo a si se utilizará un reloj externo o el reloj interno del microcontrolador. En nuestro caso agregaremos un microcontrolador Atmega328P (ver fig. 11) y un Atmega168 (ver fig. 12) los cuales se configurarán para usar el reloj interno del microcontrolador. Por lo tanto pegamos la siguiente información en el archivo boards.txt y lo guardamos:

Atmega 328P (usando reloj interno) atmega328bb.name=ATmega328p on a breadboard (8 MHz internal clock)

atmega328bb.upload.protocol=stk500 atmega328bb.upload.maximum_size=30720 atmega328bb.upload.speed=57600 atmega328bb.bootloader.low_fuses=0xE2 atmega328bb.bootloader.high_fuses=0xDA atmega328bb.bootloader.extended_fuses=0x05 atmega328bb.bootloader.path=arduino:atmega atmega328bb.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex atmega328bb.bootloader.unlock_bits=0x3F atmega328bb.bootloader.lock_bits=0x0F atmega328bb.build.mcu=atmega328p atmega328bb.build.f_cpu=8000000L atmega328bb.build.core=arduino:arduino atmega328bb.build.variant=arduino:standard

Fig. 11

Atmega 168 (usando reloj interno) atmega168bb.name=ATmega168 on a breadboard (8 MHz internal clock) atmega168bb.upload.protocol=stk500 atmega168bb.upload.maximum_size=14336 atmega168bb.upload.speed=57600 atmega168bb.bootloader.low_fuses=0xE2 atmega168bb.bootloader.high_fuses=0xDA atmega168bb.bootloader.extended_fuses=0x05 atmega168bb.bootloader.path=arduino:atmega atmega168bb.bootloader.file=ATmegaBOOT_168_pro_8MHz.hex atmega168bb.bootloader.unlock_bits=0x3F atmega168bb.bootloader.lock_bits=0x0F atmega168bb.build.mcu=atmega168 atmega168bb.build.f_cpu=8000000L atmega168bb.build.core=arduino:arduino atmega168bb.build.variant=arduino:standard

Fig. 12

Una vez modificado el archivo boards.txt procedemos a abrir el IDE de arduino y nos dirigimos a la pestaña: “Herramientas > Tarjeta”, donde aparecerán las nuevas tarjetas como opción (ver fig. 13).

Fig. 13

B. Quemado del Bootloader Ahora que podemos seleccionar el microcontrolador por si solo como una “tarjeta arduino” podemos quemar en este el bootloader de arduino usando algún programador AVR, e incluso utilizar el programador que creamos con un arduino en la sección II de este documento. Para ello seleccionamos el microcontrolador en la sección de tarjetas (ver fig. 13) y luego nos dirigimos a la pestaña “Herramientas > Programador” y seleccionamos el programador a utilizar, en nuestro caso elegimos la opción “Arduino as ISP” (ver fig. 14) ya que utilizaremos el programador que construimos previamente utilizando un Arduino UNO.

Fig. 14 Luego de seleccionar el programador y verificar que se encuentra seleccionado el puerto COM correcto, hacemos click en la opción “Grabar Secuencia de inicio”. El programa comenzará a grabar el bootloader en el microcontrolador, convirtiendo a este en un arduino todo-en-uno en un mismo chip.

C. Programar Microcontrolador Una vez quemado el booloader es posible programar nuestro microcontrolador directamente con el IDE de arduino, para ello una vez terminado el sketch seleccionamos la opción “Cargar usando programador” (ver fig. 15). Para programar el microcontrolador usando el IDE de arduino pero sin utilizar un programador AVR es necesario utilizar un convertidor serial, como los utilizados en la programación de arduinos LilyPad, conectando el convertidor serial al USB y a los pines correspondientes a comunicación serial y alimentación del microcontrolador.

Fig. 15