51单片机OLED12864 I2C接口使用教程 含注释详细的源代码

OLED12864_I2C接口使用教程_51单片机

       现在能买到的OLED12864显示屏大多为SPI和I2C接口的，I2C通信协议只需要两条总线就可以进行通信，下面介绍一下如何用51单片机使用I2C接口的OLED12864。

       首先介绍一下I2C通信协议，I2C（Inter-Integrated Circuit）字面上的意思是集成电路之间，它其实是I2CBus简称，所以中文应该叫集成电路总线，它是一种串行通信总线，使用多主从架构，由飞利浦公司在1980年代为了让主板、嵌入式系统或手机用以连接低速周边设备而发展。I2C的正确读法为“I平方C”（"I-squared-C"）。

       I2C只使用两条双向漏极开路（Open Drain）（串行数据（SDA）及串行时钟频率（SCL））总线，且利用上拉电阻将两条总线的电位上拉。I2C允许相当大的工作电压范围，但典型的电压准位为+3.3V或+5V。

       I2C的参考设计使用一个7比特长度的地址空间但保留了16个地址，所以在一组总线最多可和112个节点通信[a]。常见的I2C总线依传输速率的不同而有不同的模式：标准模式（100 Kbit/s）、低速模式（10 Kbit/s），但时钟频率可被允许下降至零，这代表可以暂停通信。而新一代的I2C总线可以和更多的节点（支持10比特长度的地址空间）以更快的速率通信：快速模式（400 Kbit/s）、高速模式（3.4 Mbit/s）。

       我们在51单片机中使用I2C通信协议的时候，需要编写程序去模拟I2C总线的通信，详细的I2C通信协议的介绍可以参考：http://www.51hei.com/bbs/dpj-110328-1.html

       对于I2C通信协议，需要补充的一点是：在实际通信传输数据时，SCL总线拉高的时间只要大于1.5μs都能够正常传输数据。

       OLED12864的裸屏是由SSD1306驱动的，I2C接口的OLED12864模块对外一共有4个接口，从左到右分别是GND（接地）、VCC（电源正极，可加3.3V，也可加5V）、SCL（时钟总线）、SDA（数据总线）：

       模块背面的IIC ADRESSSELECT表示该模块在I2C通信作为从机时的地址，当中间的脚用电阻和左边接起来时，地址为0x78，当和右边接起来时，地址为0x7A。

       SSD1306的I2C总线数据格式，可以看出，往OLED12864写数据时，先发送一个起始信号，接着发送从机地址，从机地址带有读写位（低电平为写），之后就可以发送指令或数据。在发送指令或数据之前，一般都需要发送一个控制字节，如图，控制字节的最高位为连续位（如果连续位为0，接下来发送的信息只能包含数据字节），次高位为数据/指令选择位（该位声明接下来发送的是数据还是指令，0为指令，1为数据），控制字节的低六位为0。可以在一个声明连续发送数据的控制字节后面跟上多个数据字节。

作者：Ace

转载请注明作者，谢谢！

发现直接贴代码有问题，，所以就把源代码作为附件传上来。

Oled12864_SRC.rar (39.86 KB, 下载次数: 847)

2018-3-24 13:56 上传

点击文件名下载附件
下载积分: 黑币 -5

注释详细的51单片机源程序如下(IIC.c):

1. #include "IIC.h"
   
2. 
   
3. void delay5us()               
   
4. {
   
5. 
   
6. }
   
7. 
   
8. void I2C_init()                                   //初始化
   
9. {
   
10.         SDA = 1;
    
11.         _nop_();
    
12.         SCL = 1;
    
13.         _nop_();                //空闲时，两条线均为高电平         
    
14. }
    
15. 
    
16. /*I2C通信起始信号*/
    
17. void I2C_start()
    
