engblaze.com http://www.engblaze.

com/tutorial-using-atmel-studio-6-with-arduino-projects/

Tutorial: Using Atmel Studio 6 with Arduino projects

In our previous Atmel tutorial , we talked about how to set up the powerful AVR Studio 5 IDE to incorporate Arduino
libraries and projects. As flexible as AVR Studio 5 is, it had a few issues, and Atmel has been hard at work hustling
the next major version out the door. Now, rebranded as Atmel Studio 6 (no longer just for AVRs!), the new version
promises to be better, faster, and easier to use. Here, we’ll show you the quickest way to get up and running if you
want to use Arduino code with all of the new features.

Note: This article explains how to set up the Atmel Studio 6 IDE for use with Arduino projects, step-by-step. It also
notes on general setup for working with Atmel devices, background on the pros/cons of working with AVR Studio, and
a few other tips. A table of contents is below; feel free to skip to any section that interests you.

Introduction
Preparing AVR Studio and the Arduino core library
Compiler and linker setup
Build your project
Flash!
Final notes
Further reading

Introduction
Atmel Studio 6 delivers a lot of the value that AVR Studio 5 promised but never quite gave. Released in 2011 and
based on Microsoft Visual Studio, Studio 5 was a large change from AVR Studio 4, which was based on the tried and
true Eclipse IDE. Studio 4 is seriously showing its age these days, so a refresh was welcome. However, version 5
came with a long list of bugs and didn’t deliver on a lot of the feature list, which left a lot of people wondering whether
they should upgrade. The new version appears to have addressed a lot of those bugs, and gets higher marks from us
in our initial testing.

Why should I switch?

Atmel Studio is a great choice for users that have outgrown the integrated Arduino IDE. The Arduino IDE does so
much under the hood that it can actually be quite limiting for experienced programmers. As we discussed in our
previous tutorial, the lack of compiler warnings and debugging capabilities (Serial.println() after every statement
doesn’t count), make life hard when working on advanced projects.
AVR Studio is a huge step up from those limitations, but for many, making the switch cold turkey is just that: a huge
step. If you have a big project, porting the entire thing to pure C can be a daunting task. Plus, some of those Arduino
libraries are just so darn convenient. Software serial, anyone? Ethernet capability? Aw yeah.

So why not have the best of both worlds? Arduino is basically a wrapper on top of C/C++ anyway, so technically, it’s
possible to combine any Arduino sketch or library with your own custom code. The trick is in setting up your project
properly. Here are the steps to create a fully functional Arduino project in AVR Studio 6. Once accomplished, you can
keep access to the huge Arduino user-contributed code library, but enjoy all the features of advanced AVR and a real
IDE.

Preparing AVR Studio and the Arduino core library

1. First, a few preparation steps. This tutorial assumes you have AVR Studio installed already. Unlike the last
version, Studio 6 comes with full C++ support out of the box, so we don’t need to install anything extra.
2. In order to build Arduino projects, we need to grab the Arduino core library. Normally, the Arduino IDE compiles
this for us whenever we compile a sketch. To use it in Atmel Studio, we’ll compile it first, then grab the
compiled version and include it in our project. Open the Arduino IDE and turn on verbose output (“File” ->
“Preferences” -> check “Show verbose output during compilation”). On Windows Vista or 7, the path
should look like this: C:/Users//AppData/Local/Temp/
3. Make sure the Arduino IDE is set for whichever chip you want to use with Atmel Studio, and compile any
example sketch, such as the included blink example. In your output window at the bottom of the IDE window,
you should see information on where the IDE put the temporary build output. It will look something like
“C:Users\{Your User}\AppData\Local\Temp\build3173545040878149377.tmp”.
4. Before you open it, go to your Atmel Studio working directory. This is the folder that stores all of your projects –
by default, it’s “..\My Documents\Atmel Studio\”. Create a new directory here to store your Arduino core
files, and name it something appropriate (“arduinoCore” or similar).
5. Copy and paste the temporary directory from the Arduino IDE into Windows Explorer to open it. You’ll see a
bunch of files, including one called core.a. Copy that file and paste it into your arduinoCore directory. Rename
it from “core.a” to “libcore.a” so Atmel Studio recognizes it as a standard library. Now that it’s there, you can
reuse it for any Atmel Studio project as long as you’re using the same type of AVR.
6. If you’re converting an existing sketch called , open the .cpp file from the bldxxx.tmp directory in a text editor.
You can simply copy and paste this code into your AVR Studio project to speed things up in a minute.
7. Sweet, we’re ready to switch environments. Open AVR Studio and create a new AVR Studio C++ executable
project. Remember to name it in the wizard that pops up, because it’s a pain to rename a project later.
8. Choose your chip type. Many Arduino boards use the ATMega328 or 328P, which you’ll find under the
megaAVR, 8-bit device family. Older Arduinos use the ATMega168, while the newer Leonardo uses the
ATMega32U4. Look closely at the chip on your board for the model # if you’re unsure what chip you have.
9. Copy and paste the source code from the compiled .cpp file you opened earlier into the project’s main .cpp
file. You can also copy/paste the source from your Arduino .pde sketch. The first option is easier because it
includes necessary function prototypes that the Arduino IDE automatically generates, while in the latter case
you must add them yourself. In either case, you have to have these prototypes, or else the compiler will
complain that every single function is “not declared in this scope” when you try to build your project. This is
one of those things that the Arduino IDE hides from you. Adding your own prototypes is a no brainer once
you’re used to it, and it can actually save headache because automatic generation can cause problems in
more advanced projects. Remember to include prototypes for setup() and loop() – those aren’t default CPP
functions, and the AVR compiler sees them as your own additions just like anything else.
10. Add #include Arduino.h". to the very beginning of your source code.
Compiler and linker setup

