Developing for the Atmel AVR Microcontroller on Linux

You'll enjoy the programming ease and built-in peripherals of the new generation of microcontrollers. Best of all, with these tools you can develop for the popular AVR series using a Linux host.

Whether you are creating a small Internet appliance, some hardware
instrumentation, data loggers or an army of autonomous robots to do your
bidding, in numerous situations you need the flexibility
of a programmable computer. In many cases, a general-purpose system,
such as the workhorse sitting under your desk, doesn't meet size, cost or
power-consumption constraints and is simply overkill. What you need is
a microcontroller.

This article provides step-by-step instructions for setting up a complete development system
for the Atmel AVR series of microcontrollers, using free software and
Linux. The detailed instructions provided here will allow you to transform your Linux system
into a complete AVR development environment. This article walks you through
all the steps of building, debugging and installing a simple program.

What Is a Microcontroller?

When all the electronic components required to make a central
processing unit (CPU)—instruction decoder, arithmetic/logic unit,
registers and so on—are integrated into a single chip, you have a
microprocessor. When, in turn, you bundle this CPU with supporting
components, memory and I/O peripherals, you've got a microcomputer.
Extending the integration and miniaturization even further, you can
combine all the elements of a microcomputer onto a single integrated
circuit—behold the microcontroller.

The semiconductor industry evolves rapidly, making it difficult
to provide an accurate and complete definition of the term
microcontroller. Consider this: some microcontroller chips have
capacities and clock speeds that surpass the 74KB of
program memory and 4KB of RAM available to the 30kg Apollo
Lunar Module computer. You can expect today's screamer PCs to be
running tomorrow's embedded applications, with the definition of
microcontroller shifting accordingly.

Microcontrollers all have a microprocessor core, memory and I/O
interfaces, and many have additional peripherals onboard. The
specific configuration of a particular chip influences its physical
packaging, number of pins and cost. If you are accustomed to working
with microcomputers, you may feel that microcontrollers are
tight spots. They have a handful of kilobytes of program ROM and
in the area of 256 bytes of RAM. Don't fret though; a lot can be
done in this space, as the MIT Instrumentation Lab
demonstrated when developing the Apollo Lunar Module software that controls
its moon landing, return from the surface and rendezvous in orbit.

AVR Microcontrollers

The AVRs are 8-bit RISC platforms with a Harvard architecture (program
and data memory are separate). Figure 1 details the ATtiny26 AVR chip
internal organization. Like each member of a family, it has its own
particular combination of I/O and peripherals, but it shares a basic
architecture and instruction set with all the other AVRs. The ATtiny26
has 2KB of program Flash memory, 128 bytes of onboard SRAM and EEPROM,
two 8-bit counters and pulse-width modulators, 11 interrupts, 16 I/O
pins spread over two 8-bit ports, an 11-channel 10-bit analog-to-digital
converter and more—all on a single tiny 20-pin DIP.

A number of factors make the AVR microcontrollers a good choice,
especially for beginners. AVRs are:

Easy to code for: AVRs were designed from the ground up to
allow easy and efficient programming in high-level languages, with a particular focus on C.

Easy to program: the combination of onboard reprogrammable
Flash program memory and the in-system programming interface keeps the process of
transferring software to the microcontroller
simple and cheap.

Powerful and inexpensive: AVRs pack a lot of power (1 MIPS/MHz,
clocks up to 16MHz) and space (up to 128K of Flash
program memory and 4K of EEPROM and SRAM)
at low prices. Most AVRs even include additional
peripherals, such as UARTs and analog-to-digital
converters.

Hobbyist-friendly: most of the chips in the AVR family come in easy-to-use
8-, 20-, 28- or 40-pin dual in-line packages (DIPs)
and can be ordered in unit quantities from a number
of distributors.

Figure 1. ATtiny26 Block Diagram

CPU

The processor core, composed of the components in the upper-left
portion of Figure 1, includes elements to read the program memory and
to decode and execute the instructions within that memory. The CPU also can fetch
and store data to and from the EEPROM, SRAM and the 32 registers.
The registers act as extremely efficient storage for 8-bit values
(1 byte), and the ALU (arithmetic/logic unit) can operate directly on each
of the 32 registers. This AVR features a RAM-based stack.
In a few other AVRs, which don't have any SRAM, the stack is
hardware-based, limiting the stack depth to three.

Most instructions take only a single clock cycle to execute, and there
is no internal clock division on AVRs. The CPU fetches and decodes the next instruction as it is executing the current instruction. These
combined facts mean that AVRs can reach performances of nearly 1 MIPS
(million instructions per second) per MHz. With clock rates of up to 16MHz,
you can choose the right balance of speed, power consumption and
electromagnetic noise for your particular application.

Comments

Comment viewing options

AVR microcontrollers is definitely user friendly since the combination of onboard reprogrammable Flash program memory and the in-system programming interface keeps the process of transferring software to the microcontroller simple and cheap.
______texas criminal defense lawyer

I run Ubuntu 8.10 but got troubles when making bin utilities. Giving message "format not a string literal and no format arguments"

Tried to google but one of the thread said it would be dificult to omit. I guess they are wrong but how to solve it is out of my mind. I understand it have something to do with 8.10 using -Wformat=2 and that this flag may give false positives. Any sugestions???

I had a problem with gcc just skipping the busywait() function until i switched off optimization in the Makefile.
This resulted in all LEDs glowing since they were each turned on with approximately 30 clock cycles in between.

A little research showed this popping up for a few other folks trying to build cross-compilers with gcc 4.x. This message on the gcc-help list suggests that libssp is not likely to be needed when compiling for embedded systems, and suggests the expedient of disabling it during configure. The following worked for me:

I am using simulavr version 0.1.2.2 in current Debian testing. In the article you stated, regarding output from simulavr, that "You should see a message to that effect, for example, writing 0xff to 0x0038." I don't get that output from simulavr, I only get the following message for each time through line 71:

Trending Topics

Upcoming Webinar

Getting Started with DevOps - Including New Data on IT Performance from Puppet Labs 2015 State of DevOps Report

August 27, 2015
12:00 PM CDT

DevOps represents a profound change from the way most IT departments have traditionally worked: from siloed teams and high-anxiety releases to everyone collaborating on uneventful and more frequent releases of higher-quality code. It doesn't matter how large or small an organization is, or even whether it's historically slow moving or risk averse — there are ways to adopt DevOps sanely, and get measurable results in just weeks.