18. {
    
19.         SCL = 1;   //此时主机有总线控制权，先把SCL线拉高
    
20.         _nop_();   //稳定一下
    
21.         SDA = 1;   //把SDA线拉高，以便发出起始信号（不确定是否为高）
    
22.         delay5us();//通信协议规定延时大于4.7us
    
23.         SDA = 0;   //拉低SDA线，制造下降沿的起始信号
    
24.         delay5us();//通信协议规定延时大于4us
    
25. }
    
26.                                  
    
27. /*I2C通信终止信号*/
    
28. void I2C_stop()
    
29. {
    
30.         SDA = 0;   //拉低SDA线，以便发出终止信号
    
31.         _nop_();   //稳定一下
    
32.         SCL = 1;   //拉高SCL线
    
33.         delay5us();//通信协议规定延时大于4us
    
34.         SDA = 1;   //拉高SDA线
    
35.         delay5us();//通信协议规定延时大于4.7us
    
36. }
    
37. 
    
38. /*从机应答检测*/
    
39. bit Test_ack()
    
40. {
    
41.         SCL = 1;        
    
42.         //拉高SCL线，以便主机读取从机发出的应答或非应答信号
    
43.         delay5us();//通信协议规定延时大于4us
    
44.         if(SDA)           
    
45.         //主机读取的SDA线为高，说明从机发送了一个非应答信号
    
46.         {
    
47.                 SCL = 0;/*接下来准备发送停止信号，所以让时钟总线SCL拉低，
    
48.                                 让I2C_stop();函数中的SDA可变为0*/
    
49.                 _nop_();//稳定总线
    
50.                 I2C_stop();
    
51.                 return 0;//结束检测从机应答函数
    
52.         }        
    
53.         else
    
54.         //主机读取的SDA线为低，说明从机发送了一个应答信号
    
55.         {
    
56.                 SCL = 0;/*将时钟总线SCL拉低，此时SDA上数据的变化才有效，
    
57.                                 因为接下来会继续发数据*/
    
58.                 _nop_();//稳定总线
    
59.                 return 1;
    
60.         }
    
61. }
    
62. 
    
63. /*I2C通信：发送一个字节*/
    
64. void I2C_send_byte(uint8_t byte)
    
65. {
    
66.         uint8_t i;//声明一个计数变量i
    
67.         for(i = 0; i < 8; i++)//一个字节有8位，发8次
    
68.         {
    
69.                 SCL = 0;//拉低SCL，让数据总线SDA变化有效
    
70.                 _nop_();//稳定总线
    
71.                 if(byte & 0x80)//1000 0000 & byte
    
72. /*如果（要发送数据的当前传输位）byte的最高位为1，执行该if语句，
    
73.   如果（要发送数据的当前传输位）byte的最高位为0，不执行该if语句*/
    
74.                 {
    
75.                         SDA = 1;   
    
76.                         //（当前传输位）byte的最高位为1，即把1放到SDA线上
    
77.                         _nop_();//稳定总线
    
78.                 }        
    
79.                 else
    
80.                 //如果（当前发送位）byte的最高位为0（不为1），给SDA送0
    
81.                 {
    
82.                         SDA = 0;
    
83.                         _nop_();//稳定总线
    
84.                 }
    
85.                 SCL = 1;//拉高SCL线，使从机能够从SDA线上读取到当前的数据
    
86.                 _nop_();//稳定总线
    
87.                 byte <<= 1;
    
88. /*使byte左移一位，即原来已被发送到SDA线上的最高位被移除，
    
89. 第七位（还未发送的数据位）变成最高位变为下一次循环的当前发送位*/
    
90.         }
    
91.         SCL = 0;
    
92.         //发送完数据之后，将SCL拉低，以便从机改变SDA线，发出应答信号
    
93.         _nop_();//稳定总线
    
94.         SDA = 1;//释放总线控制权
    
95.         _nop_();//稳定总线
    
96. }
    

复制代码

OLED_12864.c

1. #include "OLED_12864.h"
   
2. 
   
3. 
   
4. void Delay300ms()
   
5. {
   
6. 
   
7. }
   
8. 
   
9. 
   
10. /*写指令函数，第一个参数为指令，第二、三个参数选择是否需要通信开始和结束函数，=1有，=0没有*/
    
