Introduction to programming AVR devices in C using AVR studio

Prepared by

A.V.Microtech
Noida (India)
Rev A-1001110
Software packages
You will need functional installation of the following packages.

1) AVR studio
Source Atmel Website :- Installs as ICON

Sreenshot of AVR studio. It comes with a good set of documentation found under Help

2) WinAVR
Source sourceforge.net

The package includes:-

AVR-GCC free GNU c-compiler

AVRdude free AVR flash downloader

To check successful install

Type “avr-gcc” at command prompt and you get (avr-gcc: no input files)

Type “avrdude” at command prompt and you get a list of avrdude flags.

The avrdude documents can be found at C:\winAVR-YYYYMMDD\doc\avrdude\avrdude.pdf

Hardware details

Bootloader:- Microcontrollers like Atmega328p have a portion of flash that can be programmed
with bootloader code to auto download hex program into the main flash (0000 onwards). The
bootloader behave as though you have an in-circuit programmer between your PC and the
atmega328 board.

Upon hardware reset program counter jumps to the start of bootloader. The bootloader waits for
approx 2 sec for the PC (infact avrdude) to establish communication and if no sync character
received in 2 sec, it jumps to 0000 to start executing the code. The bootloader that Arduino board
comes programmed with can only communicate with avrdude.

Fuses :- From the Atmega328 datasheet you can see that it has configurable fuses which decide on
various runtime configuration. For example you can run it from internal clock or various types of
external clocks. Please do not change fuses when operating from bootloader.

We will use USB atmega328 board as shown in picture above. This board works with Arduino and
with a simple customization, seamlessly with AVR studio.

The Arduino environment (IDE) controls DTR signal and with boards having the DTR tied to reset
pin of atmega328, it is easy to bring the device into bootloader when required.

AVR Studio. AVRstudio by default uses STK500. Hence to download data we must come out
from AVR studio and activate avrdude to help us download data into atmega328. For this we will
write a batchfile in the default sub folder of the project directory. The reason being that AVRstudio
C project, keeps its hex file in a subfolder named default. The batchfile content are as below

avrdude -P com1 -b 57600 -p m328p -c AVRISP -F -e -U flash:w:firstcblinky.hex

Shown in the picture is default sub folder of our project “FirstCblinky”

Further we will use a simple hardware configuration to lock the bootloader permanently so that we
do not have the limitation of 2 sec. To enter into locked bootloader mode we will jumper the
Arduino pin12 with RESET as shown in figure below. Upon activating the reset button the
atmega328 will enter into bootloader indefinitely till either code is downloaded or the jumper is
removed.
AVRdude Programmer

The Atmega328 board can also be converted into programmer. Arduino 0018 comes with a sketch
called “Arduino ISP” that converts the board into avrdude USB programmer identified as avrisp
by avrdude. The default baud rate is 19600.

After downloading the Arduino ISP sketch please remove “AUTO” jumper and change the
adjacent jumper from AR to P as shown in picture below. Removing AUTO jumper will prevent
the board into entering bootloader unnecessarily.

Please note this is a complete programmer and can do any modification to Fuse and lockbits. You
can again create a batch file to execute your commands repeatedly.

avrdude -P com1 -b 19600 -p m328p -c AVRISP -F -e -U flash:w:firstcblinky.hex

A typical C program is as shown below:-
******************************************************************************************************

#define F_CPU 16000000

#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <avr/eeprom.h>
#include <math.h>
#include <stdio.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>

//function declaration

void PortInit(void);

int main(void) // Main entry into the program

{
PortInit();
uint8_t b; //(8 bit variable just like int a;)
double d;
b = 0b01010101;

while(1) // Loop to run continuously

{
d = 5000;
while(d>0){d = d-1;}
PORTB = b;

d = 5000;
while(d>0){d = d-1;}
PORTB = ~b;

}
}

void PortInit(void)
{
DDRB = 7; //Set port B
}

****************************************************************************************************
int main(void) is the main entry point and is a must for every WinAVR C program. While(1) is a non
terminating loop to keep running untill the reset is pressed.

