Programando Arduino desde Atmel Studio 7 integrando

AVRDUDE

Atmel Studio 7 nos permite integrar el programa AVRDUDE de Arduino con el fin de programar una
tarjeta Arduino y realizar proyectos ya sea utilizando lenguaje C++, lenguaje ensamblador o crear
proyectos basados en los “sketchs” de Arduino aprovechando las ventajas que nos ofrece todo el
entorno de Atmel estudio.

A continuación se mostrará como configurar el entorno de Atmel Studio para poder programar una
tarjeta Arduino Mega creando proyectos en lenguaje C++ y ensamblador

Las pruebas fueron realizadas utilizando la versión 1.6.5 de Arduino, atmel Studio 7 y el sistema
operativo Windows 7.

1. Configuración inicial.

1.1. Descargar e instalar la versión más reciente del IDE Arduino disponible en la página oficial
https://www.arduino.cc/

1.2. Una vez instalado el programa y al abrir el programa ingresar en la opción Archivo 
preferencias, en la sección que dice “mostrar salida detallada mientras:” activar la casilla
subir o upload
1.3. Utilizar un ejemplo de Arduino y subirlo a la board que estemos utilizando. Para este
ejemplo se utiliza el Sketch Blink y la tarjeta Arduino Mega. Se debe observar información
que se muestra en la parte inferior del IDE Arduino, esta información será utilizada para
configurar posteriormente el Atmel Studio 7.
De esta información se extrae lo siguiente:

Línea de comando:

C:\Program Files (x86)\Arduino\hardware\tools\avr/bin/avrdude 

Agregamos la extensión .exe a la aplicación avrdude en el caso de que no aparezca.

Entonces la línea de comando quedaría así:

C:\Program Files (x86)\Arduino\hardware\tools\avr/bin/avrdude.exe 

Argumento:

-CC:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf -

v -patmega2560 -cwiring -PCOM22 -b115200 -D -
Uflash:w:C:\Users\FELIXA~1\AppData\Local\Temp\build89386426458058
25899.tmp/Blink.cpp.hex:i

En esta sección se muestra información referente al tipo de tarjeta que estamos utilizando y el
puerto COM al cual se encuentra conectada, también sobre la ubicación del archivo hexadecimal
que resulta de la compilación del programa.

La parte resaltada en rojo se pone entre comillas doble y la parte resaltada en verde se cambia por
la expresión: "$(BinDir)\$(TargetName).hex"

El argumento queda entonces de la siguiente manera:

-C”C:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf”

-v -patmega2560 -cwiring -PCOM22 -b115200 -D -
Uflash:w:"$(BinDir)\$(TargetName).hex":i
 1.4. Descargar e instalar la versión 7 de atmel Studio disponible en la páginal
http://www.atmel.com/tools/ATMELSTUDIO.aspx

Una vez instalado ejecutar la aplicación e ingresar en la opción Tools  External Tools

1.5. En la ventana que aparece se debe configurar el argumento y la línea de comando que se
definió en la sección 1.3 de esta guía.

 
Titulo
  Escribir aquí la línea de comando 
Escribir aquí los argumentos 
 

Seleccionamos un título, por ejemplo Upload y copiamos la línea de comando y el argumento en la

sección command y Arguments respectivamente, le damos entonces click en Apply y OK. Con esto
ya queda entonces configurado nuestro entorno Atmel Studio 7 para poder programar una tarjeta
Arduino Mega.

Es importante resaltar que los argumentos configurados en la ventana external tools dependen de
la tarjeta que estemos utilizando y el puerto COM que haya sido asignado, por tanto al cambiar de
tarjeta es necesario verificar nuevamente estos parámetros para configurar correctamente nuestra
aplicación.

2. Creando un proyecto en lenguaje C++

Realizaremos la comprobación de la configuración realizada creando un nuevo proyecto el cual

cambie de estado el puerto B del microcontrolador esto lo podemos verificar con el LED conectado
al pin 13 en el Arduino.

#include <avr/io.h> 
#define F_CPU 16000000UL 
#include <util/delay.h> 
 
int main(void) { 
  DDRB = 0xff ; 
  while (1) { 
    PORTB= 0xff; 
    _delay_ms(500); 
    PORTB = 0x00; 
    _delay_ms(500); 
  } 
} 

2.1. En el menú File  New Project seleccionamos la opción GCC C++ Executable Project,
asignamos un nombre al proyecto y definimos la ubicación del mismo.  

 
 
2.2. Seleccionar el microcontrolador que estemos utilizando, en este caso es el ATmega2560

2.3. Escribir el código y en el menú Build seleccionar la opción Build Solution para compilar y
generar el archivo .hex
 2.4. Si no existen errores se mostrará en la parte inferior de la pantalla el resultado de la
compilación con el mensaje Build succeeded.

 
2.5. Seleccionar Upload en la opción Tools para subir el programa a la board de arduino
 

 
En la parte inferior debe salir algo como lo que se muestra a continuación:

avrdude.exe: Version 6.0.1, compiled on Apr 15 2015 at 19:59:58 
             Copyright (c) 2000‐2005 Brian Dean, http://www.bdmicro.com/ 
             Copyright (c) 2007‐2009 Joerg Wunsch 
 
             System wide configuration file is "C:\Program Files 
