A DIY ATMega32 Prototype Board

Overview

AVR micro-controller is a popular embedded controller for electronic students, engineers and hobbyists. Making a PCB for for micro-controller is exiting stuff for novice electronic practicing. It's is hard at first time but we can easily use it for firmware and circuit testing for later on.

 

I have some components I left a long time ago. So I designed my own test board for 40-pin AVR microcontrollers. I have ATMega644, ATMega32 and ATMega16 in my project box. I also have some USB PIC microcontroller, PIC18F2550. It can be use to make a DIY PICKit2 programmer that able to program any AVR microcontroller using AVRdude IDE. This software is very user-friendly. 

Some AVR micro-controller users prefer a USBasp or an FTDI chip with AVRdude to program this these chips. But currently I don't have them at my workshop. 

Schematic 

I use Protues VSM since it's easy to use for circuit and PCB design. I put some blocks on this board,

1. A PICKit2 programmer and AVR ISP header
2. A On-board 12VDC to 5VDC regulator
3. A RS-232 to TTL converter
4. A Reset button and external crystal oscillator
5. Three buttons for ATMega32 external interrupts
6. LED(s) with DIP switch connects to PORTC
7. SPI header
8. Two potentiometers for ADC input
9. DIP switch for ADC configuration
10. A DS1207 I2C RTC 
11. A  40-pin ZIF socket for ATMega32, ATMega16, etc.

 The pictures below are its circuit diagram.

Schematic Sheet #1

Schematic Sheet #2

Schematic Sheet #3

 It contains three A4-size sheets.

Printed Circuit Board (PCB)

