You are on page 1of 10

Tutorial: Using Atmel Studio 6 with Arduino projects | EngBlaze

1 of 10





Arduino, AVR, and hardware hacks, oh my.







Online and In-Person Linux Training Courses From The Linux Foundation.

Microsoft PPM Dashboards
Ready out of the box Save time and money

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.
Preparing AVR Studio and the Arduino core library
Compiler and linker setup
Build your project
Final notes
Further reading

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

10/27/2014 8:01 PM

Tutorial: Using Atmel Studio 6 with Arduino projects | EngBlaze

2 of 10

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
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/<MyUser>/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
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 <sketch name>, open the <project_name>.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

10/27/2014 8:01 PM

Tutorial: Using Atmel Studio 6 with Arduino projects | EngBlaze

3 of 10

1. Now we have to tackle proper compiler setup and linking. Go to “Project”->”<ProjectName> 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,

10/27/2014 8:01 PM

Tutorial: Using Atmel Studio 6 with Arduino projects | EngBlaze

4 of 10

–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
‐carduino ‐P\\.\COM10 ‐b57600 ‐D ‐Uflash:w:"$(ProjectDir)Debug\$(ItemFileName).hex":i  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. One of our commenters pointed out that the Arduino Ethernet uses 115200 by default, so
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.


10/27/2014 8:01 PM

Tutorial: Using Atmel Studio 6 with Arduino projects | EngBlaze

5 of 10

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

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.





This entry was posted in Arduino, AVR, Tutorials and tagged arduino, atmel studio, AVR, how-to, ide, programming, tutorial by

on September 16, 2012 at 8:08 am said:

Thanks you very much for this good description. It is easier than with AVR Studio 5.
I think there is a little mistake here: “Uflash:w:”$(ProjectDir)Debug$(ItemFileName).hex”:i” you missed the “\” after Debug.

on September 16, 2012 at 10:24 pm said:

Great catch Sam, thanks! It should be fixed now.

on September 23, 2012 at 2:23 pm said:

10/27/2014 8:01 PM

Tutorial: Using Atmel Studio 6 with Arduino projects | EngBlaze

6 of 10

Thanks for this tutorial guys. I was able to configure, compile, and upload a blink test program to a breadboarded 328p.
However, while trying to compile a larger sketch, one that uses an external library, FastSPI, that failed.
In the AVR?GNU C++ Compiler Directories section, I do have the path to the library listed, it goes to the arduino-1.0.1\libraries
\FastSPI_LED path. I’m not sure what else I needed to do to get this library included. Do I have to compile/upload it first from
the IDE to get a “.a” library first and include that?
Right now when I try to compile, I get this:
Building target: Hoop.elf
Invoking: AVR8/GNU Linker : (AVR_8_bit_GNU_Toolchain_3.4.1_798) 4.6.2
“C:\Program Files (x86)\Atmel\Atmel Studio 6.0\extensions\Atmel\AVRGCC\\AVRToolchain\bin\avr-g++.exe” -o Hoop.elf
Hoop.o -Wl,-Map=”” -Wl,–start-group -Wl,-lm -Wl,-lcore -Wl,–end-group -Wl,-L”C:\Users\Ashley M.
Kirchner\Documents\Atmel Studio\arduinoCore” -Wl,–gc-sections -mmcu=atmega328p
Hoop.o: In function `CFastSPI_LED::setLeds(int)’:
C:\Users\Ashley M. Kirchner\Documents\Atmel Studio\Hoop\Hoop\Debug/.././Hoop.cpp(250,1): undefined reference to
C:\Users\Ashley M. Kirchner\Documents\Atmel Studio\Hoop\Hoop\Debug/.././Hoop.cpp(250,1): undefined reference to
C:\Users\Ashley M. Kirchner\Documents\Atmel Studio\Hoop\Hoop\Debug/.././Hoop.cpp(250,1): undefined reference to
etc., etc.
Suggestions on how to properly include a library?

on September 23, 2012 at 3:07 pm said:

Followup: that `CFastSPI_LED::setLeds(int)’ function IS part of the FastSPI library, that’s where that comes from. So it seems
that it does at least read it in, but I don’t know why it fails.
FYI, FastSPI is available from if you want to look how it’s written.

on September 25, 2012 at 5:37 pm said:

Have you added the FastSPI source as an “Existing Item” to your Atmel Studio project? That’s usually the cause of
“undefined reference” errors like the one you describe. You should be able to see the library .cpp files somewhere in
your Solution Explorer – make a new folder and add them to that if you want to avoid cluttering up your project

on September 26, 2012 at 12:34 am said:

All right, that got me a step further. Now it’s erroring out saying it can’t find WProgram.h. That file is being
referenced at the top of the .cpp file for FastSPI:
#if defined(ARDUINO) && ARDUINO >= 100
#include “Arduino.h”
#include “WProgram.h”
#include “wiring.h”
I do have a #define ARDUINO 101 line in the main program’s .cpp file, not in FastSPI’s .cpp file. Should it be in
both? This same if-eval is also in FastSPI’s .h file …

10/27/2014 8:01 PM

Tutorial: Using Atmel Studio 6 with Arduino projects | EngBlaze

7 of 10

I’m starting to think this is more hassle than it’s worth.

on September 26, 2012 at 12:40 am said:

Seems greater than and lesser than signs are being filtered. Trying with actual HTML codes:
#if defined(ARDUINO) && ARDUINO >= 100
#include “Arduino.h”
#include “WProgram.h”
#include <pins_arduino.h>
#include “wiring.h”

on September 26, 2012 at 8:08 am said:

hello Sir,
i have done all the setting you explained. its realy very nice to use the fetchers of the arduino in avr studio 6. But i have some
1) If i am using this, can i use those pin which is not given to use in the arduino?
2) Can i use the Pin change interrupt and all 8 external interrupt?
3) can we do coding like before in studio 6 and just use the fetchers of arduino?

on January 13, 2013 at 10:18 pm said:

Hi ismail, some quick answers:
1. Yes, you can use any pin on your AVR of choice. You’ll just have to use normal C code to manipulate those pins
rather than the Arduino read/write functions.
2. Yes.
3. Absolutely – you can mix and match as you please, but if you use the Arduino libraries, you’ll need to structure your
project according to their rules ( with setup() and loop() rather than main() ).

on October 9, 2012 at 12:26 am said:

This is a great tutorial, and it worked great up until I tried to upload it to my Arduino Uno. I think that the problem is when setting
up the Tools connection. At first when I pasted the line into the arguments box and fixed the com port, an error came up saying:
“can’t open config file “C:\dev\arduino-1.0.1\hardware/tools/avr/ect/avrdude.conf” : No such file or directory
So I changed the path in that line to where I stored the file, in this case the line now reads:
-CD:\MyDocs\Documents\arduino\arduino-1.0.1\hardware/tools/avr/etc/avrdude.conf -v -v -patmega328p -carduino -P\\.\COM4
-b57600 -D -Uflash:w:”$(ProjectDir)Debug\$(ItemFileName).hex”:i
It connects to the arduino because when I select the tool, the lights on the board blink, but the program won’t load and an error

10/27/2014 8:01 PM

Tutorial: Using Atmel Studio 6 with Arduino projects | EngBlaze

8 of 10

comes up saying:
avrdude.exe: stk500_getsync(): not in sync: resp=0×00
If anyone can help with this I would greatly appreciate it.

on January 13, 2013 at 10:15 pm said:

Sometimes avrdude has trouble resetting the board so that it will accept new code. Try hitting the reset button as you
activate the upload command. Does it make a difference?

on November 14, 2012 at 11:31 am said:

Excellent tutorial, thank you very much! I helped me to get through the whole thing (almostI) flawlessly and now I’m happy to
back in my beloved VisualStudio with the Arduino
The only problem I had:
- Error message after first attempt to flash, saying
“avrdude.exe: stk500_getsync(): not in sync: resp=0×00″
- Couldn’t do the “verbose upload” in Arduino IDE (error message:)
avrdude: usbdev_open(): did not find any USB device “usb”
The solution was:
- open \arduino-1.0.2\hardware\arduino\boards.txt
- find the board I’m using (Arduino Ethernet)
- see that ethernet.upload.speed is 115200
- change upload speed in arguments for avrdude from -b57600 to -b115200
Again, thank you for that great tutorial!!!

on November 26, 2012 at 11:07 pm said:

Hi Phil, thanks for the kind words and the tip. I didn’t realize that the Ethernet had a default baud rate of 115200 despite
it using the AtMega328 chip. I’ll update the tutorial to reflect that. Thanks again!

on December 9, 2012 at 9:05 am said:

Hi, I already tried to complete these steps three times and it isn’t building.
Could you help me?
make: *** [prim_proj.elf] Error 1
Done executing task “RunCompilerTask” — FAILED.
Done building target “CoreBuild” in project “prim_proj.cppproj” — FAILED.
Done building project “prim_proj.cppproj” — FAILED.
Build: 0 succeeded or up-to-date, 1 failed, 0 skipped

10/27/2014 8:01 PM

Tutorial: Using Atmel Studio 6 with Arduino projects | EngBlaze

9 of 10

on January 13, 2013 at 9:47 pm said:

Error 1 simply means that another program called by Make during the build experienced an error. In this case, that
usually means a gcc error, but not always. If you have other details you can post, it would be helpful for diagnosis. More
info here:

Wil B
on December 26, 2012 at 10:50 pm said:

Found this tutorial super-useful, thanks so much! I actually tried to get this up and running in Eclipse first, but ran into problem
after problem using the guidelines currently on the Arduino site. You should write their tutorial too, your writing style is a lot

on December 30, 2012 at 3:24 pm said:

Thanks Wil! Glad you found it useful. We try to post our articles to the community area of the Arduino site, but
sometimes they’re a bit hidden compared to the regular documentation there. We’ll see if we can’t lobby them to feature
us more often

on January 1, 2013 at 3:47 pm said:

What about libcore.a?? there is only 16 MHz, how to change it? get a new core.a?
how to compile all with makefile and change the options what you want by self?

on January 5, 2013 at 11:17 am said:

Hi Michal – Yes, using this method, you have to recompile libcore.a for each different processor that you plan on using.
We know this isn’t ideal, however, getting Atmel Studio to compile the core libraries for each build takes much longer
and can also be finicky to set up. We’re looking into a smoother way of doing it in the future.

on January 9, 2013 at 12:02 am said:

Works great! Thanks!
One possible addition at the end of step 1 in the Compiler and Linker Setup section:
Select “All Configurations” from the Configuration: drop down list to modify both release and debug configurations at the same
From past path headaches, I also unchecked Relative Path and entered the absolute paths to the Arduino libraries.
Your site is now in my bookmarks for AVR’s!

10/27/2014 8:01 PM

Tutorial: Using Atmel Studio 6 with Arduino projects | EngBlaze

10 of 10

on January 13, 2013 at 9:29 pm said:

Thanks ridgelift, great to hear you found it useful! The tip is much appreciated, we’ll make sure that gets included.

10/27/2014 8:01 PM