学习目标

  1. 掌握移植方法
  2. 掌握解决移植失败的思路
  3. 掌握调试方式

    学习内容

    需求

    214.png216.png

官方测试示例

选择对应的平台

测试示例中，找到芯片对应平台，我们选择的是STM32F407
217.png

修改例程

已知错误修改：

  1. #ifndef u8
  2. #define u8 uint8_t
  3. #endif
  5. #ifndef u16
  6. #define u16 uint16_t
  7. #endif
  9. #ifndef u32
  10. #define u32 uint32_t
  11. #endif

引脚定义修改：

  1. #define SCL_PORT_RCC    RCC_AHB1Periph_GPIOB
  2. #define SCL_PORT            GPIOB
  3. #define SCL_PIN                GPIO_Pin_6
  5. #define SDA_PORT_RCC    RCC_AHB1Periph_GPIOB
  6. #define SDA_PORT            GPIOB
  7. #define SDA_PIN                GPIO_Pin_7
  9. //-----------------OLED端口定义---------------- 
  10. #define OLED_SCL_Clr() GPIO_ResetBits(SCL_PORT,SCL_PIN)//SCL
  11. #define OLED_SCL_Set() GPIO_SetBits(SCL_PORT,SCL_PIN)
  13. #define OLED_SDA_Clr() GPIO_ResetBits(SDA_PORT,SDA_PIN)//DIN
  14. #define OLED_SDA_Set() GPIO_SetBits(SDA_PORT,SDA_PIN)
  16. //#define OLED_RES_Clr() GPIO_ResetBits(GPIOD,GPIO_Pin_4)//RES
  17. //#define OLED_RES_Set() GPIO_SetBits(GPIOD,GPIO_Pin_4)

初始化逻辑修改:

  1. GPIO_InitTypeDef  GPIO_InitStructure;
  3. ////////////////// SCL
  4. RCC_AHB1PeriphClockCmd(SCL_PORT_RCC, ENABLE);
  5. //GPIO初始化设置
  6. GPIO_InitStructure.GPIO_Pin = SCL_PIN;
  7. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
  8. GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
  9. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  10. GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
  11. GPIO_Init(SCL_PORT, &GPIO_InitStructure);//初始化
  13. ////////////////// SDA
  14. RCC_AHB1PeriphClockCmd(SDA_PORT_RCC, ENABLE);
  15. //GPIO初始化设置
  16. GPIO_InitStructure.GPIO_Pin = SDA_PIN;
  17. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
  18. GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
  19. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  20. GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
  21. GPIO_Init(SDA_PORT, &GPIO_InitStructure);//初始化
  24. //    OLED_RES_Clr();
  25. //    delay_ms(200);
  26. //    OLED_RES_Set();

烧录

修改芯片设置，修改烧录方式为DAP Link，烧录到当前GD32F470芯片中

测试结果