(x86)\Arduino\hardware\tools\avr/etc/avrdude.conf" 
 
             Using Port                    : COM22 
             Using Programmer              : wiring 
             Overriding Baud Rate          : 115200 
             AVR Part                      : ATmega2560 
             Chip Erase delay              : 9000 us 
             PAGEL                         : PD7 
             BS2                           : PA0 
             RESET disposition             : dedicated 
             RETRY pulse                   : SCK 
             serial program mode           : yes 
             parallel program mode         : yes 
             Timeout                       : 200 
             StabDelay                     : 100 
             CmdexeDelay                   : 25 
             SyncLoops                     : 32 
             ByteDelay                     : 0 
             PollIndex                     : 3 
             PollValue                     : 0x53 
             Memory Detail                 : 
 
                                      Block Poll               Page                       Polled 
               Memory Type Mode Delay Size  Indx Paged  Size   Size #Pages MinW  MaxW   ReadBack 
               ‐‐‐‐‐‐‐‐‐‐‐ ‐‐‐‐ ‐‐‐‐‐ ‐‐‐‐‐ ‐‐‐‐ ‐‐‐‐‐‐ ‐‐‐‐‐‐ ‐‐‐‐ ‐‐‐‐‐‐ ‐‐‐‐‐ ‐‐‐‐‐ ‐‐‐‐‐‐‐‐‐ 
               eeprom        65    10     8    0 no       4096    8      0  9000  9000 0x00 0x00 
               flash         65    10   256    0 yes    262144  256   1024  4500  4500 0x00 0x00 
               lfuse          0     0     0    0 no          1    0      0  9000  9000 0x00 0x00 
               hfuse          0     0     0    0 no          1    0      0  9000  9000 0x00 0x00 
               efuse          0     0     0    0 no          1    0      0  9000  9000 0x00 0x00 
               lock           0     0     0    0 no          1    0      0  9000  9000 0x00 0x00 
               calibration    0     0     0    0 no          1    0      0     0     0 0x00 0x00 
               signature      0     0     0    0 no          3    0      0     0     0 0x00 0x00 
 
             Programmer Type : Wiring 
             Description     : Wiring 
             Programmer Model: AVRISP 
             Hardware Version: 15 
             Firmware Version Master : 2.10 
             Vtarget         : 0.0 V 
             SCK period      : 47.8 us 
 
avrdude.exe: AVR device initialized and ready to accept instructions 
 
Reading | ################################################## | 100% 0.02s 
 
avrdude.exe: Device signature = 0x1e9801 
avrdude.exe: safemode: lfuse reads as FF 
avrdude.exe: safemode: hfuse reads as D0 
avrdude.exe: safemode: efuse reads as FF 
avrdude.exe: reading input file "C:\Users\Felix Andres\Documents\Atmel 
Studio\7.0\ArduinoProject\Blink_Led\Blink_Led\Debug\Blink_Led.hex" 
avrdude.exe: writing flash (300 bytes): 
 
Writing | ################################################## | 100% 0.08s 
 
avrdude.exe: 300 bytes of flash written 
avrdude.exe: verifying flash memory against C:\Users\Felix Andres\Documents\Atmel 
Studio\7.0\ArduinoProject\Blink_Led\Blink_Led\Debug\Blink_Led.hex: 
avrdude.exe: load data flash data from input file C:\Users\Felix Andres\Documents\Atmel 
Studio\7.0\ArduinoProject\Blink_Led\Blink_Led\Debug\Blink_Led.hex: 
avrdude.exe: input file C:\Users\Felix Andres\Documents\Atmel 
Studio\7.0\ArduinoProject\Blink_Led\Blink_Led\Debug\Blink_Led.hex contains 300 bytes 
avrdude.exe: reading on‐chip flash data: 
 
Reading | ################################################## | 100% 0.07s 
 
avrdude.exe: verifying ... 
avrdude.exe: 300 bytes of flash verified 
 
avrdude.exe: safemode: lfuse reads as FF 
avrdude.exe: safemode: hfuse reads as D0 
avrdude.exe: safemode: efuse reads as FF 
avrdude.exe: safemode: Fuses OK (H:FF, E:D0, L:FF) 
 
avrdude.exe done.  Thank you.

3. Creando un proyecto en lenguaje ensamblador

Creamos ahora un Proyecto para realizar la misma operación pero en lenguaje ensamblador
 
 
.EQU F_CPU = 16000000 
.ORG 0 
 
MAIN:   
LDI R16, 0xFF   
OUT DDRB, R16    ;Define el Puerto B como salida 
 
 
BACK:   
COM R16     ;Complementa el valor en el registro 16   
OUT PORTB, R16   ;Pone el dato en el Puerto B   
CALL DELAY   
RJMP BACK     ; Ciclo infinito 
 
DELAY:                ; Rutina de retardo 
LDI R17, 100   
LOOP3: LDI R18, 64   
LOOP2: LDI R19, 255   
LOOP1: DEC R19   
BRNE LOOP1  
DEC R18   
BRNE LOOP2  
DEC R17   
BRNE LOOP3  
RET         
3.1. En el menú File  New Project seleccionamos la opción AVR Assemebler Project,
asignamos un nombre al proyecto y definimos la ubicación del mismo. 

3.2. Seleccionamos el chip que vamos a utilizar

3.3. Copiamos el código en ensamblador y compilamos

3.4. Seleccionar la opción Upload en la opción Tools para subir el programa a la board de
Arduino.