First contact with AVR Studio 5 (beta)

After years of being the lastest (and only) official IDE for AVR microcontrollers, Atmel decided to launch a new version of the famous AVR Studio. Of course between this AVR Studio 5 release (which is still beta) and AVR Studio 4, Atmel tried a new IDE for AVR32 based on Eclipse.
From my point of view the AVR32 Studio based on Eclipse was the best decision Atmel did. It brought something new all the developers that love and use AVR products. The fact is that having an IDE based on Eclipse (which is based on Java) let users run the IDE in several platforms and not only Windows (as AVR Studio 4 did). Moreover, Atmel delivered an AVR32 Toolchain for Windows and Linux, and the lastest one was easily ported to OS X.
The new version of AVR Studio (5) is based on…. Visual Studio! Yes… it can only runs on Windows (don’t try Wine, it’s like trying to drive a new BMW X5 with an old FIAT 600 engine, you will not go very far). But, let’s judge it by  how it works, and not how it was constructed.

As you might image when listening that it was based on Visual Studio, the ASM/C/C++ compiler is integrated with the instaler. And also the software framework, even though this last one is only available for AVR32 and the XMega series. There is no ASF for the 8bit family (yet).

Once the project is created, everything is very similar to AVR Studio 4. May be this is one of the reason why Atmel choose Visual Studio instead of Eclipse for the new IDE.

At a glance there are a few interesting things that were necessary to have. For example, you can import an AVR Studio 4 project into this new IDE.

As it happens with AVR32 Studio (based on Eclipse) you have a few predefined code snippets, and can add yours.

The project properties panel is more complete, you can choose different microcontrollers, and configure the toolchain in the same way you do it with Eclipse (for AVR32)

To sum up, AVR Studio 5 it’s a better IDE than Studio 4, it’s not perfect or portable to other platforms, but it gives me a good impression.

AVR32 Software Framework Drivers: USART

As we get into AVR32 programming it’s unavoidable to use drivers from the software framework. First because we are not going to reinvent the wheel every time we want to start a new project, then because they are fully tested and documented. Moreover, they provide code-compatibility between several AVR32 families (UC3A, UC3B, UC3L, AP7…)
I thought that a good first approach to AVR32 software framework was using and understanding the USART. The USART is essential for those who don´t have a JTAG for debugging (I know, it’s not too expensive, but may be for a student or somebody that just want to test the platform) because you can send debug content to your Mac/PC using the serial port (this means using the USART in UART mode).
Our first program will be an UART echo program. This means that it will echo every character sent from the PC. We will learn a few things about AVR32 and how to code with this example, more than be can imagine at first.
First of all, ensure you have the lastest version of AVR32Studio and AVR32 Software Framework. Both available and for free at Inside AVR32Studio create a “New AVR32 C project from template”.

In the template you will choose your board/mcu configuration. In this case, I will use EVK1101 as the board, and AT32UC3B0256 ad the MCU.

Once the project is configured we will select the Software Framework drivers that we will use.

Once the Software Framework drivers are selected, replace your main.c with main.c (USART)
Let’s take a close look to the code:
First of all we will include the header files from the framework that we will use, this includes the AVR32 IO definition, GPIO, USART and Power Manager.

// Include Files
#include <avr32/io.h>
// EVK1101
#include "board.h"
// Drivers
#include "power_clocks_lib.h"
#include "gpio.h"
#include "usart.h"

then we will define the frequency for the PBA, which USART we will use, and which GPIO pins we will be connected to that UART

#define TARGET_PBACLK_FREQ_HZ FOSC0  // PBA clock target frequency, in Hz
// Usart Pins compatible with EVK1101
#define MY_USART               (&AVR32_USART1)
#define MY_USART_RX_PIN        AVR32_USART1_RXD_0_0_PIN
#define MY_USART_TX_PIN        AVR32_USART1_TXD_0_0_PIN

in the main function we will configure the GPIO pins. this is done by creating a variable of type gpio_map_t which includes the pin and its function.

	static const gpio_map_t MY_USART_GPIO_MAP = {

then we set up the UART parameters, this includes the baudrate, parity and stop among others.

	static const usart_options_t MY_USART_OPTIONS = { .baudrate= 57600, .charlength= 8,
			.paritytype= USART_NO_PARITY, .stopbits = USART_1_STOPBIT,
			.channelmode = USART_NORMAL_CHMODE };

next we configure the Power Clock in order to use the crystal connected to OSC0.

	pcl_switch_to_osc(PCL_OSC0, FOSC0, OSC0_STARTUP);

We need to tell the GPIO module that it must assign the GPIO pins to the USART


For enabling the UART the framework provides a function for initializing in RS232 mode


And last, but not least, you can see in this few lines of code how to write and read from the UART

	usart_write_line(MY_USART, "This is an echo program)n");
	while(1) {
		c = usart_getchar(MY_USART);

The AVR32 UC3B Platform

The AVR32 is not only a microcontroller, it’s a complete development platform that works smoothly on Linux and Windows, and may be OSX without too much pain. By development platform I mean having an IDE not only for building projects, but also for managing them (version control, plugins that support development, built-in programmer and debugger), a programmer that requires few external components, and a good compiler (if possible in C/C++).  If you found a platform with all these positive points, for free, and all the tools provided by the  manufacturer, then you will enjoy programming on this platform. Atmel provides all these things and a software framework that let you reach your time to market faster.
Basically the fact that Eclipse was the IDE choosen by Atmel for developening over AVR32 plus the software framework where the things that motivated me to start learning about this new version of AVR. Moreover, the microcontroller is not a mid-range AVR, but a full 32bit MCU capable of running Linux, or a small RTOS, delivering nearly 83DMIPS at 60MHz using 3.3V and 23mA.
My starting MCU is the AT32UC3B0256 which has the following features:

  • 256Kbytes of Flash
  • 32Kbytes of SRAM
  • 83 Dhrystone MIPS at 60MHz
  • 44 I/O pins in a 64 pins TQFT package
  • USB 2.0 Full Speed and On The Go

A very basic diagram shows how things are connected in the AVR32 UC3B.

Recently Atmel annouced a new member of the UC3B family, the AT32UC3B0512, which has 96Kbytes of SRAM and 512Kbytes of Flash in the same TFQF64 package.
My first steps in this platform are guided by the ATEVK1101 which is an evalutation kit for the AT32UC3B. This kit allows a rapid and friendly development without the need of dealing with a SMD component and a custom PCB.

The AVR32 Studio IDE can be found at:
For programming the AVR32 using the USB DFU (we need Flip:
And last but not least, Atmel provides a toolchain of GCC for compiling apps:
So let’s get started with a simple Hello World project…