11. bit OLED12864_Write_Commmand(uint8_t cmd, bit start, bit stop)
    
12. {
    
13.         if(start)
    
14.         {
    
15.                 I2C_start();
    
16.                 I2C_send_byte(OLED_12864_Address+0);//写从机地址，并且加上读写标志位（最后一位）
    
17.                 if(!Test_ack())
    
18.                 {
    
19.                         return 0;
    
20.                 }
    
21.                 /*执行从机应答检测函数，如果从机发送了非应答信号，那么就退出数据发送函数*/
    
22.         }
    
23.         I2C_send_byte(0x80 | 0x00 | 0x00);  //Co位为1（接下来要传指令），DC为0（接下来是指令）
    
24.         if(!Test_ack())
    
25.         {
    
26.                 return 0;
    
27.         }
    
28.         /*执行从机应答检测函数，如果从机发送了非应答信号，那么就退出数据发送函数*/
    
29. 
    
30.         I2C_send_byte(cmd);
    
31.         if(!Test_ack())
    
32.         {
    
33.                 return 0;
    
34.         }
    
35.         /*执行从机应答检测函数，如果从机发送了非应答信号，那么就退出数据发送函数*/
    
36. 
    
37.         if(stop)
    
38.                 I2C_stop();
    
39. 
    
40.         return 1;
    
41. }
    
42. 
    
43. /*写连续数据函数，第一个参数为数据，第二个参数为发送连多少位连续的数据，第三、四个参数选择是否需要通信开始和结束函数，=1有，=0没有*/
    
44. bit OLED12864_Write_Continuous_Data(uint8_t* dat, uint8_t count, bit start, bit stop)
    
45. {
    
46.         uint8_t i = 0;//定义计数变量
    
47.         if(start)
    
48.         {
    
49.                 I2C_start();
    
50.                 I2C_send_byte(OLED_12864_Address+0);//写从机地址，并且加上读写标志位（最后一位）
    
51.                 if(!Test_ack())
    
52.                 {
    
53.                         return 0;
    
54.                 }
    
55.                 /*执行从机应答检测函数，如果从机发送了非应答信号，那么就退出数据发送函数*/
    
56.         }
    
57.         I2C_send_byte(0x00 | 0x40 | 0x00);  //Co位为0（接下来只传数据），DC为1（接下来是数据）
    
58.         if(!Test_ack())
    
59.         {
    
60.                 return 0;
    
61.         }
    
62.         /*执行从机应答检测函数，如果从机发送了非应答信号，那么就退出数据发送函数*/
    
63.         for(i = 0 ;i < count ;i++)
    
64.         {
    
65.                 I2C_send_byte(*dat++);
    
66.                 if(!Test_ack())
    
67.                 {
    
68.                         return 0;
    
69.                 }
    
70.         /*执行从机应答检测函数，如果从机发送了非应答信号，那么就退出数据发送函数*/
    
71.         }
    
72. 
    
73.         if(stop)
    
74.                 I2C_stop();
    
75. 
    
76.         return 1;
    
77. }
    
78. 
    
79. 
    
80. /*写相同的连续数据函数，第一个参数为数据，第二参数为发送的次数*/
    
81. bit OLED12864_Write_Same_Continuous_Data(uint8_t dat, uint8_t count)
    
82. {
    
83.         uint8_t i = 0;//定义计数变量
    
84.         I2C_start();
    
85.         I2C_send_byte(OLED_12864_Address+0);//写从机地址，并且加上读写标志位（最后一位）
    
86.         if(!Test_ack())
    
87.         {
    
88.                 return 0;
    
89.         }
    
90.         /*执行从机应答检测函数，如果从机发送了非应答信号，那么就退出数据发送函数*/
    
91. 
    
92.         I2C_send_byte(0x00 | 0x40 | 0x00);  //Co位为0（接下来只传数据），DC为1（接下来是数据）
    
93. 
    
94.         if(!Test_ack())
    
95.         {
    
96.                 return 0;
    
97.         }
    
98.         /*执行从机应答检测函数，如果从机发送了非应答信号，那么就退出数据发送函数*/
    
99.         for(i = 0 ;i < count ;i++ )
    
100.         {
     
101.                 I2C_send_byte(dat);
     
102.                 if(!Test_ack())
     
103.                 {
     
104.                         return 0;
     
105.                 }
     
106.         /*执行从机应答检测函数，如果从机发送了非应答信号，那么就退出数据发送函数*/
     
107.         }
     
108.         
     
109.         I2C_stop();
     
110. 
     
111.         return 1;
     
112. }
     