1. Now we have to tackle proper compiler setup and linking. Go to “Project”->” Properties” (or press Alt-F7),
then click on “Toolchain”. We need to setup a bunch of compiler options here. By default, this will only edit
your “Debug” build configuration, so select “All Configurations” from the Configuration drop-down menu if
you want to modify both release and debug configurations at the same time.
2. First, click on “Symbols”, in the left-hand “AVR/GNU C++ Compiler” dropdown menu. We need to add a
symbol to tell the compiler the speed of our chip: for example, click the green plus icon, then enter
"F_CPU=16000000L" for a 16Mhz chip. Most 5V Arduinos are running at 16Mhz, hence 16000000 (L stands
for long integer). If you have a 3.3V Arduino, it will likely be set at 8Mhz, so use F_CPU=8000000L instead.
Next, add another symbol to define your Arduino software version: "ARDUINO=100" for v1.0,
"ARDUINO=101" for v1.01, etc.
3. Click on to “Directories” in the same C++ Compiler menu. We need to add the directories that contain our
Arduino core code and libraries, so the compiler can string it all together for us. For any Arduino project, we’ll
need to tell the compiler where to find “Arduino.h” and “pins_arduino.h”. Starting in your Arduino installation
directory, add the folders “./hardware/arduino/cores/arduino” and “./hardware/arduino/variants/standard”.
4. You’ll need to add the directories of any extra Arduino libraries you’re using. For example, if you include the
SoftwareSerial library, go ahead and add that directory to this section so the compiler knows where to find it. If
you forget anything, the compiler will tell you when you try to build, with a message such as “SoftwareSerial.h:
No such file or directory”. You should also add the home directory of your project, so the compiler can find
source files there.
5. You’ll also need to add the .cpp source files for those same linked libraries to your actual Atmel Studio project.
Add a directory to your project (“Project”->”New Folder”) and name it “libraries”, to keep things organized.
Then, go to “Project”->”Add Existing Item” (or Shift+Alt+A), and find the source directories for your
included libraries (usually in “/libraries”, unless you have a custom setup). Select the source files, but instead
of clicking the “Add” button, click the small arrow next to it, and click “Add as link”. You’ll notice the file show up
in your Solution Explorer with a small shortcut icon next to it.
 6. Click on “Optimization” immediately under “Directories”. Choose “Optimize for size” under
“Optimization Level“. Add "-fdata-sections" under “other optimization flags”, and check the box for
“prepare functions for garbage collection”. Next, click on “Miscellaneous” in the same list, and add "-fno-
exceptions" to the “Other flags” field. Keep in mind that the Arduino IDE keeps all other optimization flags
off – feel free to leave the other default boxes in “Optimization” checked as they may improve program size,
but if you’re having build problems, try turning them off.
7. Now we’ll move on to the linker. In the left-hand menu, click on “AVR/GNU Linker”->”Libraries”. In the top
Libraries section, you should already see an entry for “m”, which is the AVR math library. Add an entry called
“core”, which is our libcore.a file that we grabbed earlier.
8. We also need to tell it where to find libcore.a, so add our earlier “arduinoCore” directory under “Library
search path“.
9. Click on “AVR/GNU C++ Linker”->“Optimization”, and check the box for “Garbage Collect unused
sections (-Wl, –gc-sections)”. This tells the linker to leave out unused portions of each library, which
reduces final code size.
10. Awesome, we’re done with the project setup. Save your settings, and we can get back to the code.

Build your project

1. At this point, your environment should be completely set up. Hit F7 to build your solution and watch the output
window. Is it successful? If so, great. If not, take a look at the errors to see if there’s a problem with the code
or if it’s likely a problem with the linked files. Also take a look at the beautiful new world of compiler warnings
you’ve uncovered. If your project is at all complex and you’ve only compiled using the Arduino IDE previously,
you’ll have at least a few warnings. These warnings won’t necessarily break your program, but they could.
Eliminating them usually means you’re following best practices. There are a few warnings generated by the
Arduino core libraries – if you’re feeling adventurous you can alter that code, but everything will work fine if you
leave them alone.

