dsPIC30F2010 Software I2C LCD and RTC

Introduction

A dedicated I2C module of a micro-controller including the dsPIC30F2010 is fixed. For instance the I2C1 port pins of the dsPIC30F2010 are RF2(SDA) and RF3(SCL). These pins share with other communication module such as ICSP and UART1. So we need to disconnect them first before setting up a proper communication port connection. However, some modern micro-controllers have a port remapping for communication interface pins.  

 

PCF8574T Software I2C Character LCD

 

On the other hand, the I2C communication protocol is very easy to emulate via software bit-banging method using Assembly, C, or even other high level programming languages. Mikro C offers both hardware and software I2C library routines. We can check its user's manual for details. Here I cut only some key-points:

External dependencies of Software I²C Library

The following variables must be defined in all projects using Software I²C Library:	Description :	Example :
extern sbit Soft_I2C_Scl;	Soft I²C Clock line.	sbit Soft_I2C_Scl at RB11_bit;
extern sbit Soft_I2C_Sda;	Soft I²C Data line.	sbit Soft_I2C_Sda at RB12_bit;
extern sbit Soft_I2C_Scl_Direction;	Direction of the Soft I²C Clock pin.	sbit Soft_I2C_Scl_Direction at TRISB11_bit;
extern sbit Soft_I2C_Sda_Direction;	Direction of the Soft I²C Data pin.	sbit Soft_I2C_Sda_Direction at TRISB12_bit;

Library Routines

• Soft_I2C_Init
• Soft_I2C_Start
• Soft_I2C_Read
• Soft_I2C_Write
• Soft_I2C_Stop
• Soft_I2C_Break

 

The Soft_I2C_Scl and Soft_I2C_Sda must be declared first before we can use the Soft_I2C_Init function. The Software I2C operates at lower clock speed and need more program space (ROM) since it's a purely software communication protocol.

 

dsPIC30F2010 Interfacing and Programming using MikroC

 

We can select any pins of the dsPIC30F2010 to operates a software I2C communication protocol. Here I use RD0 for SCL and RD1 for SDA. I'm not sure about its SCL clock frequency since I don't have an oscilloscope.

Schematic:

 

Schematic

 

In this example a PCF8574T character LCD and a DS3231 Real Time Clock (RTC) chip use a single I2C bus to communication with the master MCU.  The MCU continuous read the RTC data from DS3231 and shows it on the I2C character LCD. The DS3231 timing is very precise since it uses its internal calibrated RC oscillator.

PCF8574T Arduino TWI HD44780 LCD Module

 

Arduino DS3231 High Precision Real Time Clock Module

Arduino DS3231 High Precision Real Time Clock Module

 

The PCF8574T and DS3231 Arduino module are widely used among students and hobbyists due to its low cost and less complexity. 

MikroC Source Code:

1. 
   
2. // Software I2C connections
3. sbit Soft_I2C_Scl at RD0_bit;
4. sbit Soft_I2C_Sda at RD1_bit;
5. sbit Soft_I2C_Scl_Direction at TRISD0_bit;
6. sbit Soft_I2C_Sda_Direction at TRISD1_bit;
7. // End Software I2C connections
8. 
   
9. const char PCF8574_W=0x40;
10. const char PCF8574_R=0x41;
11. const char PCF8574T_LCD_W=0x4E;
12. const char PCF8574T_LCD_R=0x4F;
13. const char PCF8574A_W=0x70;
14. const char PCF8574A_R=0x71;
15. 
    
16. void pcf8574_write(char _data){
17. Soft_I2C_Start(); // issue I2C start signal
18. Soft_I2C_Write(PCF8574T_LCD_W); // send byte via I2C (device address + W)
19. Soft_I2C_Write(_data); // send byte (data address)
20. Soft_I2C_Stop(); // issue I2C stop signal
21. }
22. 
    
23. /*TWI LCD Driver*/
24. #define RS 0
25. #define RW 1
26. #define EN 2
27. #define BL 3
28. 
    
29. #define i2c_lcd_cursor_off() i2c_lcd_command(0x0C)
30. #define i2c_lcd_line_1() i2c_lcd_command(0x80)
31. #define i2c_lcd_line_2() i2c_lcd_command(0xC0)
32. 
    
33. char backLight=1;
34. 
    
35. void i2c_lcd_command(char command){
36. char _data;
37. _data=command&0xF0;
38. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
39. //_delay_us(10);
40. pcf8574_write(_data|(backLight<<BL));
41. //_delay_us(50);
42. 
    
43. _data=command<<4;
44. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
45. //_delay_us(10);
46. pcf8574_write(_data|(backLight<<BL));
47. //_delay_us(50);
48. }
49. 
    