失败。无法工作。
通常碰到这种情况，我们需要进行分析。

  1. 环境问题
  2. 协议问题

    STM32测试环境

    采用自己的模板环境。

    测试代码构建

    ```c u8 t=’ ‘; OLED_Init();

while(1) { OLED_ShowPicture(0,0,128,64,BMP1,1); OLED_Refresh(); delay_1ms(500); OLED_Clear(); OLED_ShowChinese(0,0,0,16,1);//中 OLED_ShowChinese(18,0,1,16,1);//景 OLED_ShowChinese(36,0,2,16,1);//园 OLED_ShowChinese(54,0,3,16,1);//电 OLED_ShowChinese(72,0,4,16,1);//子 OLED_ShowChinese(90,0,5,16,1);//技 OLED_ShowChinese(108,0,6,16,1);//术 OLED_ShowString(8,16,”ZHONGJINGYUAN”,16,1); OLED_ShowString(20,32,”2014/05/01”,16,1); OLED_ShowString(0,48,”ASCII:”,16,1); OLED_ShowString(63,48,”CODE:”,16,1); OLED_ShowChar(48,48,t,16,1);//显示ASCII字符 t++; if(t>’~’)t=’ ‘; OLED_ShowNum(103,48,t,3,16,1); OLED_Refresh(); delay_1ms(500); OLED_Clear(); OLED_ShowChinese(0,0,0,16,1); //1616 中 OLED_ShowChinese(16,0,0,24,1); //2424 中 OLED_ShowChinese(24,20,0,32,1);//3232 中 OLED_ShowChinese(64,0,0,64,1); //6464 中 OLED_Refresh(); delay_1ms(500); OLED_Clear(); OLED_ShowString(0,0,”ABC”,8,1);//68 “ABC” OLED_ShowString(0,8,”ABC”,12,1);//612 “ABC” OLED_ShowString(0,20,”ABC”,16,1);//816 “ABC” OLED_ShowString(0,36,”ABC”,24,1);//1224 “ABC” OLED_Refresh(); delay_1ms(500); OLED_ScrollDisplay(11,4,1); }

  1. 修改一些API命名，比如delay的api
  2. <a name="GxKfY"></a>
  3. #### 驱动移植
  4. 可以将之前出错的API移植过来。
  5. ```c
  6. #ifndef __OLED_H
  7. #define __OLED_H 
  9. #include "stm32f4xx.h"
  10. #include "stdlib.h"    
  12. #ifndef u8
  13. #define u8 uint8_t
  14. #endif
  16. #ifndef u16
  17. #define u16 uint16_t
  18. #endif
  20. #ifndef u32
  21. #define u32 uint32_t
  22. #endif
  24. #define SCL_PORT_RCC    RCC_AHB1Periph_GPIOB
  25. #define SCL_PORT            GPIOB
  26. #define SCL_PIN                GPIO_Pin_6
  28. #define SDA_PORT_RCC    RCC_AHB1Periph_GPIOB
  29. #define SDA_PORT            GPIOB
  30. #define SDA_PIN                GPIO_Pin_7
  32. #define SDA_STATE()     GPIO_ReadInputDataBit(SDA_PORT, SDA_PIN)
  34. #define SDA_IN()        {    GPIO_InitTypeDef  GPIO_InitStructure;    \
  35.                                             GPIO_InitStructure.GPIO_Pin = SDA_PIN; \
  36.                                             GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; \
  37.                                             GPIO_Init(SDA_PORT, &GPIO_InitStructure);    }                                        
  38. #define SDA_OUT()        {    GPIO_InitTypeDef  GPIO_InitStructure;    \
  39.                                             GPIO_InitStructure.GPIO_Pin = SDA_PIN; \
  40.                                             GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; \
  41.                                             GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; \
  42.                                             GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; \
  43.                                             GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; \
  44.                                             GPIO_Init(SDA_PORT, &GPIO_InitStructure); }
  45. //#define SDA_IN()     0
  46. //#define SDA_OUT() 0
  48. //-----------------OLED端口定义---------------- 
  49. #define OLED_SCL_Clr() GPIO_ResetBits(SCL_PORT,SCL_PIN)//SCL
  50. #define OLED_SCL_Set() GPIO_SetBits(SCL_PORT,SCL_PIN)
  52. #define OLED_SDA_Clr() GPIO_ResetBits(SDA_PORT,SDA_PIN)//DIN
  53. #define OLED_SDA_Set() GPIO_SetBits(SDA_PORT,SDA_PIN)
  55. //#define OLED_RES_Clr() GPIO_ResetBits(GPIOD,GPIO_Pin_4)//RES
  56. //#define OLED_RES_Set() GPIO_SetBits(GPIOD,GPIO_Pin_4)
  59. #define OLED_CMD  0    //写命令
  60. #define OLED_DATA 1    //写数据
  62. void OLED_ClearPoint(u8 x,u8 y);
  63. void OLED_ColorTurn(u8 i);
  64. void OLED_DisplayTurn(u8 i);
  65. void I2C_Start(void);
  66. void I2C_Stop(void);
  67. void I2C_WaitAck(void);
  68. void Send_Byte(u8 dat);
  69. void OLED_WR_Byte(u8 dat,u8 mode);
  70. void OLED_DisPlay_On(void);
  71. void OLED_DisPlay_Off(void);
  72. void OLED_Refresh(void);
  73. void OLED_Clear(void);
  74. void OLED_DrawPoint(u8 x,u8 y,u8 t);
  75. void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2,u8 mode);
  76. void OLED_DrawCircle(u8 x,u8 y,u8 r);
  77. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1,u8 mode);
  78. void OLED_ShowChar6x8(u8 x,u8 y,u8 chr,u8 mode);
  79. void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1,u8 mode);
  80. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1,u8 mode);
  81. void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1,u8 mode);
  82. void OLED_ScrollDisplay(u8 num,u8 space,u8 mode);
  83. void OLED_ShowPicture(u8 x,u8 y,u8 sizex,u8 sizey,u8 BMP[],u8 mode);
  84. void OLED_Init(void);
  86. #endif
  1. #include "oled.h"
  2. #include "stdlib.h"
  3. #include "oledfont.h"       
  4. #include "systick.h"
  6. u8 OLED_GRAM[144][8];
  8. //反显函数
  9. void OLED_ColorTurn(u8 i)
  10. {
  11.     if(i==0)
  12.         {
  13.             OLED_WR_Byte(0xA6,OLED_CMD);//正常显示
  14.         }
  15.     if(i==1)
  16.         {
  17.             OLED_WR_Byte(0xA7,OLED_CMD);//反色显示
  18.         }
  19. }
  21. //屏幕旋转180度
  22. void OLED_DisplayTurn(u8 i)
  23. {
  24.     if(i==0)
  25.         {
  26.             OLED_WR_Byte(0xC8,OLED_CMD);//正常显示
  27.             OLED_WR_Byte(0xA1,OLED_CMD);
  28.         }
  29.     if(i==1)
  30.         {
  31.             OLED_WR_Byte(0xC0,OLED_CMD);//反转显示
  32.             OLED_WR_Byte(0xA0,OLED_CMD);
  33.         }
  34. }
  36. //延时
  37. void IIC_delay(void)
  38. {
  39. //    u8 t=10;
  40. //    while(t--);
  41.         delay_1us(5);
  42. }
  44. //起始信号
  45. void I2C_Start(void)
  46. {
  47.     SDA_OUT();
  49.     OLED_SDA_Set();
  50.     OLED_SCL_Set();
  51.     IIC_delay();
  52.     OLED_SDA_Clr();
  53.     IIC_delay();
  54.     OLED_SCL_Clr();
  55.     IIC_delay();
  56. }
  58. //结束信号
  59. void I2C_Stop(void)
  60. {
  61.     SDA_OUT();
  63.     OLED_SDA_Clr();
  64.     OLED_SCL_Set();
  65.     IIC_delay();
  66.     OLED_SDA_Set();
  67. }
  69. //等待信号响应
  70. void I2C_WaitAck(void) //测数据信号的电平
  71. {
  72.     OLED_SDA_Set();
  73.     SDA_IN();
  74.     IIC_delay();
  75.     OLED_SCL_Set();
  76.     IIC_delay();
  77.     OLED_SCL_Clr();
  78.     SDA_OUT();
  79.     IIC_delay();
  80. }
  82. //写入一个字节
  83. void Send_Byte(u8 dat)
  84. {
  85.     u8 i;
  86.     SDA_OUT();
  88.     for(i=0;i<8;i++)
  89.     {
  90.         if(dat&0x80)//将dat的8位从最高位依次写入
  91.         {
  92.             OLED_SDA_Set();
  93.     }
  94.         else
  95.         {
  96.             OLED_SDA_Clr();
  97.     }
  98.         IIC_delay();
  99.         OLED_SCL_Set();
  100.         IIC_delay();
  101.         OLED_SCL_Clr();//将时钟信号设置为低电平
  102.         dat<<=1;
  103.   }
  104. }
  106. //发送一个字节
  107. //mode:数据/命令标志 0,表示命令;1,表示数据;
  108. void OLED_WR_Byte(u8 dat,u8 mode)
  109. {
  110.     I2C_Start();
  111.     Send_Byte(0x78);
  112.     I2C_WaitAck();
  113.     if(mode){Send_Byte(0x40);}
  114.   else{Send_Byte(0x00);}
  115.     I2C_WaitAck();
  116.     Send_Byte(dat);
  117.     I2C_WaitAck();
  118.     I2C_Stop();
  119. }
  121. //开启OLED显示 
  122. void OLED_DisPlay_On(void)
  123. {
  124.     OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
  125.     OLED_WR_Byte(0x14,OLED_CMD);//开启电荷泵
  126.     OLED_WR_Byte(0xAF,OLED_CMD);//点亮屏幕
  127. }
  129. //关闭OLED显示 
  130. void OLED_DisPlay_Off(void)
  131. {
  132.     OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
  133.     OLED_WR_Byte(0x10,OLED_CMD);//关闭电荷泵
  134.     OLED_WR_Byte(0xAE,OLED_CMD);//关闭屏幕
  135. }
  137. //更新显存到OLED    
  138. void OLED_Refresh(void)
  139. {
  140.     u8 i,n;
  141.     for(i=0;i<8;i++)
  142.     {
  143.         OLED_WR_Byte(0xb0+i,OLED_CMD); //设置行起始地址
  144.         OLED_WR_Byte(0x00,OLED_CMD);   //设置低列起始地址
  145.         OLED_WR_Byte(0x10,OLED_CMD);   //设置高列起始地址
  146.         I2C_Start();
  147.         Send_Byte(0x78);
  148.         I2C_WaitAck();
  149.         Send_Byte(0x40);
  150.         I2C_WaitAck();
  151.         for(n=0;n<128;n++)
  152.         {
  153.             Send_Byte(OLED_GRAM[n][i]);
  154.             I2C_WaitAck();
  155.         }
  156.         I2C_Stop();
  157.   }
  158. }
  159. //清屏函数
  160. void OLED_Clear(void)
  161. {
  162.     u8 i,n;
  163.     for(i=0;i<8;i++)
  164.     {
  165.        for(n=0;n<128;n++)
  166.             {
  167.              OLED_GRAM[n][i]=0;//清除所有数据
  168.             }
  169.   }
  170.     OLED_Refresh();//更新显示
  171. }
  173. //画点 
  174. //x:0~127
  175. //y:0~63
  176. //t:1 填充 0,清空    
  177. void OLED_DrawPoint(u8 x,u8 y,u8 t)
  178. {
  179.     u8 i,m,n;
  180.     i=y/8;
  181.     m=y%8;
  182.     n=1<<m;
  183.     if(t){OLED_GRAM[x][i]|=n;}
  184.     else
  185.     {
  186.         OLED_GRAM[x][i]=~OLED_GRAM[x][i];
  187.         OLED_GRAM[x][i]|=n;
  188.         OLED_GRAM[x][i]=~OLED_GRAM[x][i];
  189.     }
  190. }
  192. //画线
  193. //x1,y1:起点坐标
  194. //x2,y2:结束坐标
  195. void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2,u8 mode)
  196. {
  197.     u16 t; 
  198.     int xerr=0,yerr=0,delta_x,delta_y,distance;
  199.     int incx,incy,uRow,uCol;
  200.     delta_x=x2-x1; //计算坐标增量 
  201.     delta_y=y2-y1;
  202.     uRow=x1;//画线起点坐标
  203.     uCol=y1;
  204.     if(delta_x>0)incx=1; //设置单步方向 
  205.     else if (delta_x==0)incx=0;//垂直线 
  206.     else {incx=-1;delta_x=-delta_x;}
  207.     if(delta_y>0)incy=1;
  208.     else if (delta_y==0)incy=0;//水平线 
  209.     else {incy=-1;delta_y=-delta_x;}
  210.     if(delta_x>delta_y)distance=delta_x; //选取基本增量坐标轴 
  211.     else distance=delta_y;
  212.     for(t=0;t<distance+1;t++)
  213.     {
  214.         OLED_DrawPoint(uRow,uCol,mode);//画点
  215.         xerr+=delta_x;
  216.         yerr+=delta_y;
  217.         if(xerr>distance)
  218.         {
  219.             xerr-=distance;
  220.             uRow+=incx;
  221.         }
  222.         if(yerr>distance)
  223.         {
  224.             yerr-=distance;
  225.             uCol+=incy;
  226.         }
  227.     }
  228. }
  229. //x,y:圆心坐标
  230. //r:圆的半径
  231. void OLED_DrawCircle(u8 x,u8 y,u8 r)
  232. {
  233.     int a, b,num;
  234.     a = 0;
  235.     b = r;
  236.     while(2 * b * b >= r * r)      
  237.     {
  238.         OLED_DrawPoint(x + a, y - b,1);
  239.         OLED_DrawPoint(x - a, y - b,1);
  240.         OLED_DrawPoint(x - a, y + b,1);
  241.         OLED_DrawPoint(x + a, y + b,1);
  243.         OLED_DrawPoint(x + b, y + a,1);
  244.         OLED_DrawPoint(x + b, y - a,1);
  245.         OLED_DrawPoint(x - b, y - a,1);
  246.         OLED_DrawPoint(x - b, y + a,1);
  248.         a++;
  249.         num = (a * a + b * b) - r*r;//计算画的点离圆心的距离
  250.         if(num > 0)
  251.         {
  252.             b--;
  253.             a--;
  254.         }
  255.     }
  256. }
  260. //在指定位置显示一个字符,包括部分字符
  261. //x:0~127
  262. //y:0~63
  263. //size1:选择字体 6x8/6x12/8x16/12x24
  264. //mode:0,反色显示;1,正常显示
  265. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1,u8 mode)
  266. {
  267.     u8 i,m,temp,size2,chr1;
  268.     u8 x0=x,y0=y;
  269.     if(size1==8)size2=6;
  270.     else size2=(size1/8+((size1%8)?1:0))*(size1/2);  //得到字体一个字符对应点阵集所占的字节数
  271.     chr1=chr-' ';  //计算偏移后的值
  272.     for(i=0;i<size2;i++)
  273.     {
  274.         if(size1==8)
  275.               {temp=asc2_0806[chr1][i];} //调用0806字体
  276.         else if(size1==12)
  277.         {temp=asc2_1206[chr1][i];} //调用1206字体
  278.         else if(size1==16)
  279.         {temp=asc2_1608[chr1][i];} //调用1608字体
  280.         else if(size1==24)
  281.         {temp=asc2_2412[chr1][i];} //调用2412字体
  282.         else return;
  283.         for(m=0;m<8;m++)
  284.         {
  285.             if(temp&0x01)OLED_DrawPoint(x,y,mode);
  286.             else OLED_DrawPoint(x,y,!mode);
  287.             temp>>=1;
  288.             y++;
  289.         }
  290.         x++;
  291.         if((size1!=8)&&((x-x0)==size1/2))
  292.         {x=x0;y0=y0+8;}
  293.         y=y0;
  294.   }
  295. }
  298. //显示字符串
  299. //x,y:起点坐标  
  300. //size1:字体大小 
  301. //*chr:字符串起始地址 
  302. //mode:0,反色显示;1,正常显示
  303. void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1,u8 mode)
  304. {
  305.     while((*chr>=' ')&&(*chr<='~'))//判断是不是非法字符!
  306.     {
  307.         OLED_ShowChar(x,y,*chr,size1,mode);
  308.         if(size1==8)x+=6;
  309.         else x+=size1/2;
  310.         chr++;
  311.   }
  312. }
  314. //m^n
  315. u32 OLED_Pow(u8 m,u8 n)
  316. {
  317.     u32 result=1;
  318.     while(n--)
  319.     {
  320.       result*=m;
  321.     }
  322.     return result;
  323. }
  325. //显示数字
  326. //x,y :起点坐标
  327. //num :要显示的数字
  328. //len :数字的位数
  329. //size:字体大小
  330. //mode:0,反色显示;1,正常显示
  331. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1,u8 mode)
  332. {
  333.     u8 t,temp,m=0;
  334.     if(size1==8)m=2;
  335.     for(t=0;t<len;t++)
  336.     {
  337.         temp=(num/OLED_Pow(10,len-t-1))%10;
  338.             if(temp==0)
  339.             {
  340.                 OLED_ShowChar(x+(size1/2+m)*t,y,'0',size1,mode);
  341.       }
  342.             else 
  343.             {
  344.               OLED_ShowChar(x+(size1/2+m)*t,y,temp+'0',size1,mode);
  345.             }
  346.   }
  347. }
  349. //显示汉字
  350. //x,y:起点坐标
  351. //num:汉字对应的序号
  352. //mode:0,反色显示;1,正常显示
  353. void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1,u8 mode)
  354. {
  355.     u8 m,temp;
  356.     u8 x0=x,y0=y;
  357.     u16 i,size3=(size1/8+((size1%8)?1:0))*size1;  //得到字体一个字符对应点阵集所占的字节数
  358.     for(i=0;i<size3;i++)
  359.     {
  360.         if(size1==16)
  361.                 {temp=Hzk1[num][i];}//调用16*16字体
  362.         else if(size1==24)
  363.                 {temp=Hzk2[num][i];}//调用24*24字体
  364.         else if(size1==32)       
  365.                 {temp=Hzk3[num][i];}//调用32*32字体
  366.         else if(size1==64)
  367.                 {temp=Hzk4[num][i];}//调用64*64字体
  368.         else return;
  369.         for(m=0;m<8;m++)
  370.         {
  371.             if(temp&0x01)OLED_DrawPoint(x,y,mode);
  372.             else OLED_DrawPoint(x,y,!mode);
  373.             temp>>=1;
  374.             y++;
  375.         }
  376.         x++;
  377.         if((x-x0)==size1)
  378.         {x=x0;y0=y0+8;}
  379.         y=y0;
  380.     }
  381. }
  383. //num 显示汉字的个数
  384. //space 每一遍显示的间隔
  385. //mode:0,反色显示;1,正常显示
  386. void OLED_ScrollDisplay(u8 num,u8 space,u8 mode)
  387. {
  388.     u8 i,n,t=0,m=0,r;
  389.     while(1)
  390.     {
  391.         if(m==0)
  392.         {
  393.         OLED_ShowChinese(128,24,t,16,mode); //写入一个汉字保存在OLED_GRAM[][]数组中
  394.             t++;
  395.         }
  396.         if(t==num)
  397.             {
  398.                 for(r=0;r<16*space;r++)      //显示间隔
  399.                  {
  400.                     for(i=1;i<144;i++)
  401.                         {
  402.                             for(n=0;n<8;n++)
  403.                             {
  404.                                 OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
  405.                             }
  406.                         }
  407.            OLED_Refresh();
  408.                  }
  409.         t=0;
  410.       }
  411.         m++;
  412.         if(m==16){m=0;}
  413.         for(i=1;i<144;i++)   //实现左移
  414.         {
  415.             for(n=0;n<8;n++)
  416.             {
  417.                 OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
  418.             }
  419.         }
  420.         OLED_Refresh();
  421.     }
  422. }
  424. //x,y：起点坐标
  425. //sizex,sizey,图片长宽
  426. //BMP[]：要写入的图片数组
  427. //mode:0,反色显示;1,正常显示
  428. void OLED_ShowPicture(u8 x,u8 y,u8 sizex,u8 sizey,u8 BMP[],u8 mode)
  429. {
  430.     u16 j=0;
  431.     u8 i,n,temp,m;
  432.     u8 x0=x,y0=y;
  433.     sizey=sizey/8+((sizey%8)?1:0);
  434.     for(n=0;n<sizey;n++)
  435.     {
  436.          for(i=0;i<sizex;i++)
  437.          {
  438.                 temp=BMP[j];
  439.                 j++;
  440.                 for(m=0;m<8;m++)
  441.                 {
  442.                     if(temp&0x01)OLED_DrawPoint(x,y,mode);
  443.                     else OLED_DrawPoint(x,y,!mode);
  444.                     temp>>=1;
  445.                     y++;
  446.                 }
  447.                 x++;
  448.                 if((x-x0)==sizex)
  449.                 {
  450.                     x=x0;
  451.                     y0=y0+8;
  452.                 }
  453.                 y=y0;
  454.      }
  455.      }
  456. }
  457. //OLED的初始化
  458. void OLED_Init(void)
  459. {
  460.   GPIO_InitTypeDef  GPIO_InitStructure;
  462.     ////////////////// SCL
  463.     RCC_AHB1PeriphClockCmd(SCL_PORT_RCC, ENABLE);
  464.     //GPIO初始化设置
  465.   GPIO_InitStructure.GPIO_Pin = SCL_PIN;
  466.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
  467.   GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
  468.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  469.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
  470.   GPIO_Init(SCL_PORT, &GPIO_InitStructure);//初始化
  472.     ////////////////// SDA
  473.     RCC_AHB1PeriphClockCmd(SDA_PORT_RCC, ENABLE);
  474.     //GPIO初始化设置
  475.   GPIO_InitStructure.GPIO_Pin = SDA_PIN;
  476.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;//普通输出模式
  477.   GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
  478.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  479.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
  480.   GPIO_Init(SDA_PORT, &GPIO_InitStructure);//初始化
  482.     OLED_SCL_Clr();
  483.     OLED_SDA_Clr();
  484. //    OLED_RES_Clr();
  485. //    delay_ms(200);
  486. //    OLED_RES_Set();
  488.     OLED_WR_Byte(0xAE,OLED_CMD);//--turn off oled panel
  489.     OLED_WR_Byte(0x00,OLED_CMD);//---set low column address
  490.     OLED_WR_Byte(0x10,OLED_CMD);//---set high column address
  491.     OLED_WR_Byte(0x40,OLED_CMD);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
  492.     OLED_WR_Byte(0x81,OLED_CMD);//--set contrast control register
  493.     OLED_WR_Byte(0xCF,OLED_CMD);// Set SEG Output Current Brightness
  494.     OLED_WR_Byte(0xA1,OLED_CMD);//--Set SEG/Column Mapping     0xa0左右反置 0xa1正常
  495.     OLED_WR_Byte(0xC8,OLED_CMD);//Set COM/Row Scan Direction   0xc0上下反置 0xc8正常
  496.     OLED_WR_Byte(0xA6,OLED_CMD);//--set normal display
  497.     OLED_WR_Byte(0xA8,OLED_CMD);//--set multiplex ratio(1 to 64)
  498.     OLED_WR_Byte(0x3f,OLED_CMD);//--1/64 duty
  499.     OLED_WR_Byte(0xD3,OLED_CMD);//-set display offset    Shift Mapping RAM Counter (0x00~0x3F)
  500.     OLED_WR_Byte(0x00,OLED_CMD);//-not offset
  501.     OLED_WR_Byte(0xd5,OLED_CMD);//--set display clock divide ratio/oscillator frequency
  502.     OLED_WR_Byte(0x80,OLED_CMD);//--set divide ratio, Set Clock as 100 Frames/Sec
  503.     OLED_WR_Byte(0xD9,OLED_CMD);//--set pre-charge period
  504.     OLED_WR_Byte(0xF1,OLED_CMD);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
  505.     OLED_WR_Byte(0xDA,OLED_CMD);//--set com pins hardware configuration
  506.     OLED_WR_Byte(0x12,OLED_CMD);
  507.     OLED_WR_Byte(0xDB,OLED_CMD);//--set vcomh
  508.     OLED_WR_Byte(0x40,OLED_CMD);//Set VCOM Deselect Level
  509.     OLED_WR_Byte(0x20,OLED_CMD);//-Set Page Addressing Mode (0x00/0x01/0x02)
  510.     OLED_WR_Byte(0x02,OLED_CMD);//
  511.     OLED_WR_Byte(0x8D,OLED_CMD);//--set Charge Pump enable/disable
  512.     OLED_WR_Byte(0x14,OLED_CMD);//--set(0x10) disable
  513.     OLED_WR_Byte(0xA4,OLED_CMD);// Disable Entire Display On (0xa4/0xa5)
  514.     OLED_WR_Byte(0xA6,OLED_CMD);// Disable Inverse Display On (0xa6/a7) 
  515.     OLED_Clear();
  516.     OLED_WR_Byte(0xAF,OLED_CMD);
  517. }
  • 头文件的引入问题。处理#include "delay.h"替换为 #include "systick.h"

  • 修改delay函数

    void IIC_delay(void)
{
//    u8 t=10;
//    while(t--);
      delay_1us(5);
}

    I2C信号处理

    start信号
    void I2C_Start(void)
{
  SDA_OUT();

  OLED_SDA_Set();
  OLED_SCL_Set();
  IIC_delay();
  OLED_SDA_Clr();
  IIC_delay();
  OLED_SCL_Clr();
  IIC_delay();
}

    stop信号
    void I2C_Stop(void)
{
  SDA_OUT();

  OLED_SDA_Clr();
  OLED_SCL_Set();
  IIC_delay();
  OLED_SDA_Set();
}

    wait ack信号
    void I2C_WaitAck(void) //测数据信号的电平
{
  OLED_SDA_Set();
  SDA_IN();
  IIC_delay();
  OLED_SCL_Set();
  IIC_delay();
  OLED_SCL_Clr();
  SDA_OUT();
  IIC_delay();
}

    信号处理过程中，需要将输出改为输入，sda线需要由主从双方进行交替使用。

    头文件封装

    ```c

    define SDA_STATE() GPIO_ReadInputDataBit(SDA_PORT, SDA_PIN)

define SDA_IN() { GPIO_InitTypeDef GPIO_InitStructure; \

                                        GPIO_InitStructure.GPIO_Pin = SDA_PIN; \
                                        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; \
                                        GPIO_Init(SDA_PORT, &GPIO_InitStructure);    }

define SDA_OUT() { GPIO_InitTypeDef GPIO_InitStructure; \

                                        GPIO_InitStructure.GPIO_Pin = SDA_PIN; \
                                        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; \
                                        GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; \
                                        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; \
                                        GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; \
                                        GPIO_Init(SDA_PORT, &GPIO_InitStructure); }

<a name="NnaG2"></a>
#### 完整代码
```c
#ifndef __OLED_H
#define __OLED_H 

