ATMega32 TWI and SH1106 128x64 OLED Example

The SH1106 is a 132 X 64 Dot Matrix OLED/PLED Segment/Common Driver with Controller manufactured by SINO WEALTH. This chip is applicable for many low cost display. A low cost monochrome OLED display for Arduino is very popular among student and electronic hobbyists. It cost around 2USD. This chip has many communication interface depend on the display manufacturers, 8-bit 6800-series parallel interface, 8-bit 8080-series parallel interface, 3-wire & 4-wire serial peripheral interface, 400KHz fast I2C bus interface. However an SPI or an I2C OLED display module is common due complexity of wiring. An SPI display yield a high speed data transmission and reception compares to the I2C communication interface.

 

 

 

This display is easy to control via an 8-bit micro-controller especially the Arduino. The SSD1306 is its equivalent display controller manufactured by solomon-systech. It contains command and data similar to the old KS0108 display controller.

 

I bought a cheap SH1106 1.3" OLED display from a local electronics component store. It works fine at lower I2C frequency around 100kHz. At higher data rate it become halted. I already tested it with Arduino and PIC16F887 micro-controller. For more detail about configuration and display data sending to this display module please visit this post.

In this example I use my ATMega32 to display text on the SH1106 display. At this time I have problem with the ATMega644P TWI. So I use this smaller memory micro-controller.

Source Code:

1. /*
2. * 10-twi_sh1106.c
3. *
4. * Created: 2/7/2026 5:21:04 PM
5. * Author : Admin
6. */
7. 
   
8. #define F_CPU 16000000UL
9. #include <avr/io.h>
10. #include <util/delay.h>
11. 
    
12. void show_text(void){
13. display_xy(0,0);
14. display_text("ATMega32 SH1106");
15. display_xy(0,1);
16. display_text("TWI Programming");
17. display_xy(0,2);
18. display_text("Microchip Studio");
19. display_xy(0,3);
20. display_text("v.7.0.2542");
21. display_xy(0,4);
22. display_text("1.3 I2C OLED ");
23. display_xy(0,5);
24. display_text("Display Module");
25. display_xy(0,6);
26. display_text("AKI-Technical");
27. display_xy(0,7);
28. display_text("2026/02/08 Sun");
29. }
30. 
    
31. int main(void)
32. {
33. /* Replace with your application code */
34. _delay_ms(1000);
35. display_init();
36. display_clear(0);
37. show_text();
38. _delay_ms(5000);
39. display_clear(0);
40. while (1)
41. {
43. display_clear(0);
44. show_text();
45. _delay_ms(2500);
46. display_clear(0);
47. _delay_ms(2500);
48. display_clear(0xFF);
49. _delay_ms(2500);
50. display_clear(0);
51. show_text();
52. _delay_ms(2500);
53. display_clear(0xAA);
54. _delay_ms(2500);
56. }
57. }
58. 
    

I place its twi.c and oled.c libraries in different files. Click here to download its source file.

Schematic and Simulation

 The ATMega32 run very well at 16MHz and high SCL frequency.

ATMega32 AVR Prototype Board

 

This PCB was offered by PCBWay (pcbway.com).

I have been using PCBWay for many years now. PCBWay fabricate PCBs at low cost, fast processing time for only 24 hours, and fast delivery time using any carrier options. This double side 10cmx10cm can be fabricate at only 5USD for 5 to 10pcs by PCBWay. It's a standard PCB with silk screen and solder mask.

10 PCBs for only 5USD

 

For different size of PCB we can instantly quote on PCBWay website using a zip PCB Gerber file without account.

PCBWay Instant Quote

 Now I create a bigger fonts function to make displaying text more visible.

1. void display_char_8x16(unsigned char x, unsigned char y, char ch){
2. y=y*2;
3. display_xy(x,y);
4. uint16_t temp;
5. ch=ch-32;
6. temp=ch*16;
7. char i=0;
8. for(i=0;i<8;i++) display_data(font_8x16[temp+i]);
9. display_xy(x,y+1);
10. for(i=8;i<16;i++) display_data(font_8x16[temp+i]);
11. }
12. 
    