50. void i2c_lcd__data(char command){
51. char _data;
52. _data=command&0xF0;
53. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
54. Delay_us(10);
55. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
56. Delay_us(50);
57. 
    
58. _data=command<<4;
59. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
60. Delay_us(10);
61. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
62. Delay_us(50);
63. }
64. 
    
65. void i2c_lcd_xy(char x, char y){
66. char addr[]={0x80,0xC0};
67. i2c_lcd_command(addr[y-1]+x-1);
68. }
69. 
    
70. void i2c_lcd_text(char *txt){
71. while(*txt) i2c_lcd__data(*txt++);
72. }
73. 
    
74. void i2c_lcd_clear(void){
75. i2c_lcd_command(0x01);
76. Delay_ms(5);
77. }
78. 
    
79. void i2c_lcd_init(void){
80. pcf8574_write(0);
81. Delay_ms(10);
82. i2c_lcd_command(0x33);
83. Delay_us(10);
84. i2c_lcd_command(0x32);
85. Delay_us(10);
86. i2c_lcd_command(0x28);
87. Delay_us(10);
88. i2c_lcd_command(0x0F);
89. Delay_us(10);
90. i2c_lcd_command(0x01);
91. Delay_ms(10);
92. i2c_lcd_command(0x06);
93. Delay_us(10);
94. }
95. 
    
96. void rtc_set(void){
97. char rtc[7]={0x35,0x12,0x17,0x05,0x15,0x10,0x26};
98. char i=0;
99. Soft_I2C_Start(); // issue I2C start signal
100. Soft_I2C_Write(0xD0); // send byte via I2C (device address + W)
101. Soft_I2C_Write(0); // send byte (data address)
102. while(i<7){
103. Soft_I2C_Write(rtc[i]);
104. i++;
105. }
106. Soft_I2C_Stop();
107. }
108. void main(){
109. char temp[7], i = 0, text[16];
110. Soft_I2C_Init(); // Initialize Soft I2C communication
111. 
     
112. Delay_ms(10);
113. //rtc_set();
114. i2c_lcd_init();
115. Delay_ms(10);
116. i2c_lcd_clear();
117. 
     
118. i2c_lcd_text("Software I2C");
119. i2c_lcd_line_2();
120. i2c_lcd_text("PCF8574T DS3231");
121. i2c_lcd_cursor_off();
122. Delay_ms(5000);
123. i2c_lcd_clear();
124. while(1){
125. for(i = 0; i < 7; i++){
126. Soft_I2C_Start(); // issue I2C start signal
127. Soft_I2C_Write(0xD0); // send byte via I2C (device address + W)
128. Soft_I2C_Write(i); // send byte (data address)
129. Soft_I2C_Stop();
131. Soft_I2C_Start();
132. Soft_I2C_Write(0xD1); // send byte (device address + R)
133. temp[i] = Soft_I2C_Read(0u); // Read the data (NO acknowledge)
134. Soft_I2C_Stop(); // issue I2C stop signal
135. }
136. sprintf(text,"Date: %2X/%2X/20%2X",temp[4],temp[5],temp[6]);
137. i2c_lcd_line_1();
138. i2c_lcd_text(text);
139. sprintf(text,"Time: %2X/%2X/%2X",temp[2],temp[1],temp[0]);
140. i2c_lcd_line_2();
141. i2c_lcd_text(text);
142. Delay_ms(800);
143. }
144. }

The sprintf function uses a lot of memory space. We can process the ASCII data one-by-one to save memory space of the MCU.

 

DS3231 and PCF8574T Software I2C Programming

DS3231 and PCF8574T Software I2C Programming

 

I tested this program on my DIY dsPIC30F2010 Prototype Board. 

 

 

For a full software TWI programming examples please see this post. 

 

 

 

dsPIC30F2010 I2C PCF8574T HD44780 LCD

Introduction

In previous post, I use the PCF8574AP DIP-16 chip to expand the output of dsPIC30F2010. Since this chip is an 8-bit bi-directional I/O device, it can be used to connect to any I/O peripheral devices. even an HD44780 character LCD. 

 

Test Program

A character LCD module comes with a PCF8574T is very popular and low cost. It is commonly an Arduino LCD module widely used among the students and electronic hobbyists. There are a lot of Arduino programming examples for this stuffs. 

 

dsPIC30F2010 Simple I2C LCD using PCF8574T 

Controlling an HD44780 character LCD via a PCF8574T is very easy with some additional code to process the 4-bit data transfer mode of the LCD chip controller. In this example, the I2C master micro-controller send some character to a 16x2 character LCD via a PCF8574T chip. 