#include "stm32f4xx.h"
#include "stdlib.h"    

#ifndef u8
#define u8 uint8_t
#endif

#ifndef u16
#define u16 uint16_t
#endif

#ifndef u32
#define u32 uint32_t
#endif

#define SCL_PORT_RCC    RCC_AHB1Periph_GPIOB
#define SCL_PORT            GPIOB
#define SCL_PIN                GPIO_Pin_6

#define SDA_PORT_RCC    RCC_AHB1Periph_GPIOB
#define SDA_PORT            GPIOB
#define SDA_PIN                GPIO_Pin_7

#define SDA_STATE()     GPIO_ReadInputDataBit(SDA_PORT, SDA_PIN)

#define SDA_IN()        {    GPIO_InitTypeDef  GPIO_InitStructure;    \
                                            GPIO_InitStructure.GPIO_Pin = SDA_PIN; \
                                            GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; \
                                            GPIO_Init(SDA_PORT, &GPIO_InitStructure);    }                                        
#define SDA_OUT()        {    GPIO_InitTypeDef  GPIO_InitStructure;    \
                                            GPIO_InitStructure.GPIO_Pin = SDA_PIN; \
                                            GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; \
                                            GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; \
                                            GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; \
                                            GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; \
                                            GPIO_Init(SDA_PORT, &GPIO_InitStructure); }
