Electronics, microcontrollers, and hacks, oh my.

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

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

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.

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/

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”.

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).

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.

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.

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.

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.

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.

Add #include Arduino.h". to the very beginning of your source code.

Compiler and linker setup

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.

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.

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”.

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.

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.

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.

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.

We also need to tell it where to find libcore.a, so add our earlier “arduinoCore” directory under “Library search path“.

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.

Awesome, we’re done with the project setup. Save your settings, and we can get back to the code.

Build your project

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

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.

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.

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).

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!

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:

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.

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.

47 thoughts on “Tutorial: Using Atmel Studio 6 with Arduino projects”

Hi
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.

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?

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 organization.

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 debuts..
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?

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() ).

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:

Using arduino version 1.05, I had the same issue with the uploading using the USB serial loader. I changed -carduino to -cwiring. This is what the 1.05 Arduino environment uses. Go to File/Preferences and in the “Show verbose output during” section, uncheck compilation and check upload. Load using the Arduino environment, scroll to the top of the output window and you can see the arguments to AVRDude.

That was the only materially different switch. Works for me now!

Note that I am using a Mega 2560, so the -p argument is different than what is used for the Uno. Also, since my installation path for Arduino contains spaces, double quotes enclose these arguments.

Another quick note. If you have a serial output window open when uploading, you will get a message like this:avrdude.exe: ser_open(): can’t open device “\\.\COM4”: Access is denied.
Simply close the serial output window.

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=0x00”
– 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

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!

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 clearer 😛

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 🙂

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.

Hi kostbill, The Arduino environment differs from traditional C programming in several key ways – one of which is that it abstracts away the traditional main() function and replaces it with a one-time setup() and continual loop(). In practice, it works just as you describe, and in fact the compiler is creating just such a structure inside a normal main() behind the scenes. The language design team must have thought it would be easier for beginners to understand – not really better or worse in our opinion, but just a syntax difference to be aware of.

Most of these techniques will remain valid for the Due, but because it uses a 32 bit ARM architecture, it has some significant differences vs. the rest of Arduino’s product. You’ll need to flash a generated bin file instead of hex, using bossac.exe. The command will look something like this:

\hardware\tools\bossac.exe --port=%1 -U false -e -w

With that, you can create an External Tool like you did for the hex flashing command to make things easier in the future. Beyond that, the process should work, provided you have your clock speed set properly. We’ll try to do a separate post on the Due sometime soon.

thanks for the tutorial I actually did everything perfectly but I was not able to perform no. 5 under Compiler and linker setup. when I tried to create a new project folder the Atmel Studio could not complete the operation and hence this error:

It looks like the compiler can’t find your LiquidCrystal header file, so either it’s not in the project folder or not linked properly. What does Studio tell you when you try to complete that linking step?

Thank you for the guide. However, I faced a small problem while following through the guide.
I have an Arduino Uno, which runs on ATmega328P, and it turns out that I need a baud rate of 115200, instead of 57600. I’m not sure if this was specific to my case. I basically found the answer herehttp://www.jayconsystems.com/tutorial/atmerpt1/

I had a heckuva time with missing files and in my case it was because one of my libraries was using a C file instead of a CPP file … in that case, I needed to update the search directory listing in the C section of AS6 as well as the CPP section. After that, all worked well.