Schematic:

Schematic

 This post show a full I2C devices interfacing examples using an ATMega644P AVR chip.

MikroC Source Code:

1. 
   
2. const char PCF8574_W=0x40;
3. const char PCF8574_R=0x41;
4. const char PCF8574T_LCD_W=0x4E;
5. const char PCF8574T_LCD_R=0x4F;
6. const char PCF8574A_W=0x70;
7. const char PCF8574A_R=0x71;
8. 
   
9. void pcf8574_write(char _data){
10. I2C1_Start(); // issue I2C start signal
11. I2C1_Write(PCF8574T_LCD_W); // send byte via I2C (device address + W)
12. I2C1_Write(_data); // send byte (data address)
13. I2C1_Stop(); // issue I2C stop signal
14. }
15. 
    
16. /*TWI LCD Driver*/
17. #define RS 0
18. #define RW 1
19. #define EN 2
20. #define BL 3
21. 
    
22. #define i2c_lcd_cursor_off() i2c_lcd_command(0x0C)
23. #define i2c_lcd_line_1() i2c_lcd_command(0x80)
24. #define i2c_lcd_line_2() i2c_lcd_command(0xC0)
25. 
    
26. char backLight=1;
27. 
    
28. void i2c_lcd_command(char command){
29. char _data;
30. _data=command&0xF0;
31. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
32. //_delay_us(10);
33. pcf8574_write(_data|(backLight<<BL));
34. //_delay_us(50);
35. 
    
36. _data=command<<4;
37. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
38. //_delay_us(10);
39. pcf8574_write(_data|(backLight<<BL));
40. //_delay_us(50);
41. }
42. 
    
43. void i2c_lcd__data(char command){
44. char _data;
45. _data=command&0xF0;
46. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
47. //_delay_us(10);
48. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
49. Delay_us(50);
50. 
    
51. _data=command<<4;
52. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
53. //Delay_us(10);
54. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
55. //Delay_us(50);
56. }
57. 
    
58. void i2c_lcd_xy(char x, char y){
59. char addr[]={0x80,0xC0};
60. i2c_lcd_command(addr[y-1]+x-1);
61. }
62. 
    
63. void i2c_lcd_text(char *txt){
64. while(*txt) i2c_lcd__data(*txt++);
65. }
66. 
    
67. void i2c_lcd_clear(void){
68. i2c_lcd_command(0x01);
69. Delay_ms(5);
70. }
71. 
    
72. void i2c_lcd_init(void){
73. pcf8574_write(0);
74. Delay_ms(10);
75. i2c_lcd_command(0x33);
76. Delay_us(10);
77. i2c_lcd_command(0x32);
78. Delay_us(10);
79. i2c_lcd_command(0x28);
80. Delay_us(10);
81. i2c_lcd_command(0x0F);
82. Delay_us(10);
83. i2c_lcd_command(0x01);
84. Delay_ms(10);
85. i2c_lcd_command(0x06);
86. Delay_us(10);
87. }
88. 
    
89. void main(){
90. char temp = 0, i = 0;
91. I2C1_Init(10000); // initialize I2C communication
92. Delay_ms(10);
93. i2c_lcd_init();
94. Delay_ms(10);
95. i2c_lcd_text("dsPIC30F2010 I2C");
96. i2c_lcd_line_2();
97. i2c_lcd_text("PCF8574T LCD");
98. i2c_lcd_cursor_off();
99. 
    
100. while(1){
101. 
     
102. }
103. }

I test this example on my DIY dsPIC30F2010 Prototype Board. It works fine.

 

My DIY dsPIC30F2010 Prototype Board

dsPIC30F2010 5V DVM I2C LCD using PCF8574T 

There is one on-board POT. So I made a simple 5VDC Digital Volt Meter with this I2C LCD. The schematic remains the same a above.

 

Test Program

 

MikroC Source Code:

1. 
   
2. const char PCF8574_W=0x40;
3. const char PCF8574_R=0x41;
4. const char PCF8574T_LCD_W=0x4E;
5. const char PCF8574T_LCD_R=0x4F;
6. const char PCF8574A_W=0x70;
7. const char PCF8574A_R=0x71;
8. 
   
9. void pcf8574_write(char _data){
10. I2C1_Start(); // issue I2C start signal
11. I2C1_Write(PCF8574T_LCD_W); // send byte via I2C (device address + W)
12. I2C1_Write(_data); // send byte (data address)
13. I2C1_Stop(); // issue I2C stop signal
14. }
15. 
    