113. 
     
114.    
     
115. //Set the cursor position of start  
     
116. void OLED12864_SetPos(uint8_t x, uint8_t y)  
     
117. {   
     
118.     OLED12864_Write_Commmand(0xb0+y,1,0);  
     
119.     OLED12864_Write_Commmand(((x&0xf0)>>4)|0x10,0,0);  
     
120.     OLED12864_Write_Commmand((x&0x0f)|0x01,0,1);  
     
121. }  
     
122.   
     
123. //Fill screen wit data  
     
124. //0x00 is black  
     
125. //0xff is blue  
     
126. void OLED12864_Fill(uint8_t fill_Data)  
     
127. {  
     
128.     uint8_t m;
     
129.         //uint8_t n;  
     
130.     for(m=0;m<8;m++)  
     
131.     {  
     
132.         OLED12864_Write_Commmand(0xb0+m,1,0);       //page0-page1  
     
133.         OLED12864_Write_Commmand(0x00,0,0);     //low column start address  
     
134.         OLED12864_Write_Commmand(0x10,0,1);     //high column start address  
     
135.                 OLED12864_Write_Same_Continuous_Data(fill_Data, 128);
     
136.     }  
     
137. }  
     
138.   
     
139. void OLED12864_CLS_LINE(uint8_t rowIndex)  
     
140. {  
     
141.     uint8_t n=0;  
     
142.     OLED12864_Write_Commmand(0xb0+rowIndex,1,0);        //page0-page1  
     
143.     OLED12864_Write_Commmand(0x00,0,0);     //low column start address  
     
144.     OLED12864_Write_Commmand(0x10,0,1);     //high column start address  
     
145.         OLED12864_Write_Same_Continuous_Data(0x00, 128);  
     
146. }  
     
147.   
     
148. //clear screen( fill screen with black)  
     
149. void OLED12864_CLS(void)  
     
150. {  
     
151.     OLED12864_Fill(0x00);  
     
152. }  
     
153.   
     
154. //--------------------------------------------------------------  
     
155. // wake up screen from hibernation  
     
156. //--------------------------------------------------------------  
     
157. void OLED12864_ON(void)  
     
158. {  
     
159.     OLED12864_Write_Commmand(0X8D,1,0);  //set charge  
     
160.     OLED12864_Write_Commmand(0X14,0,0);  //open charge  
     
161.     OLED12864_Write_Commmand(0XAF,0,1);  //OLED wake up  
     
162. }  
     
163.   
     
164. //--------------------------------------------------------------  
     
165. // Prototype      : void OLED12864_OFF(void)  
     
166. // Calls          :   
     
167. // Parameters     : none  
     
168. // Description    : ?OLED?? -- ?????,OLED????10uA  
     
169. //--------------------------------------------------------------  
     
170. void OLED12864_OFF(void)  
     
171. {  
     
172.     OLED12864_Write_Commmand(0X8D,1,0);  //set charge   
     
173.     OLED12864_Write_Commmand(0X10,0,0);  //close charge  
     
174.     OLED12864_Write_Commmand(0XAE,0,1);  //OLED hibernate  
     
175. }  
     
176. 
     
177. bit OLED12864_Initial()  
     