//#define SDA_IN()     0
//#define SDA_OUT() 0

//-----------------OLED端口定义---------------- 
#define OLED_SCL_Clr() GPIO_ResetBits(SCL_PORT,SCL_PIN)//SCL
#define OLED_SCL_Set() GPIO_SetBits(SCL_PORT,SCL_PIN)

#define OLED_SDA_Clr() GPIO_ResetBits(SDA_PORT,SDA_PIN)//DIN
#define OLED_SDA_Set() GPIO_SetBits(SDA_PORT,SDA_PIN)

//#define OLED_RES_Clr() GPIO_ResetBits(GPIOD,GPIO_Pin_4)//RES
//#define OLED_RES_Set() GPIO_SetBits(GPIOD,GPIO_Pin_4)


#define OLED_CMD  0    //写命令
#define OLED_DATA 1    //写数据

void OLED_ClearPoint(u8 x,u8 y);
void OLED_ColorTurn(u8 i);
void OLED_DisplayTurn(u8 i);
void I2C_Start(void);
void I2C_Stop(void);
void I2C_WaitAck(void);
void Send_Byte(u8 dat);
void OLED_WR_Byte(u8 dat,u8 mode);
void OLED_DisPlay_On(void);
void OLED_DisPlay_Off(void);
void OLED_Refresh(void);
void OLED_Clear(void);
void OLED_DrawPoint(u8 x,u8 y,u8 t);
void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2,u8 mode);
void OLED_DrawCircle(u8 x,u8 y,u8 r);
void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1,u8 mode);
void OLED_ShowChar6x8(u8 x,u8 y,u8 chr,u8 mode);
void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1,u8 mode);
void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1,u8 mode);
void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1,u8 mode);
void OLED_ScrollDisplay(u8 num,u8 space,u8 mode);
void OLED_ShowPicture(u8 x,u8 y,u8 sizex,u8 sizey,u8 BMP[],u8 mode);
void OLED_Init(void);

#endif

#include "oled.h"
#include "stdlib.h"
#include "oledfont.h"       
#include "systick.h"

u8 OLED_GRAM[144][8];

//反显函数
void OLED_ColorTurn(u8 i)
{
    if(i==0)
        {
            OLED_WR_Byte(0xA6,OLED_CMD);//正常显示
        }
    if(i==1)
        {
            OLED_WR_Byte(0xA7,OLED_CMD);//反色显示
        }
}

//屏幕旋转180度
void OLED_DisplayTurn(u8 i)
{
    if(i==0)
        {
            OLED_WR_Byte(0xC8,OLED_CMD);//正常显示
            OLED_WR_Byte(0xA1,OLED_CMD);
        }
    if(i==1)
        {
            OLED_WR_Byte(0xC0,OLED_CMD);//反转显示
            OLED_WR_Byte(0xA0,OLED_CMD);
        }
}

//延时
void IIC_delay(void)
{
//    u8 t=10;
//    while(t--);
        delay_1us(5);
}

//起始信号
void I2C_Start(void)
{
    SDA_OUT();

    OLED_SDA_Set();
    OLED_SCL_Set();
    IIC_delay();
    OLED_SDA_Clr();
    IIC_delay();
    OLED_SCL_Clr();
    IIC_delay();
}

//结束信号
void I2C_Stop(void)
{
    SDA_OUT();

    OLED_SDA_Clr();
    OLED_SCL_Set();
    IIC_delay();
    OLED_SDA_Set();
}

//等待信号响应
void I2C_WaitAck(void) //测数据信号的电平
{
    OLED_SDA_Set();
    SDA_IN();
    IIC_delay();
    OLED_SCL_Set();
    IIC_delay();
    OLED_SCL_Clr();
    SDA_OUT();
    IIC_delay();
}

//写入一个字节
void Send_Byte(u8 dat)
{
    u8 i;
    SDA_OUT();

    for(i=0;i<8;i++)
    {
        if(dat&0x80)//将dat的8位从最高位依次写入
        {
            OLED_SDA_Set();
    }
        else
        {
            OLED_SDA_Clr();
    }
        IIC_delay();
        OLED_SCL_Set();
        IIC_delay();
        OLED_SCL_Clr();//将时钟信号设置为低电平
        dat<<=1;
  }
}

//发送一个字节
//mode:数据/命令标志 0,表示命令;1,表示数据;
void OLED_WR_Byte(u8 dat,u8 mode)
{
    I2C_Start();
    Send_Byte(0x78);
    I2C_WaitAck();
    if(mode){Send_Byte(0x40);}
  else{Send_Byte(0x00);}
    I2C_WaitAck();
    Send_Byte(dat);
    I2C_WaitAck();
    I2C_Stop();
}

//开启OLED显示 
void OLED_DisPlay_On(void)
{
    OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
    OLED_WR_Byte(0x14,OLED_CMD);//开启电荷泵
    OLED_WR_Byte(0xAF,OLED_CMD);//点亮屏幕
}

//关闭OLED显示 
void OLED_DisPlay_Off(void)
{
    OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
    OLED_WR_Byte(0x10,OLED_CMD);//关闭电荷泵
    OLED_WR_Byte(0xAE,OLED_CMD);//关闭屏幕
}

//更新显存到OLED    
void OLED_Refresh(void)
{
    u8 i,n;
    for(i=0;i<8;i++)
    {
        OLED_WR_Byte(0xb0+i,OLED_CMD); //设置行起始地址
        OLED_WR_Byte(0x00,OLED_CMD);   //设置低列起始地址
        OLED_WR_Byte(0x10,OLED_CMD);   //设置高列起始地址
        I2C_Start();
        Send_Byte(0x78);
        I2C_WaitAck();
        Send_Byte(0x40);
        I2C_WaitAck();
        for(n=0;n<128;n++)
        {
            Send_Byte(OLED_GRAM[n][i]);
            I2C_WaitAck();
        }
        I2C_Stop();
  }
}
//清屏函数
void OLED_Clear(void)
{
    u8 i,n;
    for(i=0;i<8;i++)
    {
       for(n=0;n<128;n++)
            {
             OLED_GRAM[n][i]=0;//清除所有数据
            }
  }
    OLED_Refresh();//更新显示
}

//画点 
//x:0~127
//y:0~63
//t:1 填充 0,清空    
void OLED_DrawPoint(u8 x,u8 y,u8 t)
{
    u8 i,m,n;
    i=y/8;
    m=y%8;
    n=1<<m;
    if(t){OLED_GRAM[x][i]|=n;}
    else
    {
        OLED_GRAM[x][i]=~OLED_GRAM[x][i];
        OLED_GRAM[x][i]|=n;
        OLED_GRAM[x][i]=~OLED_GRAM[x][i];
    }
}

//画线
//x1,y1:起点坐标
//x2,y2:结束坐标
void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2,u8 mode)
{
    u16 t; 
    int xerr=0,yerr=0,delta_x,delta_y,distance;
    int incx,incy,uRow,uCol;
    delta_x=x2-x1; //计算坐标增量 
    delta_y=y2-y1;
    uRow=x1;//画线起点坐标
    uCol=y1;
    if(delta_x>0)incx=1; //设置单步方向 
    else if (delta_x==0)incx=0;//垂直线 
    else {incx=-1;delta_x=-delta_x;}
    if(delta_y>0)incy=1;
    else if (delta_y==0)incy=0;//水平线 
    else {incy=-1;delta_y=-delta_x;}
    if(delta_x>delta_y)distance=delta_x; //选取基本增量坐标轴 
    else distance=delta_y;
    for(t=0;t<distance+1;t++)
    {
        OLED_DrawPoint(uRow,uCol,mode);//画点
        xerr+=delta_x;
        yerr+=delta_y;
        if(xerr>distance)
        {
            xerr-=distance;
            uRow+=incx;
        }
        if(yerr>distance)
        {
            yerr-=distance;
            uCol+=incy;
        }
    }
}
//x,y:圆心坐标
//r:圆的半径
void OLED_DrawCircle(u8 x,u8 y,u8 r)
{
    int a, b,num;
    a = 0;
    b = r;
    while(2 * b * b >= r * r)      
    {
        OLED_DrawPoint(x + a, y - b,1);
        OLED_DrawPoint(x - a, y - b,1);
        OLED_DrawPoint(x - a, y + b,1);
        OLED_DrawPoint(x + a, y + b,1);

        OLED_DrawPoint(x + b, y + a,1);
        OLED_DrawPoint(x + b, y - a,1);
        OLED_DrawPoint(x - b, y - a,1);
        OLED_DrawPoint(x - b, y + a,1);

        a++;
        num = (a * a + b * b) - r*r;//计算画的点离圆心的距离
        if(num > 0)
        {
            b--;
            a--;
        }
    }
}



//在指定位置显示一个字符,包括部分字符
//x:0~127
//y:0~63
//size1:选择字体 6x8/6x12/8x16/12x24
//mode:0,反色显示;1,正常显示
void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1,u8 mode)
{
    u8 i,m,temp,size2,chr1;
    u8 x0=x,y0=y;
    if(size1==8)size2=6;
    else size2=(size1/8+((size1%8)?1:0))*(size1/2);  //得到字体一个字符对应点阵集所占的字节数
    chr1=chr-' ';  //计算偏移后的值
    for(i=0;i<size2;i++)
    {
        if(size1==8)
              {temp=asc2_0806[chr1][i];} //调用0806字体
        else if(size1==12)
        {temp=asc2_1206[chr1][i];} //调用1206字体
        else if(size1==16)
        {temp=asc2_1608[chr1][i];} //调用1608字体
        else if(size1==24)
        {temp=asc2_2412[chr1][i];} //调用2412字体
        else return;
        for(m=0;m<8;m++)
        {
            if(temp&0x01)OLED_DrawPoint(x,y,mode);
            else OLED_DrawPoint(x,y,!mode);
            temp>>=1;
            y++;
        }
        x++;
        if((size1!=8)&&((x-x0)==size1/2))
        {x=x0;y0=y0+8;}
        y=y0;
  }
}


//显示字符串
//x,y:起点坐标  
//size1:字体大小 
//*chr:字符串起始地址 
//mode:0,反色显示;1,正常显示
void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1,u8 mode)
{
    while((*chr>=' ')&&(*chr<='~'))//判断是不是非法字符!
    {
        OLED_ShowChar(x,y,*chr,size1,mode);
        if(size1==8)x+=6;
        else x+=size1/2;
        chr++;
  }
}