16. /*TWI LCD Driver*/
17. #define RS 0
18. #define RW 1
19. #define EN 2
20. #define BL 3
21. 
    
22. #define i2c_lcd_cursor_off() i2c_lcd_command(0x0C)
23. #define i2c_lcd_line_1() i2c_lcd_command(0x80)
24. #define i2c_lcd_line_2() i2c_lcd_command(0xC0)
25. 
    
26. char backLight=1;
27. 
    
28. void i2c_lcd_command(char command){
29. char _data;
30. _data=command&0xF0;
31. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
32. //_delay_us(10);
33. pcf8574_write(_data|(backLight<<BL));
34. //_delay_us(50);
35. 
    
36. _data=command<<4;
37. pcf8574_write(_data|(backLight<<BL)|(1<<EN));
38. //_delay_us(10);
39. pcf8574_write(_data|(backLight<<BL));
40. //_delay_us(50);
41. }
42. 
    
43. void i2c_lcd__data(char command){
44. char _data;
45. _data=command&0xF0;
46. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
47. //_delay_us(10);
48. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
49. Delay_us(50);
50. 
    
51. _data=command<<4;
52. pcf8574_write(_data|(backLight<<BL)|(1<<EN)|(1<<RS));
53. //Delay_us(10);
54. pcf8574_write(_data|(backLight<<BL)|(1<<RS));
55. //Delay_us(50);
56. }
57. 
    
58. void i2c_lcd_xy(char x, char y){
59. char addr[]={0x80,0xC0};
60. i2c_lcd_command(addr[y-1]+x-1);
61. }
62. 
    
63. void i2c_lcd_text(char *txt){
64. while(*txt) i2c_lcd__data(*txt++);
65. }
66. 
    
67. void i2c_lcd_clear(void){
68. i2c_lcd_command(0x01);
69. Delay_ms(10);
70. }
71. 
    
72. void i2c_lcd_init(void){
73. pcf8574_write(0);
74. Delay_ms(10);
75. i2c_lcd_command(0x33);
76. Delay_us(10);
77. i2c_lcd_command(0x32);
78. Delay_us(10);
79. i2c_lcd_command(0x28);
80. Delay_us(10);
81. i2c_lcd_command(0x0F);
82. Delay_us(10);
83. i2c_lcd_command(0x01);
84. Delay_ms(10);
85. i2c_lcd_command(0x06);
86. Delay_us(10);
87. }
88. 
    
89. void main(){
90. unsigned int adc_rd;
91. char text[16];
92. long tlong;
93. float voltage;
94. ADPCFG = 0xFFFF; // Configure AN pins as digital
95. I2C1_Init(10000); // initialize I2C communication
96. Delay_ms(10);
97. i2c_lcd_init();
98. Delay_ms(10);
99. i2c_lcd_text("dsPIC30F2010 I2C");
100. i2c_lcd_line_2();
101. i2c_lcd_text("ADC PCF8574T LCD");
102. i2c_lcd_cursor_off();
103. Delay_ms(10000);
104. i2c_lcd_clear();
105. while(1){
106. adc_rd = ADC1_read(4); // get ADC value from 2nd channel
107. voltage = 5.0*adc_rd/1023;
108. i2c_lcd_line_1();
109. sprintf(text,"AN4 ADC: %4d 10", adc_rd);
110. i2c_lcd_text(text);
111. i2c_lcd_line_2();
112. sprintf(text,"Voltage: %.2f V", voltage);
113. i2c_lcd_text(text);
114. Delay_ms(500);
115. }
116. }

 

Using program C sprintf function is very easy to convert any data type into an array of ASCII characters. But it requires a lot of memory space. For limited ROM and RAM space, we can process the text, character, integer and floating point numbers one-by-one before sending it to UART or LCD stream. This post shows a simple number to ASCII character converting.

Archive: 

ADC Read Voltage 0.00 V

ADC Read Voltage 2.74 V

ADC Read Voltage 5.00 V

 See this short video on Youtube:

 

 

 

 

 

 

 

 

 

dsPIC30F2010 I2C and PCF8574 Interfacing using MikroC

Introduction

The dsPIC30F2010 is a 16-bit micro-controller. It means that its internal data bus is 16-bit wide. Additionally its I/O data is also 16-bit wide. However a small foot-print 16-bit MCU like the dsPIC30F2010 has only 28 pins including supply voltage pins, ADC voltage pins, clock pins ,etc. So we can get a full 16-bit input output from its pins.

 

Pin Diagrams

 