This PCB is quite large (173.7 x 111.2mm(6.84 x 4.38 inches). We can fabricate it by hand using a simple tone transfer paper method because it contain a dozen of wire jumpers on top copper layer.

Top Copper Layer

Bottom Copper Layer

 I you prefer a simple tone transfer method, use the patterns below.

Top Copper Layer

Bottom Copper Layer

Top Silk Layer

Bottom Resist Layer

 Some PCB fabrication could fabricate it for around 40USD.

However I made the earlier version of this board by hand using a simple toner transfer method and and FR-4 copper clad board. I use ferric chloride acid to etch the copper clad. It's very low cost and fast. 

 

 Click here to download this PCB project.

Atmega32 EEPROM Programming Example

There are two main memory spaces in Atmega32 microcontroller, the Data Memory and the Program Memory space. An additional EEPROM Memory is useful for data storage. It's non-volatile. Hence this controller has three memory space. They are linear and regular.

EEPROM memory space contains up to 1024 bytes of data. It's separated from data space. It's single byte readable and writable. It endurance is up to 100,000 write/erase cycles. Its access time is around 8.5ms for the internal RC clock of 1MHz.

During the device is in power-down sleep mode, the EEPROM write operation still continuous. But it's not completely power down. So the the programmer must verify the EEPROM first before setting the device to entirely power-down mode.

EEPROM corruption can occur whenever the supply voltage is too low, that the instruction execution is incorrect. We can prevent it by enabling the internal Brown-out Detector (BOD). If the BOD can not help ,we can add an additional VCC reset Protection circuit. 

For low level programming like the Assembly language, the programmer must use the I/O and Peripheral Register. However in C programming for the AVR it's invisible for the programmer.

There are some registers that we have to use before accessing the EEPROM memory.

The EEPROM Address Register – EEARH and EEARL

The address register is a 16-bit pair. But it has only 10-bit in use. So it's 10-bit (1024) address. The user can access up to 1024 bytes of EEPROM memory.

The EEPROM Data Register – EEDR

The data register is single byte read/write.

The EEPROM Control
Register – EECR

This memory contains,

• Bits 7..4 – Reserved Bits
• Bit 3 – EERIE: EEPROM Ready Interrupt Enable
• Bit 2 – EEMWE: EEPROM Master Write Enable
• Bit 1 – EEWE: EEPROM Write Enable
• Bit 0 – EERE: EEPROM Read Enable

For AVR Lib-C for AVR device, we don't need to care about these registers. the programmer can use the eeprom.h library, and call its read and write function to access the EEPROM memory.

In this programming example we will use all these registers. The example below will show a simple way to access the internal EEPROM.

Program Simulation

The controller will read and write the internal EEPROM data. The data will display on PortC.

/*
 * m32Eeprom.c
 *
 * Created: 7/20/2022 6:43:00 PM
 * Author : desktop
 */ 
 
#include <avr/io.h>
 
/*Write button connects to PD6*/
#define writeButton ((PIND&0x40)==0)
/*Read button connects to PD7*/
#define readButton ((PIND&0x80)==0)
 
/*EEPROM Write Function*/
void eepromWrite(unsigned int addr,unsigned char dat){
	/*Wait for completion of previous write*/
	while(EECR&(1<<EEWE));
	/*Set up address and data registers*/
	EEAR=addr;
	EEDR=dat;
	/*Write logical 1 to EEMWE*/
	EECR|=(1<<EEMWE);
	/*Start eeprom write by setting EEWE*/
	EECR|=(1<<EEWE);
}
 
/*EEPROM Read Function*/
unsigned char eepromRead(unsigned int addr){
	/*Wait for completion of previous write*/
	while(EECR&(1<<EEWE));
	/*Set up address register*/
	EEAR=addr;
	/*Start eeprom read by writing EERE*/
	EECR|=(1<<EERE);
	/*Return data from data register*/
	return EEDR;
}
 
int main(void)
{
	/*PORTC Output*/
	DDRC=0xFF;
	/*PA0...PA3 Input*/
	DDRA=0xF0;
	/*PORTB Input*/
	DDRB=0x00;
	/*Turn on porta and portb high*/
	PORTA=0x0F;
	PORTB=0xFF;
	/*Turn on PD6 and PD7*/
	PORTD=(1<<6)|(1<<7);
    while (1) 
    {			
		/*eeprom read task*/
		if (readButton)
		{
			/*Wait until the button released*/
			while(readButton);
			PORTC=eepromRead(PINA);
		}
		/*eeprom write task*/
		if (writeButton)
		{
			/*Wait until the button released*/
			while(writeButton);
			eepromWrite(PINA,PINB);
		}
    }
}
 
 

Click here to download its source file.

Schematic

PortA is used for address input. We use only four bits that contain up to 16 addresses.  PortB is used for data input for internal EEPROM writing. Write button connect to PD6 pin while read button connect to PD7 pin. PortC connects to a bar graph LED to display the data reading from internal EEPROM.

 

If you want a standard PCB for ATMega32 micro-controller, you can order my AVR Microcontroller project from PCBWay with a reasonable price. Click here to get a free $5 credit for new account.

Atmega32 Timer/Counter1 in Counter Mode

The Timer/Counter1 module of Atmega32 is able to count external pulse. It has a 16-bit counter/timer registers pair, TCNT1H and TCNT1L. We need to select its clock source of the Timer/Counter1 Control Register B - TCCR1B to allow this module working in external event counting mode. It work in two clock transitions, falling edge and rising edge. The clock source must be point to T1 (PB1) pin.

Running program in Proteus Simulator

It also have a pre-scaler to divide a number of input clock pulse. Basically I will need only the TCCR1B, TCNT1H, and TCNT1L register to make this module operate in external counting mode.

• Timer/Counter1 Control Register B - TCCR1B

Timer/Counter1 Control Register B - TCCR1B

I need to select clock select bits to allow it to work in counter mode, with a rising edge of external clock.

Clock Select Bit Description

I choose the "External clock source on T1 pin. Clock on rising edge". So CS12, CS11, and CS10 will set.

• Timer/Counter1 - TCNT1H and TCNT1L Register 

Timer/Counter1 – TCNT1H and TCNT1L Registers

This register composes of two 8-bit registers pair, TCNT1H and TCNT1L. They are readable and writable.

In this example, I make a counting system that could count up to 10000 before it rolls down. Since this register is 16-bit it maximum value is 65536 values. But it's not necessary here.

/*
 * m32Counter1MuxDisplay.c
 *
 * Created: 7/9/2022 6:10:41 PM
 * Author : aki-technical
 */ 
 
#include <avr/io.h>
 
#define F_CPU 4000000UL
#include <util/delay.h>
 
int main(void)
{
    int temp;
    /*Common Cathode Display*/
    unsigned char displayData[10]={0x3F,0x06,0x5B,0x4F,
0x66,0x6D,0x7D,0x07,0x7F,0x6F};
    /*PortB and PortD Output*/
    DDRC=0xFF;
    DDRD=0xFF;
	/*Select T1 Clock in, rising edge*/
	TCCR1B|=(1<<CS12)|(1<<CS11)|(1<<CS10);
	/*Clear Timer/Counter1*/
	TCNT1H=0;
	TCNT1L=0;
    while (1) 
    {
		/*Read the 16-bit counter registers*/
		temp=(TCNT1H<<8)+TCNT1L;
		/*Reset if it reaches 10000*/
		if (temp>9999)
		{
			temp=0;
			TCNT1H=0;
			TCNT1L=0;
		}
 
		/*Display processing*/
		PORTD=0x00;
		PORTC=displayData[temp/1000];
		PORTD=0x01;
		_delay_ms(5);
 
		PORTD=0x00;
		PORTC=displayData[(temp%1000)/100];
		PORTD=0x02;
		_delay_ms(5);
 
		PORTD=0x00;
		PORTC=displayData[(temp%100)/10];
		PORTD=0x04;
		_delay_ms(5);
 
		PORTD=0x00;
		PORTC=displayData[temp%10];
		PORTD=0x08;
		_delay_ms(5);
    }
}
 
 

 Click here to download its source file.

Schematic

Making a Simple Free Running Timer with Multiplexing Display using Atmega32

In previous post, I made a simple multiplexing display example using a two-digit SSD. In this example, I gonna make a free running timer two a two-digit multiplexing seven-segment display. It will start counting from 0 to 999 seconds before it reset by itself.

Program simulation

The display is driven by delay function. Each digits are activated for only 5ms. I use Timer/Counter 0 to create timing tick.

The CPU clock is 4MHz. Clock period is,

1/4000000MHz =  250 nano seconds, or 0.00000025 second.

Timer 0 prescaler is Fosc/1024. So its Timer/Counter 0 period is,

0.00000025 second * 1024 = 256 micro seconds, or 0.000256 second.

The 8-bit TCNT0 register can store counting value up to 256. So the TOV0 occurs every,

256*0.000256 second = 0.065536 second.

To get a one second timing, I need to make a calculation of one second count. That is,

1 second count = (1 second)/(0.065536 second) = 15 counts.

Finally after the 15 counts, I will get a one-second time. Then I will need to reset the counter variable.

/*
 * m32Mux2Counting.c
 *
 * Created: 6/19/2022 3:36:14 PM
 * Author : aki-technical
 */ 
 
#include <avr/io.h>
 
/*Delay function*/
#define F_CPU 4000000UL
#include <util/delay.h>
 
int main(void)
{
    unsigned char temp=0,cnt=0;
    /*Common Cathode Display*/
    unsigned char displayData[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
    /*PortB and PortD Output*/
    DDRC=0xFF;
    DDRD=0xFF;
	/*Select Fclk/1024*/
	TCCR0|=(1<<CS02)|(1<<CS00);
	/*Clear TOV0 flag*/
	TIFR|=(1<<TOV0);
	/*Clear Counter*/
	TCNT0=0;
    while (1) 
    {
		/*Multiplexing Display Process*/
		PORTD=0x00;
		PORTC=displayData[temp/10];
		/*Turn On Digit 1*/
		PORTD=0x01;
		/*Activate for 5ms*/
		_delay_ms(5);
 
		PORTD=0x00;
		PORTC=displayData[temp%10];
		/*Turn On Digit 2*/
		PORTD=0x02;
		/*Activate for 5ms*/
		_delay_ms(5);
 
		/*TOV0 occurs for every 0.065536 second*/
		if ((TIFR)&&(1<<TOV0))
		{
			cnt++;
			TIFR|=(1<<TOV0);
		}
 
		/*One second is equal to 15 counts*/
		if (cnt>=15)
		{
			temp++;
			cnt=0;
		}
		/*Check if it is greater than 99 seconds*/
		if (temp>99)
		{
			temp=0;
		}
    }
}
 
 

Click here to download its source file.

Schematic Diagram