//m^n
u32 OLED_Pow(u8 m,u8 n)
{
    u32 result=1;
    while(n--)
    {
      result*=m;
    }
    return result;
}

//显示数字
//x,y :起点坐标
//num :要显示的数字
//len :数字的位数
//size:字体大小
//mode:0,反色显示;1,正常显示
void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1,u8 mode)
{
    u8 t,temp,m=0;
    if(size1==8)m=2;
    for(t=0;t<len;t++)
    {
        temp=(num/OLED_Pow(10,len-t-1))%10;
            if(temp==0)
            {
                OLED_ShowChar(x+(size1/2+m)*t,y,'0',size1,mode);
      }
            else 
            {
              OLED_ShowChar(x+(size1/2+m)*t,y,temp+'0',size1,mode);
            }
  }
}

//显示汉字
//x,y:起点坐标
//num:汉字对应的序号
//mode:0,反色显示;1,正常显示
void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1,u8 mode)
{
    u8 m,temp;
    u8 x0=x,y0=y;
    u16 i,size3=(size1/8+((size1%8)?1:0))*size1;  //得到字体一个字符对应点阵集所占的字节数
    for(i=0;i<size3;i++)
    {
        if(size1==16)
                {temp=Hzk1[num][i];}//调用16*16字体
        else if(size1==24)
                {temp=Hzk2[num][i];}//调用24*24字体
        else if(size1==32)       
                {temp=Hzk3[num][i];}//调用32*32字体
        else if(size1==64)
                {temp=Hzk4[num][i];}//调用64*64字体
        else return;
        for(m=0;m<8;m++)
        {
            if(temp&0x01)OLED_DrawPoint(x,y,mode);
            else OLED_DrawPoint(x,y,!mode);
            temp>>=1;
            y++;
        }
        x++;
        if((x-x0)==size1)
        {x=x0;y0=y0+8;}
        y=y0;
    }
}

//num 显示汉字的个数
//space 每一遍显示的间隔
//mode:0,反色显示;1,正常显示
void OLED_ScrollDisplay(u8 num,u8 space,u8 mode)
{
    u8 i,n,t=0,m=0,r;
    while(1)
    {
        if(m==0)
        {
        OLED_ShowChinese(128,24,t,16,mode); //写入一个汉字保存在OLED_GRAM[][]数组中
            t++;
        }
        if(t==num)
            {
                for(r=0;r<16*space;r++)      //显示间隔
                 {
                    for(i=1;i<144;i++)
                        {
                            for(n=0;n<8;n++)
                            {
                                OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
                            }
                        }
           OLED_Refresh();
                 }
        t=0;
      }
        m++;
        if(m==16){m=0;}
        for(i=1;i<144;i++)   //实现左移
        {
            for(n=0;n<8;n++)
            {
                OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
            }
        }
        OLED_Refresh();
    }
}

//x,y：起点坐标
//sizex,sizey,图片长宽
//BMP[]：要写入的图片数组
//mode:0,反色显示;1,正常显示
void OLED_ShowPicture(u8 x,u8 y,u8 sizex,u8 sizey,u8 BMP[],u8 mode)
{
    u16 j=0;
    u8 i,n,temp,m;
    u8 x0=x,y0=y;
    sizey=sizey/8+((sizey%8)?1:0);
    for(n=0;n<sizey;n++)
    {
         for(i=0;i<sizex;i++)
         {
                temp=BMP[j];
                j++;
                for(m=0;m<8;m++)
                {
                    if(temp&0x01)OLED_DrawPoint(x,y,mode);
                    else OLED_DrawPoint(x,y,!mode);
                    temp>>=1;
                    y++;
                }
                x++;
                if((x-x0)==sizex)
                {
                    x=x0;
                    y0=y0+8;
                }
                y=y0;
     }
     }
}
//OLED的初始化
void OLED_Init(void)
{
  GPIO_InitTypeDef  GPIO_InitStructure;

    ////////////////// SCL
    RCC_AHB1PeriphClockCmd(SCL_PORT_RCC, ENABLE);
    //GPIO初始化设置
  GPIO_InitStructure.GPIO_Pin = SCL_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
  GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
  GPIO_Init(SCL_PORT, &GPIO_InitStructure);//初始化

    ////////////////// SDA
    RCC_AHB1PeriphClockCmd(SDA_PORT_RCC, ENABLE);
    //GPIO初始化设置
  GPIO_InitStructure.GPIO_Pin = SDA_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;//普通输出模式
  GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
  GPIO_Init(SDA_PORT, &GPIO_InitStructure);//初始化

    OLED_SCL_Clr();
    OLED_SDA_Clr();
//    OLED_RES_Clr();
//    delay_ms(200);
//    OLED_RES_Set();

    OLED_WR_Byte(0xAE,OLED_CMD);//--turn off oled panel
    OLED_WR_Byte(0x00,OLED_CMD);//---set low column address
    OLED_WR_Byte(0x10,OLED_CMD);//---set high column address
    OLED_WR_Byte(0x40,OLED_CMD);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
    OLED_WR_Byte(0x81,OLED_CMD);//--set contrast control register
    OLED_WR_Byte(0xCF,OLED_CMD);// Set SEG Output Current Brightness
    OLED_WR_Byte(0xA1,OLED_CMD);//--Set SEG/Column Mapping     0xa0左右反置 0xa1正常
    OLED_WR_Byte(0xC8,OLED_CMD);//Set COM/Row Scan Direction   0xc0上下反置 0xc8正常
    OLED_WR_Byte(0xA6,OLED_CMD);//--set normal display
    OLED_WR_Byte(0xA8,OLED_CMD);//--set multiplex ratio(1 to 64)
    OLED_WR_Byte(0x3f,OLED_CMD);//--1/64 duty
    OLED_WR_Byte(0xD3,OLED_CMD);//-set display offset    Shift Mapping RAM Counter (0x00~0x3F)
    OLED_WR_Byte(0x00,OLED_CMD);//-not offset
    OLED_WR_Byte(0xd5,OLED_CMD);//--set display clock divide ratio/oscillator frequency
    OLED_WR_Byte(0x80,OLED_CMD);//--set divide ratio, Set Clock as 100 Frames/Sec
    OLED_WR_Byte(0xD9,OLED_CMD);//--set pre-charge period
    OLED_WR_Byte(0xF1,OLED_CMD);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
    OLED_WR_Byte(0xDA,OLED_CMD);//--set com pins hardware configuration
    OLED_WR_Byte(0x12,OLED_CMD);
    OLED_WR_Byte(0xDB,OLED_CMD);//--set vcomh
    OLED_WR_Byte(0x40,OLED_CMD);//Set VCOM Deselect Level
    OLED_WR_Byte(0x20,OLED_CMD);//-Set Page Addressing Mode (0x00/0x01/0x02)
    OLED_WR_Byte(0x02,OLED_CMD);//
    OLED_WR_Byte(0x8D,OLED_CMD);//--set Charge Pump enable/disable
    OLED_WR_Byte(0x14,OLED_CMD);//--set(0x10) disable
    OLED_WR_Byte(0xA4,OLED_CMD);// Disable Entire Display On (0xa4/0xa5)
    OLED_WR_Byte(0xA6,OLED_CMD);// Disable Inverse Display On (0xa6/a7) 
    OLED_Clear();
    OLED_WR_Byte(0xAF,OLED_CMD);
}

STM32F4软件I2C封装

I2C封装

#ifndef __SOFT_I2C0_H__
#define __SOFT_I2C0_H__

#include "stm32f4xx.h"
#include "systick.h"


#define SCL_PORT_RCC    RCC_AHB1Periph_GPIOB
#define SCL_PORT            GPIOB
#define SCL_PIN                GPIO_Pin_6

#define SDA_PORT_RCC    RCC_AHB1Periph_GPIOB
#define SDA_PORT            GPIOB
#define SDA_PIN                GPIO_Pin_7


#define SCL(BIT)             GPIO_WriteBit(SCL_PORT, SCL_PIN, BIT?SET:RESET)
#define SDA(BIT)             GPIO_WriteBit(SDA_PORT, SDA_PIN, BIT?SET:RESET)
#define SDA_STATE()     GPIO_ReadInputDataBit(SDA_PORT, SDA_PIN)

#define SDA_IN()        {    GPIO_InitTypeDef  GPIO_InitStructure;    \
                                            GPIO_InitStructure.GPIO_Pin = SDA_PIN; \
                                            GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; \
                                            GPIO_Init(SDA_PORT, &GPIO_InitStructure);    }                                        
#define SDA_OUT()        {    GPIO_InitTypeDef  GPIO_InitStructure;    \
                                            GPIO_InitStructure.GPIO_Pin = SDA_PIN; \
                                            GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; \
                                            GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; \
                                            GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; \
                                            GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; \
                                            GPIO_Init(SDA_PORT, &GPIO_InitStructure); }


void SoftI2C0_init();
uint8_t SoftI2C0_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);
uint8_t SoftI2C0_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);

uint8_t SoftI2C0_write2(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t offset, uint32_t len);

#endif

#include "Soft_I2C0.h"


static void start();
static void stop();
static void send(uint8_t data);
static uint8_t recv();
static uint8_t wait_ack();
static void send_ack();
static void send_nack(); 


void SoftI2C0_init() {
        GPIO_InitTypeDef  GPIO_InitStructure;

        ////////////////// SCL
        RCC_AHB1PeriphClockCmd(SCL_PORT_RCC, ENABLE);
        //GPIO初始化设置
        GPIO_InitStructure.GPIO_Pin = SCL_PIN;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
        GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
        GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
        GPIO_Init(SCL_PORT, &GPIO_InitStructure);//初始化

        ////////////////// SDA
        RCC_AHB1PeriphClockCmd(SDA_PORT_RCC, ENABLE);
        //GPIO初始化设置
        GPIO_InitStructure.GPIO_Pin = SDA_PIN;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;//普通输出模式
        GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
        GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
        GPIO_Init(SDA_PORT, &GPIO_InitStructure);//初始化
}

uint8_t SoftI2C0_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
    start();

    send(addr << 1);            //发送设备写地址
    if(wait_ack()) return 1;    //等待响应

    send(reg);                    //发送寄存器地址
    if(wait_ack()) return 2;    //等待响应

    do {
        send(*data++);        
        if(wait_ack()) return 3;
    } while(--len);

    stop();
    return 0;
}