178. {  
     
179.     Delay300ms(); // very important delay  
     
180.       
     
181.     OLED12864_Write_Commmand(0xAE,1,0); //display off  
     
182.     OLED12864_Write_Commmand(0x20,0,0); //Set Memory Addressing Mode      
     
183.     OLED12864_Write_Commmand(0x10,0,0); //00,Horizontal Addressing Mode;01,Vertical Addressing Mode;10,Page Addressing Mode (RESET);11,Invalid  
     
184.     OLED12864_Write_Commmand(0xb0,0,0); //Set Page Start Address for Page Addressing Mode,0-7  
     
185.     OLED12864_Write_Commmand(0xc8,0,0); //Set COM Output Scan Direction  
     
186.     OLED12864_Write_Commmand(0x00,0,0); //---set low column address  
     
187.     OLED12864_Write_Commmand(0x10,0,0); //---set high column address  
     
188.     OLED12864_Write_Commmand(0x40,0,0); //--set start line address  
     
189.     OLED12864_Write_Commmand(0x81,0,0); //--set contrast control register  
     
190.     OLED12864_Write_Commmand(0xff,0,0); //???? 0x00~0xff  
     
191.     OLED12864_Write_Commmand(0xa1,0,0); //--set segment re-map 0 to 127  
     
192.     OLED12864_Write_Commmand(0xa6,0,0); //--set normal display  
     
193.     OLED12864_Write_Commmand(0xa8,0,0); //--set multiplex ratio(1 to 64)  
     
194.     OLED12864_Write_Commmand(0x3F,0,0); //  
     
195.     OLED12864_Write_Commmand(0xa4,0,0); //0xa4,Output follows RAM content;0xa5,Output ignores RAM content  
     
196.     OLED12864_Write_Commmand(0xd3,0,0); //-set display offset  
     
197.     OLED12864_Write_Commmand(0x00,0,0); //-not offset  
     
198.     OLED12864_Write_Commmand(0xd5,0,0); //--set display clock divide ratio/oscillator frequency  
     
199.     OLED12864_Write_Commmand(0xf0,0,0); //--set divide ratio  
     
200.     OLED12864_Write_Commmand(0xd9,0,0); //--set pre-charge period  
     
201.     OLED12864_Write_Commmand(0x22,0,0); //  
     
202.     OLED12864_Write_Commmand(0xda,0,0); //--set com pins hardware configuration  
     
203.     OLED12864_Write_Commmand(0x12,0,0);  
     
204.     OLED12864_Write_Commmand(0xdb,0,0); //--set vcomh  
     
205.     OLED12864_Write_Commmand(0x20,0,0); //0x20,0.77xVcc  
     
206.     OLED12864_Write_Commmand(0x8d,0,0); //--set DC-DC enable  
     
207.     OLED12864_Write_Commmand(0x14,0,0); //  
     
208.     OLED12864_Write_Commmand(0xaf,0,1); //--turn on oled panel  
     
209.       
     
210.     OLED12864_CLS();  
     
211.     return 1;  
     
212. }
     
213.   
     
214. //--------------------------------------------------------------  
     
215. // show string  
     
216. // x,y -- start position(x:0~127,column; y:0~7,row);   
     
217. // ch[] -- the string to show;   
     
218. // TextSize -- (1:6*8 ; 2:8*16)  
     
219. //OLED12864_ShowStr(0,3,"I2C Test",1);// 6*8  
     
220. //OLED12864_ShowStr(0,4,"Hello Delta",2) //8*16  
     
221. //--------------------------------------------------------------  
     
222. void OLED12864_ShowStr(uint8_t x, uint8_t y, uint8_t ch[], uint8_t TextSize)  
     