Port registers are addressed direct (sfr_defs.h). The AVR registers from R1 to R32 are however not
available. In similar way some of the useful instructions like SETB and CLRB also seems to have been lost
but are offered in more usefull way through a mechanism like
PORTB |= _BV(PB1) for sbi (sfr,bit)
PORTB &= ~(_BV(PB1)) for cbi(sfr,bit)

Another C program showing the usage of Interrupts.

#define F_CPU 16000000

#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <avr/eeprom.h>
#include <math.h>
#include <stdio.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>

//#define DDRD _SFR_IO8(0x11)

void PortInit(void);
void TimerInit(void);

int main(void)
{
PortInit();
TimerInit();
uint8_t b;//(8 bit variable just like int a;)
//double d;
b = 0b01010101;

while(1)
{
if ((PINB & 1) == 1){

b = ~b;
//b = b & 0b11111110;
PORTB = b & 0b11111110;
}

}
}

void PortInit(void)

{
DDRB = 0b00001111;

ISR(TIMER1_OVF_vect)
{
TCNT1H = 0xF0;
TCNT1L = 0x00;
PORTB |= _BV(0);

void TimerInit(void)
{
//TCCR1A
TCCR1B = 0b00000101;
TIMSK1 |= _BV(0);
sei();

}
 Attiny2313 based Character LCD controller
Index
 Introduction page 1
 SPI LCD controller page 2
 Serial LCD controller page 3
 WinAVR C code (atmega328) page 4
 Arduino code page 9
Connecting LCD display is one of the complex interconnection in
a microcontroller project and taking up valuable I/O for small
devices like Atmega168/328. This controller works in two modes
as shown in the pictures below. The Serial mode can be
connected using the Tx out of microcontroller only.

This controller works by using hex code 250 to differentiate

between writing instruction register and data register. Using two
consecutive bytes, hex 250 followed by instruction data byte will
write to instruction register of the LCD. Every data to be sent to
Instruction register must be constructed this way using two bytes.
For Example:-
First command
Serial.write(CR); //where CR is defined as 250
Serial.write(L1);

Second command
Serial.write(CR);
Serial.write(L2);

Any data without hex 250 will be sent to data display register.
The display data (data register) can be send as continuous string.
 sprintf(c,"CPU Temp %u%cC ",analogRead(8)/2,0xdf);
Serial.print(c);

This way you can also re-initialize the LCD display from your
code as shown in the Arduino sketch below. The controller has
been tested with many 16x2 LCD display from different
manufacturer.
Important :- The configuration change must always be done in power down mode.
The controller cannot change configuration in power up mode.

Notes

1) Move the three jumper to short D0, D1,D2

2) Use D3 as Chip select signal. If you do not have any other SPI device than this can be pulled low
permanently.
3) The backlight resistor is 500 ohm and it works perfectly with new LCD with high efficiency LED
backlight. However this can be sorted also. Infact this was designed for automatic backlight control
using BC547 transistor. Hence you can replace the resistor with BC547 and connect the base to
AVR/PIC PWM output through 2K resistor.
4) The reset button will also reset the AVR device.
Notes

1) Move the three jumper to short B7, B6,B5

2) Pull D2 to ground as it is polled at the start to configure the controller to either serial or SPI
interface.
3) The backlight resistor is 500 ohm and it works perfectly with new LCD with high efficiency LED
backlight. However this can be sorted also . Infact this was designed for automatic backlight
control using BC547 transistor. Hence you can replace the resistor with BC547 and connect the
base to AVR/PIC PWM output through 2K resistor.
4) Connect Tx out of microcontroller to D0.
WinAVR C Code

#define F_CPU 16000000UL

#define CR 250
#define CD 1

#define L1 0X80 //ROW 0 COL 0

#define L2 0XC0 //ROW 1 COL 0

#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <avr/eeprom.h>
#include <math.h>
#include <stdio.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>
#include <avr/wdt.h>
//#include <uart.h>

void ADC_InitA (void);