uint8_t SoftI2C0_write2(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t offset, uint32_t len) {
        start();

    send(addr << 1);            //发送设备写地址
    if(wait_ack()) return 1;    //等待响应

    send(reg);                    //发送寄存器地址
    if(wait_ack()) return 2;    //等待响应

    do {
        send(*data);
                data += offset;
        if(wait_ack()) return 3;
    } while(--len);

    stop();
    return 0;
}

uint8_t SoftI2C0_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
    start();

    send(addr << 1);                //发送设备写地址
    if(wait_ack()) return 1;        //等待响应

    send(reg);                        //发送寄存器地址
    if(wait_ack()) return 2;        //等待响应

    start();
    send((addr << 1) | 0x01);        //发送设备读地址
    if(wait_ack()) return 3;        //等待响应

    do {
        *data = recv();
        data++;
        if(len != 1) send_ack();    // 发送 NACK
    } while(--len);
    send_nack();                    // 发送 NACK
    stop();

    return 0;
}

static void start() {
    SDA_OUT();

    SDA(1);
    delay_1us(5);
    SCL(1);
    delay_1us(5);

    SDA(0);
    delay_1us(5);
    SCL(0);
    delay_1us(5);
}

static void stop() {
    SDA_OUT();

    SCL(0);
    SDA(0);

    SCL(1);
    delay_1us(5);
    SDA(1);
    delay_1us(5);
}

static void send(uint8_t data) {
    uint8_t i;
    SDA_OUT();

    for(i = 0; i < 8; i++) {
        if(data & 0x80) {
            SDA(1);
        } else {
            SDA(0);
        }
        SCL(1);
        delay_1us(5);
        SCL(0);
        delay_1us(5);
        data <<= 1;
    }
}

static uint8_t recv() {
    uint8_t i, data;
    SDA_IN();
    data = 0;
    for(i = 0; i < 8; i++) {
        SCL(0);
        delay_1us(5);
        SCL(1);
        delay_1us(5);

        data <<= 1;

        data |= SDA_STATE();

        delay_1us(5);
    }
    SCL(0);
    return data;
}

static uint8_t wait_ack() {
    int8_t retry = 10;

    SCL(0);
    SDA(1);
    SDA_IN();
    delay_1us(5);
    SCL(1);
    delay_1us(5);

    while(SDA_STATE() == 1 && retry > 0) {
        retry --;
        delay_1us(5);
    }

    if(retry <= 0) {
        stop();
        return 1;
    } else {
        SCL(0);
        SDA_OUT();
    }
    return 0;
}

static void send_ack() {
    SDA_OUT();
    SCL(0);
    SDA(0);
    delay_1us(5);

    SDA(0);

    SCL(1);
    delay_1us(5);
    SCL(0);
    SDA(1);
}

static void send_nack() {
    SDA_OUT();
    SCL(0);
    SDA(0);
    delay_1us(5);

    SDA(1);

    SCL(1);
    delay_1us(5);
    SCL(0);
    SDA(1);
}

驱动加减法

#ifndef __OLED_H
#define __OLED_H 

#include "stm32f4xx.h"
#include "stdlib.h"    
#include "Soft_I2C0.h"

#ifndef u8
#define u8 uint8_t
#endif

#ifndef u16
#define u16 uint16_t
#endif

#ifndef u32
#define u32 uint32_t
#endif


#define OLED_CMD  0    //写命令
#define OLED_DATA 1    //写数据

void OLED_ClearPoint(u8 x,u8 y);
void OLED_ColorTurn(u8 i);
void OLED_DisplayTurn(u8 i);
//void I2C_Start(void);
//void I2C_Stop(void);
//void I2C_WaitAck(void);
//void Send_Byte(u8 dat);
void OLED_WR_Byte(u8 dat,u8 mode);
void OLED_DisPlay_On(void);
void OLED_DisPlay_Off(void);
void OLED_Refresh(void);
void OLED_Clear(void);
void OLED_DrawPoint(u8 x,u8 y,u8 t);
void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2,u8 mode);
void OLED_DrawCircle(u8 x,u8 y,u8 r);
void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1,u8 mode);
void OLED_ShowChar6x8(u8 x,u8 y,u8 chr,u8 mode);
void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1,u8 mode);
void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1,u8 mode);
void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1,u8 mode);
void OLED_ScrollDisplay(u8 num,u8 space,u8 mode);
void OLED_ShowPicture(u8 x,u8 y,u8 sizex,u8 sizey,u8 BMP[],u8 mode);
void OLED_Init(void);

#endif

#include "oled.h"
#include "stdlib.h"
#include "oledfont.h"       
#include "systick.h"

u8 OLED_GRAM[144][8];

//反显函数
void OLED_ColorTurn(u8 i)
{
    if(i==0)
        {
            OLED_WR_Byte(0xA6,OLED_CMD);//正常显示
        }
    if(i==1)
        {
            OLED_WR_Byte(0xA7,OLED_CMD);//反色显示
        }
}

//屏幕旋转180度
void OLED_DisplayTurn(u8 i)
{
    if(i==0)
        {
            OLED_WR_Byte(0xC8,OLED_CMD);//正常显示
            OLED_WR_Byte(0xA1,OLED_CMD);
        }
    if(i==1)
        {
            OLED_WR_Byte(0xC0,OLED_CMD);//反转显示
            OLED_WR_Byte(0xA0,OLED_CMD);
        }
}

//延时
void IIC_delay(void)
{
//    u8 t=10;
//    while(t--);
        delay_1us(5);
}

////起始信号
//void I2C_Start(void)
//{
//    SDA_OUT();
//    
//    OLED_SDA_Set();
//    OLED_SCL_Set();
//    IIC_delay();
//    OLED_SDA_Clr();
//    IIC_delay();
//    OLED_SCL_Clr();
//    IIC_delay();
//}

////结束信号
//void I2C_Stop(void)
//{
//    SDA_OUT();
//    
//    OLED_SDA_Clr();
//    OLED_SCL_Set();
//    IIC_delay();
//    OLED_SDA_Set();
//}

////等待信号响应
//void I2C_WaitAck(void) //测数据信号的电平
//{
//    OLED_SDA_Set();
//    SDA_IN();
//    IIC_delay();
//    OLED_SCL_Set();
//    IIC_delay();
//    OLED_SCL_Clr();
//    SDA_OUT();
//    IIC_delay();
//}

////写入一个字节
//void Send_Byte(u8 dat)
//{
//    u8 i;
//    SDA_OUT();
//    
//    for(i=0;i<8;i++)
//    {
//        if(dat&0x80)//将dat的8位从最高位依次写入
//        {
//            OLED_SDA_Set();
//    }
//        else
//        {
//            OLED_SDA_Clr();
//    }
//        IIC_delay();
//        OLED_SCL_Set();
//        IIC_delay();
//        OLED_SCL_Clr();//将时钟信号设置为低电平
//        dat<<=1;
//  }
//}

//发送一个字节
//mode:数据/命令标志 0,表示命令;1,表示数据;
void OLED_WR_Byte(u8 dat,u8 mode)
{
//    I2C_Start();
//    Send_Byte(0x78);
//    I2C_WaitAck();
//    if(mode){Send_Byte(0x40);}
//  else{Send_Byte(0x00);}
//    I2C_WaitAck();
//    Send_Byte(dat);
//    I2C_WaitAck();
//    I2C_Stop();
        if(mode) {
                SoftI2C0_write(0x78 >> 1, 0x40, &dat, 1);
        } else {
                SoftI2C0_write(0x78 >> 1, 0x00, &dat, 1);
        }
}

//开启OLED显示 
void OLED_DisPlay_On(void)
{
    OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
    OLED_WR_Byte(0x14,OLED_CMD);//开启电荷泵
    OLED_WR_Byte(0xAF,OLED_CMD);//点亮屏幕
}

//关闭OLED显示 
void OLED_DisPlay_Off(void)
{
    OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
    OLED_WR_Byte(0x10,OLED_CMD);//关闭电荷泵
    OLED_WR_Byte(0xAE,OLED_CMD);//关闭屏幕
}

//更新显存到OLED    
void OLED_Refresh(void)
{
    u8 i,n;
    for(i=0;i<8;i++)
    {
        OLED_WR_Byte(0xb0+i,OLED_CMD); //设置行起始地址
        OLED_WR_Byte(0x00,OLED_CMD);   //设置低列起始地址
        OLED_WR_Byte(0x10,OLED_CMD);   //设置高列起始地址
//        I2C_Start();
//        Send_Byte(0x78);
//        I2C_WaitAck();
//        Send_Byte(0x40);
//        I2C_WaitAck();
//        for(n=0;n<128;n++)
//        {
//            Send_Byte(OLED_GRAM[n][i]);
//            I2C_WaitAck();
//        }
//        I2C_Stop();

        SoftI2C0_write2(0x78 >> 1, 0x40, &(OLED_GRAM[0][i]), 8, 128);
  }
}
//清屏函数
void OLED_Clear(void)
{
    u8 i,n;
    for(i=0;i<8;i++)
    {
       for(n=0;n<128;n++)
            {
             OLED_GRAM[n][i]=0;//清除所有数据
            }
  }
    OLED_Refresh();//更新显示
}

//画点 
//x:0~127
//y:0~63
//t:1 填充 0,清空    
void OLED_DrawPoint(u8 x,u8 y,u8 t)
{
    u8 i,m,n;
    i=y/8;
    m=y%8;
    n=1<<m;
    if(t){OLED_GRAM[x][i]|=n;}
    else
    {
        OLED_GRAM[x][i]=~OLED_GRAM[x][i];
        OLED_GRAM[x][i]|=n;
        OLED_GRAM[x][i]=~OLED_GRAM[x][i];
    }
}