223. {  
     
224.     uint8_t c = 0,i = 0,j = 0;  
     
225.     switch(TextSize)  
     
226.     {  
     
227.         case 1:  
     
228.         {  
     
229.             while(ch[j] != '\0' && ch[j] !='\n')  
     
230.             {  
     
231.                 c = ch[j] - 32;  
     
232.                 if(x > 126)  
     
233.                 {  
     
234.                     x = 0;  
     
235.                     y++;  
     
236.                 }  
     
237.                 OLED12864_SetPos(x,y);  
     
238.                 /*for(i=0;i<6;i++)  
     
239.                     OLED12864_Write_Data(F6x8[c][i],1,1);*/
     
240.                                 OLED12864_Write_Continuous_Data(&F6x8[c][0],6,1,1);//将该位的指针传给函数，并且写连续的6个数据即可  
     
241.                 x += 6;  
     
242.                 j++;  
     
243.             }  
     
244.         }break;  
     
245.         case 2:  
     
246.         {  
     
247.             while(ch[j] != '\0'  && ch[j] !='\n')  
     
248.             {  
     
249.                 c = ch[j] - 32;  
     
250.                 if(x > 120)  
     
251.                 {  
     
252.                     x = 0;  
     
253.                     y++;  
     
254.                 }  
     
255.                 OLED12864_SetPos(x,y);  
     
256.                 /*for(i=0;i<8;i++)  
     
257.                    OLED12864_Write_Data(F8X16[c*16+i],1,1);  
     
258.                 OLED12864_SetPos(x,y+1);  
     
259.                 for(i=0;i<8;i++)  
     
260.                     OLED12864_Write_Data(F8X16[c*16+i+8],1,1);*/
     
261.                                 OLED12864_Write_Continuous_Data(&F8X16[c*16],8,1,1);//将该位的指针传给函数，并且写连续的8个数据即可
     
262.                                 OLED12864_SetPos(x,y+1);
     
263.                                 OLED12864_Write_Continuous_Data(&F8X16[c*16+8],8,1,1);//将该位的指针传给函数，并且写连续的8个数据即可  
     
264.                 x += 8;  
     
265.                 j++;  
     
266.             }  
     
267.         }break;  
     
268.     }  
     
269. }
     
270. 
     
271. uint8_t rowNum = 0;
     
272.   
     
273. //--------------------------------------------------------------  
     
274. // x,y -- start position(x:0~127,column; y:0~7,row);   
     
275. // the N is the chinese index of F16x16 in codetab  
     
276. /*
     
277. for(i=0;i<5;i++)
     
278. {
     
279.     OLED12864_ShowCN(22+i*16,0,i);
     
280. }
     
281. ……………………
     
282. 
     
283. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

你的东西搞得我好累啊.好不容易才搞好了.看看我弄的效果,有图有真象

不错，可以参考，看能不能搞出svr程序

好像很有趣，想下载看看

可不可以在程序里建一个字库

guangshi_wq 发表于 2018-7-28 01:15
你的东西搞得我好累啊.好不容易才搞好了.看看我弄的效果,有图有真象

确实不错，找了超长时间的资料。

真透彻的资料

很不错的程序

很有帮助

好东西，好好学习

pavlos96 发表于 2018-7-24 09:41
可不可以在程序里建一个字库

可以的，我就在用

清楚，可以

厉害了，老哥

顶一下！

顶一下，问一下为什么没有主函数

很给力！

很好的东西，学到了

看了之后感觉很有用，给力

谢谢老哥。棒

感谢分享

感谢分享

很给力

谢谢楼主分享好东西

可以可以

代码注释很全，也很规范，值得学习

非常的好

谢谢分享！

非常好，感谢LZ

谢谢分享，前来学习。

厉害了，大佬

不错，不错，可以参考的代码

不太明白为什么第一行是黄色的 后面的是蓝色呢 这个是如何设置的啊

大佬，厉害了，感谢分享

为什么65行data要++呢？（小白一个）

谢谢分享，不错不错

代码注释很全，也很规范，值得学习，确实很详细的分析了，有这样的教程，是不是学习更给力。

感谢楼主分享

想把这个OLED玩好没这么简单，以前用过LCD1602/LCD12864。现在学习STM32，看了正点原子的视频，感觉视频里讲的只是一个点。程序为什么要这样写。怎么写。把每个函数都写一遍，都能讲很久。感觉正点原子的原子和视频有点坑了。或着是我学艺不精。

发现了学单片机一定要来51hei，这里的资料真棒。