13. void display_text_8x16(unsigned char x, unsigned char y, char *txt){
14. while(*txt){ display_char_8x16(x,y,*txt++); x=x+8;}
15. }

This example the SH1106 will display ASCII characters and numbers.

Source Code: 

 

1. /*
2. * 10-i2c_sh1106_2.c
3. *
4. * Created: 2/8/2026 7:59:35 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. int main(void)
13. {
14. /* Replace with your application code */
15. _delay_ms(1000);
16. display_init();
17. display_clear(0);
18. display_text_8x16(0,0,"SH1106 I2C OLED");
19. display_text_8x16(0,1,"And ATMega32");
20. display_text_8x16(0,2,"Programming With");
21. display_text_8x16(0,3,"Microchip Studio");
22. _delay_ms(10000);
23. display_clear(0x00);
24. while (1)
25. {
26. display_text_8x16(0,0,"ATMega32 SH1106");
27. _delay_ms(2500);
28. uint8_t h=15;
29. for(uint8_t i=0;i<10;i++) {
30. display_char_8x16(h,1,'0'+i);
31. h+=10;
32. }
33. _delay_ms(2500);
34. h=0;
35. for(uint8_t i=0;i<14;i++) {
36. display_char_8x16(h,2,'A'+i);
37. h+=10;
38. }
39. _delay_ms(2500);
40. h=0;
41. for(uint8_t i=0;i<14;i++) {
42. display_char_8x16(h,3,'N'+i);
43. h+=10;
44. }
45. _delay_ms(10000);
46. display_clear(255);
47. _delay_ms(10000);
48. display_clear(0);
49. _delay_ms(1000);
50. }
51. }
52. 
    

Click here to download this example. 

Running Program on ATMega32 Prototype Board

The schematic is the same to previous example. 

There two on-board TWI devices, a ds1307 and a AT24L16B. So the MCU will read the RTC data from ds1307 and display it on the SH1106 OLED. Two ADC inputs, ADC0(PA0) connects to a POT, and ADC1(PA1) connects to the LM35 temperature sensor. However the LM35 was a fake TO-92 chip. Time to time it burned out due to heat dissipation.

 

Proteus has only a model for the SSD1306 that almost equivalent to the SH1106. However its simulation speed is very low compare to the parallel port base graphical LCD. But running this program using a real MCU and OLED it operate very well due to the high speed MCU  and SCL clock frequency.

To add any floating point value to a string we need to configure some parameters in the Microchip Studio IDE before compiling.

 

 

The linker flag is  -lprintf_flt . Click save and close it before building the project.

Source Code:

1. /*
2. * twi.c
3. *
4. * Created: 2/4/2026 10:22:02 AM
5. * Author: Admin
6. */
7. 
   
8. #define F_CPU 16000000UL
9. 
   
10. #include <avr/io.h>
11. #include <util/delay.h>
12. 
    
13. void twi_init(void){
14. TWSR|=0x01; //Prescaler Selection Bit
15. TWBR=0x05; //Baud Rate Generator
16. TWCR=(1<<TWEN); //Enable The TWI Module
17. PORTC|=(1<<0);
18. PORTC|=(1<<1);
19. }
20. 
    
21. void twi_start(void){
22. TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
23. while((TWCR&(1<<TWINT))==0);
24. }
25. 
    
26. void twi_write(unsigned char data){
27. TWDR=data;
28. TWCR=(1<<TWINT)|(1<<TWEN);
29. while((TWCR&(1<<TWINT))==0);
30. }
31. 
    
32. unsigned char twi_read(char ACK){
33. if(ACK==0)
34. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWEA);
35. else
36. TWCR=(1<<TWINT)|(1<<TWEN);
37. while((TWCR&(1<<TWINT))==0);
38. return TWDR;
39. }
40. 
    
41. void twi_stop(){
42. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
43. //_delay_us(10);
44. }

I tested this firmware using the AMTega32 on my AVR Prototype Board. However it works on the ATMega16 or the ATMega644P with a proper software configurations. 

 

 

Click here to download its source file. 

 

 

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.