//画线
//x1,y1:起点坐标
//x2,y2:结束坐标
void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2,u8 mode)
{
    u16 t; 
    int xerr=0,yerr=0,delta_x,delta_y,distance;
    int incx,incy,uRow,uCol;
    delta_x=x2-x1; //计算坐标增量 
    delta_y=y2-y1;
    uRow=x1;//画线起点坐标
    uCol=y1;
    if(delta_x>0)incx=1; //设置单步方向 
    else if (delta_x==0)incx=0;//垂直线 
    else {incx=-1;delta_x=-delta_x;}
    if(delta_y>0)incy=1;
    else if (delta_y==0)incy=0;//水平线 
    else {incy=-1;delta_y=-delta_x;}
    if(delta_x>delta_y)distance=delta_x; //选取基本增量坐标轴 
    else distance=delta_y;
    for(t=0;t<distance+1;t++)
    {
        OLED_DrawPoint(uRow,uCol,mode);//画点
        xerr+=delta_x;
        yerr+=delta_y;
        if(xerr>distance)
        {
            xerr-=distance;
            uRow+=incx;
        }
        if(yerr>distance)
        {
            yerr-=distance;
            uCol+=incy;
        }
    }
}
//x,y:圆心坐标
//r:圆的半径
void OLED_DrawCircle(u8 x,u8 y,u8 r)
{
    int a, b,num;
    a = 0;
    b = r;
    while(2 * b * b >= r * r)      
    {
        OLED_DrawPoint(x + a, y - b,1);
        OLED_DrawPoint(x - a, y - b,1);
        OLED_DrawPoint(x - a, y + b,1);
        OLED_DrawPoint(x + a, y + b,1);

        OLED_DrawPoint(x + b, y + a,1);
        OLED_DrawPoint(x + b, y - a,1);
        OLED_DrawPoint(x - b, y - a,1);
        OLED_DrawPoint(x - b, y + a,1);

        a++;
        num = (a * a + b * b) - r*r;//计算画的点离圆心的距离
        if(num > 0)
        {
            b--;
            a--;
        }
    }
}



//在指定位置显示一个字符,包括部分字符
//x:0~127
//y:0~63
//size1:选择字体 6x8/6x12/8x16/12x24
//mode:0,反色显示;1,正常显示
void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1,u8 mode)
{
    u8 i,m,temp,size2,chr1;
    u8 x0=x,y0=y;
    if(size1==8)size2=6;
    else size2=(size1/8+((size1%8)?1:0))*(size1/2);  //得到字体一个字符对应点阵集所占的字节数
    chr1=chr-' ';  //计算偏移后的值
    for(i=0;i<size2;i++)
    {
        if(size1==8)
              {temp=asc2_0806[chr1][i];} //调用0806字体
        else if(size1==12)
        {temp=asc2_1206[chr1][i];} //调用1206字体
        else if(size1==16)
        {temp=asc2_1608[chr1][i];} //调用1608字体
        else if(size1==24)
        {temp=asc2_2412[chr1][i];} //调用2412字体
        else return;
        for(m=0;m<8;m++)
        {
            if(temp&0x01)OLED_DrawPoint(x,y,mode);
            else OLED_DrawPoint(x,y,!mode);
            temp>>=1;
            y++;
        }
        x++;
        if((size1!=8)&&((x-x0)==size1/2))
        {x=x0;y0=y0+8;}
        y=y0;
  }
}


//显示字符串
//x,y:起点坐标  
//size1:字体大小 
//*chr:字符串起始地址 
//mode:0,反色显示;1,正常显示
void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1,u8 mode)
{
    while((*chr>=' ')&&(*chr<='~'))//判断是不是非法字符!
    {
        OLED_ShowChar(x,y,*chr,size1,mode);
        if(size1==8)x+=6;
        else x+=size1/2;
        chr++;
  }
}

//m^n
u32 OLED_Pow(u8 m,u8 n)
{
    u32 result=1;
    while(n--)
    {
      result*=m;
    }
    return result;
}

//显示数字
//x,y :起点坐标
//num :要显示的数字
//len :数字的位数
//size:字体大小
//mode:0,反色显示;1,正常显示
void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1,u8 mode)
{
    u8 t,temp,m=0;
    if(size1==8)m=2;
    for(t=0;t<len;t++)
    {
        temp=(num/OLED_Pow(10,len-t-1))%10;
            if(temp==0)
            {
                OLED_ShowChar(x+(size1/2+m)*t,y,'0',size1,mode);
      }
            else 
            {
              OLED_ShowChar(x+(size1/2+m)*t,y,temp+'0',size1,mode);
            }
  }
}

//显示汉字
//x,y:起点坐标
//num:汉字对应的序号
//mode:0,反色显示;1,正常显示
void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1,u8 mode)
{
    u8 m,temp;
    u8 x0=x,y0=y;
    u16 i,size3=(size1/8+((size1%8)?1:0))*size1;  //得到字体一个字符对应点阵集所占的字节数
    for(i=0;i<size3;i++)
    {
        if(size1==16)
                {temp=Hzk1[num][i];}//调用16*16字体
        else if(size1==24)
                {temp=Hzk2[num][i];}//调用24*24字体
        else if(size1==32)       
                {temp=Hzk3[num][i];}//调用32*32字体
        else if(size1==64)
                {temp=Hzk4[num][i];}//调用64*64字体
        else return;
        for(m=0;m<8;m++)
        {
            if(temp&0x01)OLED_DrawPoint(x,y,mode);
            else OLED_DrawPoint(x,y,!mode);
            temp>>=1;
            y++;
        }
        x++;
        if((x-x0)==size1)
        {x=x0;y0=y0+8;}
        y=y0;
    }
}

//num 显示汉字的个数
//space 每一遍显示的间隔
//mode:0,反色显示;1,正常显示
void OLED_ScrollDisplay(u8 num,u8 space,u8 mode)
{
    u8 i,n,t=0,m=0,r;
    while(1)
    {
        if(m==0)
        {
        OLED_ShowChinese(128,24,t,16,mode); //写入一个汉字保存在OLED_GRAM[][]数组中
            t++;
        }
        if(t==num)
            {
                for(r=0;r<16*space;r++)      //显示间隔
                 {
                    for(i=1;i<144;i++)
                        {
                            for(n=0;n<8;n++)
                            {
                                OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
                            }
                        }
           OLED_Refresh();
                 }
        t=0;
      }
        m++;
        if(m==16){m=0;}
        for(i=1;i<144;i++)   //实现左移
        {
            for(n=0;n<8;n++)
            {
                OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
            }
        }
        OLED_Refresh();
    }
}

//x,y：起点坐标
//sizex,sizey,图片长宽
//BMP[]：要写入的图片数组
//mode:0,反色显示;1,正常显示
void OLED_ShowPicture(u8 x,u8 y,u8 sizex,u8 sizey,u8 BMP[],u8 mode)
{
    u16 j=0;
    u8 i,n,temp,m;
    u8 x0=x,y0=y;
    sizey=sizey/8+((sizey%8)?1:0);
    for(n=0;n<sizey;n++)
    {
         for(i=0;i<sizex;i++)
         {
                temp=BMP[j];
                j++;
                for(m=0;m<8;m++)
                {
                    if(temp&0x01)OLED_DrawPoint(x,y,mode);
                    else OLED_DrawPoint(x,y,!mode);
                    temp>>=1;
                    y++;
                }
                x++;
                if((x-x0)==sizex)
                {
                    x=x0;
                    y0=y0+8;
                }
                y=y0;
     }
     }
}
//OLED的初始化
void OLED_Init(void)
{
//    OLED_RES_Clr();
//    delay_ms(200);
//    OLED_RES_Set();

    OLED_WR_Byte(0xAE,OLED_CMD);//--turn off oled panel
    OLED_WR_Byte(0x00,OLED_CMD);//---set low column address
    OLED_WR_Byte(0x10,OLED_CMD);//---set high column address
    OLED_WR_Byte(0x40,OLED_CMD);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
    OLED_WR_Byte(0x81,OLED_CMD);//--set contrast control register
    OLED_WR_Byte(0xCF,OLED_CMD);// Set SEG Output Current Brightness
    OLED_WR_Byte(0xA1,OLED_CMD);//--Set SEG/Column Mapping     0xa0左右反置 0xa1正常
    OLED_WR_Byte(0xC8,OLED_CMD);//Set COM/Row Scan Direction   0xc0上下反置 0xc8正常
    OLED_WR_Byte(0xA6,OLED_CMD);//--set normal display
    OLED_WR_Byte(0xA8,OLED_CMD);//--set multiplex ratio(1 to 64)
    OLED_WR_Byte(0x3f,OLED_CMD);//--1/64 duty
    OLED_WR_Byte(0xD3,OLED_CMD);//-set display offset    Shift Mapping RAM Counter (0x00~0x3F)
    OLED_WR_Byte(0x00,OLED_CMD);//-not offset
    OLED_WR_Byte(0xd5,OLED_CMD);//--set display clock divide ratio/oscillator frequency
    OLED_WR_Byte(0x80,OLED_CMD);//--set divide ratio, Set Clock as 100 Frames/Sec
    OLED_WR_Byte(0xD9,OLED_CMD);//--set pre-charge period
    OLED_WR_Byte(0xF1,OLED_CMD);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
    OLED_WR_Byte(0xDA,OLED_CMD);//--set com pins hardware configuration
    OLED_WR_Byte(0x12,OLED_CMD);
    OLED_WR_Byte(0xDB,OLED_CMD);//--set vcomh
    OLED_WR_Byte(0x40,OLED_CMD);//Set VCOM Deselect Level
    OLED_WR_Byte(0x20,OLED_CMD);//-Set Page Addressing Mode (0x00/0x01/0x02)
    OLED_WR_Byte(0x02,OLED_CMD);//
    OLED_WR_Byte(0x8D,OLED_CMD);//--set Charge Pump enable/disable
    OLED_WR_Byte(0x14,OLED_CMD);//--set(0x10) disable
    OLED_WR_Byte(0xA4,OLED_CMD);// Disable Entire Display On (0xa4/0xa5)
    OLED_WR_Byte(0xA6,OLED_CMD);// Disable Inverse Display On (0xa6/a7) 
    OLED_Clear();
    OLED_WR_Byte(0xAF,OLED_CMD);
}

去掉I2C处理的逻辑，将I2C和驱动分离，原因是，在整个系统中，I2C是总线，会外挂多个设备，不应该将一个设备和I2C绑死。

二维数组

uint8_t arr[4][5] = {
    {0, 1, 2, 3, 4},
    {10, 11, 12, 13, 14},
    {20, 21, 22, 23, 24},
    {30, 31, 32, 33, 34}
}

二维数组可以理解为一张表，上面的数组对应下面的内容：

0 1 2 3 4
10 11 12 13 14
20 21 22 23 24
30 31 32 33 34

在内存中的存储也是连续的，存储方式如下：

0 1 2 3 4 10 11 12 13 14 20 21 22 23 24 30 31 32 33 34

内存中是一行一行的进行存储的。
那么如果我想获得一个第1行第2列的值，可以如下方式获取：