void PWM_Init (void);
void WDT_off(void);
void WDT_Prescaler_Change(void);
int ADC_Meas(void);
void Comm_write( const char* myval, int b);
void Comm_Transmit( char myval, int b);
void SPI_MasterInit(void);
void SPI_MasterTransmit(char cData);
void USART_Init( );
void USART_Transmit( unsigned char data);

int main(void)
{
USART_Init();
SPI_MasterInit();

int d, b;
char c[30] ;
//************************
//b = 0 for serial
//b = 1 for SPI
b = 1;
//******************************
//Clear Display
USART_Transmit( CR );
_delay_us(50);
USART_Transmit( CD );
_delay_us(50);

d = 0;
while(1){
d++;

Comm_Transmit( CR,b );
_delay_us(50);
Comm_Transmit( L1,b );
_delay_us(50);
sprintf(c,"Good welldone!!");
Comm_write( c,b );

Comm_Transmit( CR,b );
_delay_us(50);
Comm_Transmit( L2,b );
_delay_us(50);
sprintf(c,"The Value - %u%cC. ",d, 0xdf);
Comm_write( c,b );

if (d>9){
d = 0;
}

_delay_ms(500);

void USART_Init( )
{
/* Set baud rate */
UBRR0H = 0;
UBRR0L = 103;
UCSR0A &= !(1<<U2X0);//U2X0 = 0
/* Enable Receiver and Transmitter */
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
//UCSR0B = _BV(TXEN0) | _BV(RXEN0);
/* Set frame format: 8data, 1stop bit */
UCSR0C = (3<<UCSZ00);
//OSCCAL = 0XB0;

void USART_Transmit( unsigned char data )

{
 /* Wait for empty transmit buffer */
//! Not. And USCRA with the bit position UDR0E
while ( !( UCSR0A & (1<<UDRE0)) );
/* Put data into buffer, sends the data */
UDR0 = data;
}

void Comm_write(const char* myval, int b)

{
int a = 0;
while (a<strlen(myval)){
if (b == 0){
USART_Transmit(myval[a]);
a++;}
if (b > 0){
SPI_MasterTransmit(myval[a]);
a++;}
}
}
void Comm_Transmit( char myval, int b)
{
if (b == 0){
USART_Transmit(myval);
}
if (b > 0){
SPI_MasterTransmit(myval);
}

void SPI_MasterInit(void)
{

/* Set MOSI and SCK output, all others input */

DDRB |=(1<<PORTB2)|(1<<PORTB3)|(1<<PORTB5);//Keep portb2 as output
PORTB = (1<<PORTB4);
/* Enable SPI, Master, set clock rate fck/16 - SPR0 = 1, fck/64- SPR1 = 1*/
SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
}

void SPI_MasterTransmit(char cData)

{
/* Start transmission */
SPDR = cData;
/* Wait for transmission complete */
while(!(SPSR & (1<<SPIF)))
;
_delay_ms(1);
}
Note:- You may receive new Arduino sketch without the need of HEspi
library(no library will be sent). This is just for the convenience of the user
as otherwise you have to ensure that the library is installed on all the
machines that you are working on. We have retained the code below just
to show the library usage.

Arduino Sketch

Requirement:-

HEspi Library to setup the SPI communication. Please note that the library does not assert any
chip_select . Hence the same library can control many SPI connected device by asserting the pins using
Digital I/O.

//***************************************************
#include <avr/io.h>
#include <stdlib.h>
#include <HEspi.h>

/*LCD CONTROL
CONTROL CHARACTER DECIDED BY INTERNAL OPERATION OF
ATTINY2313 SPI LCD / RS232 CONTROLLER
T0 SEND CONTROL CHARACTERS.
Serial.write(CR);
Serial.write(CD);
OR
Comm (CD,0) (0 for SPI and 1 for RS232)

SEND ASCII 250 AND THEN ANY CONTROL CHARACTER */

#define CR 250 //TO ACCESS CONTROL REGISTER

/*SEE PAGE 191,192,193 OF HITACHI LCD CONTROLLER HD44780 DATSHEET

0 0 0 0 0 0 0 1 */
#define CD 1 //CLEAR DISPLAY

//1 ADD ADD ADD ADD ADD ADD ADD

#define L1 0X80 //ROW 0 COL 0
#define L2 0XC0 //ROW 1 COL 0

// 0 0 0 0 1 D C B
#define CBY 0X0F //CURSOR ON BLINK ON 00001DCB
#define CBN 0X0C //CURSOR 0FF BLINK 0FF
int RCByte;
int TCByte = 0xff;
int mv = 0;
char c[30];
HEspi myspi;
void setup()
{
Serial.begin(9600);
pinMode(6,OUTPUT); //To SPI LCD
pinMode(7,OUTPUT); //To SPI I/O Board.
digitalWrite(7,HIGH);
digitalWrite(6,LOW);
LCD_Reset(0);
LCD_Reset(1);

void loop() // run over and over again

{

digitalWrite(7,HIGH);
digitalWrite(6,LOW);

myspi.write(CR); // | Alternate |
myspi.write(CD); // | Comm(CD) |

Serial.write(CR);
Serial.write(L1);

myspi.print("HobbyElectronic");
sprintf(c,"Trimmer Val %u%% ",analogRead(0)/10);
Serial.print(c);
myspi.write(CR);
myspi.write(L2);
Serial.write(CR);
Serial.write(L2);

myspi.print("support LCD 1");

//Serial.print("support LCD 2");
//
sprintf(c,"CPU Temp %u%cC ",analogRead(8)/2,0xdf);
Serial.print(c);

delay(500);

myspi.write(CR);
myspi.write(CBN);

//digitalWrite(6,HIGH);
//digitalWrite(7,LOW);
 ////BLINK LED CONNECTED TO ATTINY2313 SPI OPTOISOLATED I/O BOARD
//for (int i=0; i <= 5; i++){

//TCByte = 0;
//RCByte = myspi.Transmit(TCByte);
//delay(500);

//TCByte = 0XFF;
//RCByte = myspi.Transmit(TCByte);

//delay(500);
//}

void LCD_Reset(uint8_t inter) //inter is for interface: 0 for SPI: 1 for RS232
{
Comm(0b00110000,inter);
delay(5);
Comm(0b00110000,inter);
delayMicroseconds(100);
Comm(0b00110000,inter);
Comm(0b00111000,inter);
Comm(0b00001100,inter);
Comm(0b00000001,inter);
Comm(0b00000110,inter);

void Comm(uint8_t mval, uint8_t inter){

if (inter == 0){
myspi.write(CR);
myspi.write(mval); }
if (inter == 1){
Serial.write(CR);
Serial.write(mval);
}
}

//****************************************************************
Line follower Infrared sensor

Arduino Sketch
#include <LiquidCrystal.h>
//The test was done with 33K and 10K resistor. The 33K gives longer range
//but 10k is more immune to reflected sunlight i.e in a well lit room.
// but still can give reasonable 4cm distance sensing.

// LiquidCrystal display with:

// rs on pin 12
// rw on pin 11
// enable on pin 10
// d0, d1, d2, d3 on pins 5, 4, 3, 2
LiquidCrystal lcd(10, 9, 8, 5, 4, 3, 2);
int aval1 =0;
int aval2 = 0;
int refval = 0;
int r=0;
int s=0;
int t=0;
char* str1[] = {"CHANNEL A", "CHANNEL B", "CHANNEL C"};
int lf = 0;
int rg = 0;
int st = 0;

void setup()
{
// Print a message to the LCD.
lcd.print(str1[st]);
lcd.print(analogRead(0));
pinMode(12,OUTPUT);
pinMode(13,OUTPUT);
pinMode(11,OUTPUT);
pinMode(7,INPUT);
digitalWrite(12,LOW);
}

void loop()
{
st = 0;
aval1 = 0;
aval2 = 0;
digitalWrite(11,HIGH);
while (st < 10)
{
st++;
digitalWrite(11,HIGH);
delayMicroseconds(10);
aval1 = aval1+analogRead(0);
digitalWrite(11,LOW);
delayMicroseconds(10);
aval2 = aval2+analogRead(0);

}
refval = analogRead(1);
if (abs(aval2-aval1)>refval)
{
digitalWrite(13,HIGH);

}
else
{
digitalWrite(13,LOW);
 }
lcd.clear();
lcd.print(str1[0]);
lcd.setCursor(1,1);
lcd.print("Analog=");
lcd.print(aval2-aval1);
lcd.print(" : ");
lcd.print(refval);
delay(100);
}
 Attiny2313 Twin DC Motor Driver
Robots like line follower require twin differential DC motor driver. This intelligent board does high speed
processing (16Mhz crystal) and reduces the number of I/O and processing overhead otherwise required by
the main CPU ( AVR or PIC ). Free from latchups and resets, this board offers the highest immunity to
electrical noise. This board can support low voltage motors from Tamiya. It can work as standalone fully
functional Robot controller. Like line tracing, obstacle avoidance or light following robot. This board can
also be run from 3.3V to be compatible with ARM devices.
 Web Server

A simple web server that shows the value of the analog input pins, and set Digital
outputs on Attiny23213 Board. In the Demo sketch, only four outputs can be toggled,
however you can easily increase it 8.

This Sketch is currently configured to run on local network. You can plug a straight cable
directly to your PC LAN card. Cross cable is not required (most system can take care of
that).

Kindly ensure that your PC does not use the IP address 192.168.1.110 but another IP
address within the subnet mask 255.255.0.0 for example 192.168.1.120.

The power supply required for arduino board is 6V DC and power required by I/O board
(outputs) is 6V to 12V (DC Power jack). The Wiznet board is supplied with 3.3volts.

Procedure for a proper reset

Hard Reset -> Power off and on.

Soft Reset
1) Press first button on Add on Board (near 5V). This resets Wiznet board
Wait for a few seconds..............
2) Press Reset on I/O board. This resets Arduino 328 board and I/O board.
 Interfacing Bootboard with SD Card

This is a functional hardware to connect Bootboard to an SD card. The card tested

was 128MB Panasonic SD card.

SD card pinout and corresponding Arduino and AVR pins are shown below. AVR
uses SPI interace to communicate with SD card.
A regulator like 78M33 can be used to produce 3.3V required for SD card. The
Mosfet used during trial was 2N7000. You also need 10K resistors as shown in
figure below. The DO pin can be directly connected to AVR MISO as 3.3V is logic 1
for AVR. However all the outputs of AVR (Clock, Chip select and MOSI) must use
level converter as shown below. Resistors based level converter are also
suggested by some, but not yet used by us.
Note :-

Please set CPOL and CPHA in SPI setting very carefully the default value is 0, 0 but
many times configuration 1, 1 is the acceptable one. Read the SD card technical
information carefully.

Please contact your seller if you need any further clarification.

 Arduino as a Programmer

With Arduino release-0018 it is possible to down load

programming sketch in a AVR and use it to burn programs
or bootloaders in other devices. We have tested the sketch
with Atmega8-16 and the size fits in.You will need a standard
6 pin (2x3) ISP cable.
The step by step instruction is as below.

Step 1) Prepare your Arduino as programmer i.e burn a

programming sketch. Connect you programming board to
your PC as you would do normally to burn sketches. Go to
examples and select ArduinoISP (new in Arduino 0018).
Click upload as you do normally to upload the sketch to your
board. After completion your Programmer is ready.
Step 2) Connect the Target Board ( blank AVR )as in picture
below.
Please maintain the direction of programming cable. Further
the pin1 of programmer’s ISP header must match with Pin1
of target board’s ISP header. Move jumper as in picture
above. Auto Jumper can be removed.
Step 3) Select the correct Board in the Arduino IDE (change
the AVR if you are burning Atmega8-16 / 168 etc).
Upon clicking the button you will see the bootloader being
burnt (flashed) in the target board.
Step 4) Remove all the connection and connect the target
board to the PC and down load your famous blinky to test if
all went well.
Jumper configuration