To get a full 8-bit or 16-bit external I/O, we need to add any I/O expansion chips. These chips implement the SPI or I2C interface. Here I use the PCF8574 I2C I/O expansion chip. This chip an 8-bit bidirectional micro-processor expansion chip. 

 

The PCF8574 Series 

The device features an 8-bit quasi-bidirectional I/O port (P0–P7), including latched outputs with high current drive capability for directly driving LEDs. Each quasi-bidirectional I/O can be used as an input or output without the use of a data-direction control signal. At power on, the I/Os are high. In this mode, only a current source to VCC is active.

This chip is suitable for,

• Telecom Shelters: Filter Units
• Servers
• Routers (Telecom Switching Equipment)
• Personal Computers
• Personal Electronics
• Industrial Automation
• Products with GPIO-Limited Processors 

PCF8574 Interfacing Diagram

PCF8574AP DIP-16

We can event use this chip for a 4x4 matrix keypad, or driving an HD44780-base character LCD.

 

Pin Configuration and Functions

This device has various package types. A PDIP-16 or a SOIC-16 are common for most of electronics hobbyists.

 

Simplified Block Diagram of Device

This device has an 8-bit customizable slave address with R/W bit.

PCF8574 Interface Definition

 

We can custom its optional slave address via A2...A0 bits. Its default write address when A2...A0 are wired to GND is 0x40.

 

Address Reference

 

The Master I2C device need to write device slave address followed by output port data twice.

PCF8574 Write Mode

To read from this I2C slave device, the microprocessor need to write device read address (eg. 0x41), followed by I2C in read mode.

PCF8574 Read Mode

 

We can use various I/O devices with this chip.

 

PCF8574 Typical Application

 Interrupt Output (INT) pin is optional.

 

dsPIC30F2010 I2C Programming using MikroC

MikroC for dsPIC offer a build-in dedicated and software I2C libraries. Both of them are stable and reliable for most of applications. It excepts that the software I2C operates at lower clock frequency.

Here I use its dedicated I2C module. Most of dsPIC30F MCUs have more than one I2C module. 

Important :

• I²C library routines require you to specify the module you want to use. To select the desired I²C module, simply change the letter x in the routine prototype for a number from 1 to 3.
• Number of I²C modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.

These are its library routines:

Library Routines

• I2Cx_Init
• I2Cx_Start
• I2Cx_Restart
• I2Cx_Is_Idle
• I2Cx_Read
• I2Cx_Write
• I2Cx_Stop
• I2C_Set_Active

Generic Routines

• I2C_Start
• I2C_Restart
• I2C_Is_Idle
• I2C_Read
• I2C_Write
• I2C_Stop

 For more information about using the I2C module, please see this page.

PCF8574AP Output LEDs Example

For an introductory example, the dsPIC30F2010 send an 8-bit data to this chip. The 8-bit output of PCF8574AP connect individual LED.

 

Schematic:

Schematic

 MikroC Source Code:

 

1. 
   
2. const char PCF8574_W=0x40;
3. const char PCF8574_R=0x41;
4. const char PCF8574A_W=0x70;
5. const char PCF8574A_R=0x71;
6. 
   
7. void pcf8574_write(char device, char _data){
8. I2C1_Start(); // issue I2C start signal
9. I2C1_Write(device); // send byte via I2C (device address + W)
10. I2C1_Write(_data); // send byte (data address)
11. I2C1_Stop(); // issue I2C stop signal
12. }
13. 
    
14. void blink(unsigned int duration, unsigned int counts){
15. while(counts>0){
16. pcf8574_write(PCF8574A_W,0x00);
17. Vdelay_ms(duration);
18. pcf8574_write(PCF8574A_W,0xFF);
19. Vdelay_ms(duration);
20. counts--;
21. }
22. pcf8574_write(PCF8574A_W,0x00);
23. }
24. void main(){
25. char temp = 0, i = 0;
26. I2C1_Init(100000); // initialize I2C communication
27. Delay_ms(10);
28. pcf8574_write(PCF8574A_W,0x00);
29. blink(100,100);
30. while(1){
31. pcf8574_write(PCF8574A_W,temp);
32. temp+=(1<<i);
33. i++;
34. if(i > 8) i = temp = 0;
35. Delay_ms(200);
36. }
37. }

 

 I tested this code on my DIY dsPIC30F2010 Prototype Board.

 

 I tested this code on my DIY dsPIC30F2010 Prototype Board.

 I tested this code on my DIY dsPIC30F2010 Prototype Board.

 I tested this code on my DIY dsPIC30F2010 Prototype Board.

 I tested this code on my DIY dsPIC30F2010 Prototype Board.

 For a full I2C devices interfacing example using the ATMega644P chip see this post.