arr[1][2];

如果想获得地址，也是一样的：

&arr[1][2];

如果我把第1行第2列这个指针给到你，我们该如何它对应的取值：

void current(uint8_t* p) {
    uint8_t data = *p;
}

current(&arr[1][2]);

如果我把第1行第2列这个指针给到你，我们该如何它下一行这个位置的值：

void next(uint8_t* p) {
    p += 5;
    uint8_t data = *p;
}
next(&arr[1][2]);

功能扩展

uint8_t SoftI2C0_write2(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t offset, uint32_t len) {
    start();

    send(addr << 1);            //发送设备写地址
    if(wait_ack()) return 1;    //等待响应

    send(reg);                    //发送寄存器地址
    if(wait_ack()) return 2;    //等待响应

    do {
        send(*data);
        data += offset;
        if(wait_ack()) return 3;
    } while(--len);

    stop();
    return 0;
}

由于OLED屏幕内部维护了一个二维数组，二维数组又是按照列去发送数据的，因此我们对数据发送逻辑进行修改操作。

测试

SoftI2C0_init();

u8 t=' ';
OLED_Init();

while(1) {
    OLED_ShowPicture(0,0,128,64,BMP1,1);
    OLED_Refresh();
    delay_1ms(500);
    OLED_Clear();
    OLED_ShowChinese(0,0,0,16,1);//中
    OLED_ShowChinese(18,0,1,16,1);//景
    OLED_ShowChinese(36,0,2,16,1);//园
    OLED_ShowChinese(54,0,3,16,1);//电
    OLED_ShowChinese(72,0,4,16,1);//子
    OLED_ShowChinese(90,0,5,16,1);//技
    OLED_ShowChinese(108,0,6,16,1);//术
    OLED_ShowString(8,16,"ZHONGJINGYUAN",16,1);
    OLED_ShowString(20,32,"2014/05/01",16,1);
    OLED_ShowString(0,48,"ASCII:",16,1);
    OLED_ShowString(63,48,"CODE:",16,1);
    OLED_ShowChar(48,48,t,16,1);//显示ASCII字符
    t++;
    if(t>'~')t=' ';
    OLED_ShowNum(103,48,t,3,16,1);
    OLED_Refresh();
    delay_1ms(500);
    OLED_Clear();
    OLED_ShowChinese(0,0,0,16,1);  //16*16 中
    OLED_ShowChinese(16,0,0,24,1); //24*24 中
    OLED_ShowChinese(24,20,0,32,1);//32*32 中
    OLED_ShowChinese(64,0,0,64,1); //64*64 中
    OLED_Refresh();
    delay_1ms(500);
    OLED_Clear();
    OLED_ShowString(0,0,"ABC",8,1);//6*8 “ABC”
    OLED_ShowString(0,8,"ABC",12,1);//6*12 “ABC”
    OLED_ShowString(0,20,"ABC",16,1);//8*16 “ABC”
    OLED_ShowString(0,36,"ABC",24,1);//12*24 “ABC”
    OLED_Refresh();
    delay_1ms(500);
    OLED_ScrollDisplay(11,4,1);
}

完整代码

I2C驱动代码

#include "Soft_I2C0.h"


static void start();
static void stop();
static void send(uint8_t data);
static uint8_t recv();
static uint8_t wait_ack();
static void send_ack();
static void send_nack(); 


void SoftI2C0_init() {
    GPIO_InitTypeDef  GPIO_InitStructure;

    ////////////////// SCL
    RCC_AHB1PeriphClockCmd(SCL_PORT_RCC, ENABLE);
    //GPIO初始化设置
    GPIO_InitStructure.GPIO_Pin = SCL_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
    GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
    GPIO_Init(SCL_PORT, &GPIO_InitStructure);//初始化

    ////////////////// SDA
    RCC_AHB1PeriphClockCmd(SDA_PORT_RCC, ENABLE);
    //GPIO初始化设置
    GPIO_InitStructure.GPIO_Pin = SDA_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;//普通输出模式
    GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//上拉
    GPIO_Init(SDA_PORT, &GPIO_InitStructure);//初始化
}

uint8_t SoftI2C0_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
    start();

    send(addr << 1);            //发送设备写地址
    if(wait_ack()) return 1;    //等待响应

    send(reg);                    //发送寄存器地址
    if(wait_ack()) return 2;    //等待响应

    do {
        send(*data++);        
        if(wait_ack()) return 3;
    } while(--len);

    stop();
    return 0;
}

uint8_t SoftI2C0_write2(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t offset, uint32_t len) {
    start();

    send(addr << 1);            //发送设备写地址
    if(wait_ack()) return 1;    //等待响应

    send(reg);                    //发送寄存器地址
    if(wait_ack()) return 2;    //等待响应

    do {
        send(*data);
        data += offset;
        if(wait_ack()) return 3;
    } while(--len);

    stop();
    return 0;
}

uint8_t SoftI2C0_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
    start();

    send(addr << 1);                //发送设备写地址
    if(wait_ack()) return 1;        //等待响应

    send(reg);                        //发送寄存器地址
    if(wait_ack()) return 2;        //等待响应

    start();
    send((addr << 1) | 0x01);        //发送设备读地址
    if(wait_ack()) return 3;        //等待响应

    do {
        *data = recv();
        data++;
        if(len != 1) send_ack();    // 发送 NACK
    } while(--len);
    send_nack();                    // 发送 NACK
    stop();

    return 0;
}

static void start() {
    SDA_OUT();

    SDA(1);
    delay_1us(5);
    SCL(1);
    delay_1us(5);

    SDA(0);
    delay_1us(5);
    SCL(0);
    delay_1us(5);
}

static void stop() {
    SDA_OUT();

    SCL(0);
    SDA(0);

    SCL(1);
    delay_1us(5);
    SDA(1);
    delay_1us(5);
}

static void send(uint8_t data) {
    uint8_t i;
    SDA_OUT();

    for(i = 0; i < 8; i++) {
        if(data & 0x80) {
            SDA(1);
        } else {
            SDA(0);
        }
        SCL(1);
        delay_1us(5);
        SCL(0);
        delay_1us(5);
        data <<= 1;
    }
}

static uint8_t recv() {
    uint8_t i, data;
    SDA_IN();
    data = 0;
    for(i = 0; i < 8; i++) {
        SCL(0);
        delay_1us(5);
        SCL(1);
        delay_1us(5);

        data <<= 1;

        data |= SDA_STATE();

        delay_1us(5);
    }
    SCL(0);
    return data;
}

static uint8_t wait_ack() {
    int8_t retry = 10;

    SCL(0);
    SDA(1);
    SDA_IN();
    delay_1us(5);
    SCL(1);
    delay_1us(5);

    while(SDA_STATE() == 1 && retry > 0) {
        retry --;
        delay_1us(5);
    }

    if(retry <= 0) {
        stop();
        return 1;
    } else {
        SCL(0);
        SDA_OUT();
    }
    return 0;
}

static void send_ack() {
    SDA_OUT();
    SCL(0);
    SDA(0);
    delay_1us(5);

    SDA(0);

    SCL(1);
    delay_1us(5);
    SCL(0);
    SDA(1);
}

static void send_nack() {
    SDA_OUT();
    SCL(0);
    SDA(0);
    delay_1us(5);

    SDA(1);

    SCL(1);
    delay_1us(5);
    SCL(0);
    SDA(1);
}

STM32F4
#ifndef __SOFT_I2C0_H__
#define __SOFT_I2C0_H__

#include "stm32f4xx.h"
#include "systick.h"


#define SCL_PORT_RCC    RCC_AHB1Periph_GPIOB
#define SCL_PORT            GPIOB
#define SCL_PIN                GPIO_Pin_6

#define SDA_PORT_RCC    RCC_AHB1Periph_GPIOB
#define SDA_PORT            GPIOB
#define SDA_PIN                GPIO_Pin_7


#define SCL(BIT)             GPIO_WriteBit(SCL_PORT, SCL_PIN, BIT?SET:RESET)
#define SDA(BIT)             GPIO_WriteBit(SDA_PORT, SDA_PIN, BIT?SET:RESET)
#define SDA_STATE()     GPIO_ReadInputDataBit(SDA_PORT, SDA_PIN)

#define SDA_IN()        {    GPIO_InitTypeDef  GPIO_InitStructure;    \
                                            GPIO_InitStructure.GPIO_Pin = SDA_PIN; \
                                            GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; \
                                            GPIO_Init(SDA_PORT, &GPIO_InitStructure);    }                                        
#define SDA_OUT()        {    GPIO_InitTypeDef  GPIO_InitStructure;    \
                                            GPIO_InitStructure.GPIO_Pin = SDA_PIN; \
                                            GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; \
                                            GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; \
                                            GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; \
                                            GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; \
                                            GPIO_Init(SDA_PORT, &GPIO_InitStructure); }


void SoftI2C0_init();
uint8_t SoftI2C0_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);
uint8_t SoftI2C0_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);

uint8_t SoftI2C0_write2(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t offset, uint32_t len);

#endif

GD32F4
#ifndef __SOFT_I2C0_H__
#define __SOFT_I2C0_H__

#include "gd32f4xx.h"
#include "systick.h"


#define SCL_RCU        RCU_GPIOB
#define SCL_PORT    GPIOB
#define SCL_PIN        GPIO_PIN_6
#define SCL_AF        GPIO_AF_4

#define SDA_RCU        RCU_GPIOB
#define SDA_PORT    GPIOB
#define SDA_PIN        GPIO_PIN_7
#define SDA_AF        GPIO_AF_4

/************** io ***************/
#define SCL(BIT)             gpio_bit_write(SCL_PORT, SCL_PIN, BIT?SET:RESET)
#define SDA(BIT)             gpio_bit_write(SDA_PORT, SDA_PIN, BIT?SET:RESET)
#define SDA_STATE()     gpio_input_bit_get(SDA_PORT, SDA_PIN)

#define SDA_IN()          gpio_mode_set(SDA_PORT, GPIO_MODE_INPUT,  GPIO_PUPD_NONE, SDA_PIN)
#define SDA_OUT()         gpio_mode_set(SDA_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, SDA_PIN)


void SoftI2C0_init();
uint8_t SoftI2C0_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);
uint8_t SoftI2C0_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);
uint8_t SoftI2C0_write2(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t offset, uint32_t len);


#endif

练习题

  1. 实现软件i2c显示
  2. 实现硬件i2c显示