Configure AVRDude to flash your compiled code

1. Once you’ve built your project successfully, you need to upload it to your device. Fortunately, you can do this
using the exact same method as the Arduino IDE. Arduino uses the avrdude utility to flash via serial, and we’ll
do the same. We just need to tell AVR Studio what options to use. Click on “Tools”->”External Tools…”,
then click “Add” in the window that pops up.
2. If you’re using a USB to Serial cable like most Arduino boards do, note which COM port it uses and make the
title something like “Usb to Serial Programmer: COM10” for easy identification.
3. In the “Command” field, put the path to avrdude.exe in your Arduino installation. For example:
"C:/arduino-1.0.1/hardware/tools/avr/bin/avrdude.exe" (quotes removed).
 4. In “Arguments”, paste this line: -CC:\dev\arduino-1.0.1\hardware/tools/avr/etc/avrdude.conf
-v -v -patmega328p -cwiring -P\\.\COM10 -b57600 -D -
Uflash:w:"$(ProjectDir)Debug\$(ItemFileName).hex":i If you’re using Edit the path to your
Arduino installation and change the COM port, chip target, and baud rate if necessary (ATMega328’s normally
need 57600 baud, older ATMega168’s flash at 19200. A few of our commenters pointed out that the Arduino
Ethernet uses 115200 by default, and possibly the ATMega328P as well. Check what the Arduino IDE is using
and copy that for your model). The rest of the flags are the exact same as the Arduino IDE uses. The “-v” flags
control the level of verbosity – feel free to play with this parameter. You can include up to four “-v”s (which logs
every serial byte transmitted, woohoo!), but we’ve found that two flags provide enough information without
being overwhelming. Note: if you have any trouble with this step, go back to the Arduino IDE and flash a
project in verbose mode by holding Shift while you press the “Upload” button. This will display all of the
command line output in the bottom status window, and you can see exactly what command your system is
using to call avrdude.exe. Edit accordingly for the AVR Studio options. You may also want to check the “Use
Output window” box so you can see the results of the flash; otherwise AVRDude will open a command
window and close it the moment it’s done. If you’re using an older version of the Arduino software (prior to
1.0.2), you may need to replace “-cwiring” with “-carduino”. Again, it’s best to check what arguments the IDE is
using and copy those.

Flash!
1. Boo yah. Go back to your project and click on the “Tools” menu; there should now be a new menu item for
your “USB to Serial Programmer”. Make sure you have the main .cpp source file open in your IDE window –
the serial programmer will try to access a .hex file for whatever tab is open, so this is the only one that will
work. Ensure your Arduino is connected to your computer, then click the Programmer menu item. You should
see AVRDude open up in your output window, then a progress bar showing flash status. Look for the
“AVRDude is done. Thank you!” message after a successful flash.

A lot of this prep work only needs to be done once. You’ll need to set up the toolchain properly for each project you
create, but now that you have the Arduino core library and some practice, things go much quicker the 2nd time. The
AVRDude setup is universal and can be reused for every project.

You’re done! You now have an Arduino with a fully working project, and a huge amount of new development
possibilities ahead of you. Explore AVR Studio and everything it has to offer, you’ll be impressed. The AVR Simulator
and step-through debugging are absolutely priceless when you’re working on a complex project, and you can now
mix Arduino and avr-libc code to your hearts content.

Final Notes:
1. In some cases, your build may produce ‘cxa_pure_virtual()’ errors. This is due to a missing error handling
function for pure virtuals in C++, but we can provide it ourselves: add

extern "C" void __cxa_pure_virtual() { while (1); }

to your main source file. This function doesn’t do much, but from what we’ve read these errors can safely be
ignored, so we just provide a dummy function to make the compiler happy. You could also place this in a
"pure_virtual.cpp" file and then include it in every new project.
 2. Are you looking for a cross platform solution? You won’t find it here, as AVR Studio is Windows only. If that’s
alright with you, full steam ahead, but otherwise, you may want to look at Eclipse as a full-featured, cross-
platform IDE. AVR Studio has some features that Eclipse doesn’t (the AVR Simulator is huge, among other
things), but the latter is no slouch. The Eclipse setup process is similar and is outlined in great detail on the
Arduino website.

Further reading
Smiley’s Workshop, a site dedicated to AVR programming and projects, has a comprehensive article on switching
from the Arduino IDE to AVR Studio. It’s a bit older and discusses AVR Studio 4 instead of 5, but is excellent
background reading if you’re still trying to wrap your head around everything.