logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

高通字库芯片GT20L16S1Y驱动 0.96寸 OLED 任意显示中文

 rookie 2021-05-14

连续两个月的加班，给ODM客户生产温控器订单，今天终于顺利发货，对于工程师出身的我，终于可以对着电脑，消停几天，研究技术，分享技术了，闲话少说，直接进入正题：

半年前有个老客户介绍个中央某院的项目，我主业是做各种温控器的，老客户介绍的新客户，没法推脱，就干吧，项目需求具体细节不方便公开，说说本次要分享的部分，要实现的功能是一个OLED任意显示一段中文句子。

项目的硬件组成比较简单：STM8L051+ KEY + OLED + GT20L16S1Y

软件平台：IAR

整个项目没什么难点，但没做过这个的，也需要一番折腾，在这里，我把项目的主要代码贴出来供电友们参考，也感谢之前版本的电友。做个靠谱的电友，除了分享单独的.c.h驱动文件，最后还会有调用伪代码，也就是整个代码的调用过程。

一：高通字库芯片驱动程序：

  1. // .c文件
  3. #include "stm8l15x.h"//STM8L051/151等系列共用库函数
  4. #include "GT20L16S1Y.h"
  6. #define S1Y_CLK_L   (GPIO_ResetBits(GPIOB,GPIO_Pin_4))     
  7. #define S1Y_CLK_H   (GPIO_SetBits(GPIOB,GPIO_Pin_4))     
  9. #define S1Y_CS_L    (GPIO_ResetBits(GPIOB,GPIO_Pin_5))
  10. #define S1Y_CS_H    (GPIO_SetBits(GPIOB,GPIO_Pin_5))
  12. #define S1Y_SI_L    (GPIO_ResetBits(GPIOB,GPIO_Pin_6))
  13. #define S1Y_SI_H    (GPIO_SetBits(GPIOB,GPIO_Pin_6))
  15. #define S1Y_SO      GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_7)
  17. void GT20L16_init(void)
  18. {
  19.   /* GT20L16S1Y 引脚配置 */
  20.   GPIO_Init(GPIOB, GPIO_Pin_4, GPIO_Mode_Out_PP_Low_Fast);  //高速推挽输出低电平[SCLK]
  21.   GPIO_Init(GPIOB, GPIO_Pin_5, GPIO_Mode_Out_PP_Low_Fast);  //高速推挽输出低电平[CS]
  22.   GPIO_Init(GPIOB, GPIO_Pin_6, GPIO_Mode_Out_PP_Low_Fast);  //高速推挽输出低电平[SI]
  23.   GPIO_Init(GPIOB, GPIO_Pin_7, GPIO_Mode_In_PU_No_IT);      //上拉输入[SO]
  24. }
  27. /***************************************
  28. ASCII 调用
  29. ASCIICode：表示ASCII 码（8bits）
  30. BaseAdd：说明该套字库在芯片中的起始地址。
  31. r_dat_bat： 是读点阵数据函数。
  32. DZ_Data：是保存读出的点阵数据的数组。
  33. ****************************************/
  34. u8  S1Y_ASCII_GetData( u8 ASCIICode, u32 BaseAdd, u8* S1YDZ_Data )
  35. {
  36.     if( ( ASCIICode >= 0x20 ) && ( ASCIICode <= 0x7e ) )
  37.     {
  38.         switch( BaseAdd )
  39.         {
  40.             case 0x3bfc0:
  41.                 S1Y_rdat_bat( ( ASCIICode - 0x20 ) * 8 + BaseAdd, 8, S1YDZ_Data ); //5X7
  42.                 break ;
  43.             case 0x66c0:
  44.                 S1Y_rdat_bat( ( ASCIICode - 0x20 ) * 8 + BaseAdd, 8, S1YDZ_Data ); //7X8
  45.                 break ;
  46.             case 0x3b7c0:
  47.                 S1Y_rdat_bat( ( ASCIICode - 0x20 ) * 16 + BaseAdd, 16, S1YDZ_Data ); //8X16 A
  48.                 break ;
  49.             case 0x3cf80:
  50.                 S1Y_rdat_bat( ( ASCIICode - 0x20 ) * 26 + BaseAdd, 16, S1YDZ_Data ); //8X16 F
  51.                 break ;
  52.             case 0x3c2c0:
  53.                 S1Y_rdat_bat( ( ASCIICode - 0x20 ) * 34 + BaseAdd + 2, 32, S1YDZ_Data ); //16X16 Arial
  54.                 break ;
  55.             case 0x3d580:
  56.                 S1Y_rdat_bat( ( ASCIICode - 0x20 ) * 34 + BaseAdd + 2, 32, S1YDZ_Data ); //16X16 T
  57.                 break ;
  58.             default:
  59.                 break;
  60.         }
  61.         return 1;
  62.     }
  63.     else
  64.     {
  65.         return 0;
  66.     }
  67. }
  70. /***************************************************
  71. 16 点GB2312 标准点阵字库
  72. 参数说明：
  73. GBCode表示汉字内码。
  74. MSB 表示汉字内码GBCode 的高8bits。
  75. LSB 表示汉字内码GBCode 的低8bits。
  76. Address 表示汉字或ASCII字符点阵在芯片中的字节地址。
  77. BaseAdd：说明点阵数据在字库芯片中的起始地址。
  78. r_dat_bat 是读点阵数据函数。
  79. DZ_Data是保存读出的点阵数据的数组。
  80. *****************************************************/
  81. void S1Y_gt16_GetData( u8 MSB, u8 LSB, u8* S1YDZ_Data )
  82. {
  83.     u32 temp = ( MSB - 0xB0 ) * 94 + LSB - 0xA1;
  84.     u32 BaseAdd = 0, Address;
  85.     if( MSB == 0xA9 && LSB >= 0xA1 )
  86.     {
  87.         Address = ( 282 + ( LSB - 0xA1 ) ) * 32 + BaseAdd;
  88.     }
  89.     else if( MSB >= 0xA1 && MSB <= 0xA3 && LSB >= 0xA1 )
  90.     {
  91.         Address = ( ( MSB - 0xA1 ) * 94 + ( LSB - 0xA1 ) ) * 32 + BaseAdd;
  92.     }
  93.     else if( MSB >= 0xB0 && MSB <= 0xF7 && LSB >= 0xA1 )
  94.     {
  95.         Address = ( 846 + temp ) * 32 + BaseAdd;
  96.     }
  97.     S1Y_rdat_bat( Address, 32, S1YDZ_Data );
  98. }
  99. //Address=((MSB-0xB0)*94+(LSB-0xA1)+846)*32+BaseAdd;
  101. /****************************************************
  102. 8X16 点国标扩展字符
  103. 说明：
  104. BaseAdd：说明本套字库在字库芯片中的起始字节地址。
  105. FontCode：表示字符内码（16bits）.
  106. Address：表示字符点阵在芯片中的字节地址。
  107. r_dat_bat 是读点阵数据函数。
  108. DZ_Data是保存读出的点阵数据的数组。
  109. *****************************************************/
  110. void S1Y_GB_EXT_816( u16 FontCode, u8* S1YDZ_Data )
  111. {
  112.     u32 BaseAdd = 0x3b7d0, Address;
  113.     u32 temp1 = ( FontCode - 0xAAA1 );
  114.     u32 temp2 = ( FontCode - 0xABA1 + 95 );
  115.     if( FontCode >= 0xAAA1 && FontCode <= 0xAAFE )
  116.     {
  117.         Address = temp1 * 16 + BaseAdd;
  118.     }
  119.     else if( FontCode >= 0xABA1 && FontCode <= 0xABC0 )
  120.     {
  121.         Address = temp2 * 16 + BaseAdd;
  122.     }
  123.     S1Y_rdat_bat( Address, 16, S1YDZ_Data );
  124. }
  126. /****************************************************
  127. 从字库中读数据函数
  128. 说明：
  129. Address  ： 表示字符点阵在芯片中的字节地址。
  130. byte_long： 是读点阵数据字节数。
  131. *p_arr   ： 是保存读出的点阵数据的数组。
  132. *****************************************************/
  133. u8 S1Y_rdat_bat( u32 address, u8 byte_long, u8* p_arr )
  134. {
  135.     unsigned int j = 0;
  136.     S1Y_CS_L;
  137.     S1Y_SendByte( address );
  138.     for( j = 0; j < byte_long; j++ )
  139.     {
  140.         p_arr[j] = S1Y_ReadByte();
  141.     }
  142.     S1Y_CS_H;
  143.     return p_arr[0];
  144. }
  146. void S1Y_SendByte( u32 cmd )
  147. {
  148.     u8 i;
  149.     cmd = cmd | 0x03000000;
  150.     for( i = 0; i < 32; i++ )
  151.     {
  152.         S1Y_CLK_L;
  153.         if( cmd & 0x80000000 )
  154.         {
  155.             S1Y_SI_H;
  156.         }
  157.         else
  158.         {
  159.             S1Y_SI_L;
  160.         }
  161.         S1Y_CLK_H;
  162.         cmd = cmd << 1;
  163.     }
  164. }
  165. u8 S1Y_ReadByte( void )
  166. {
  167.     u8 i;
  168.     u8 dat = 0;
  169.     S1Y_CLK_H;
  170.     for( i = 0; i < 8; i++ )
  171.     {
  172.         S1Y_CLK_L;
  173.         dat = dat << 1;
  174.         if( S1Y_SO )
  175.         {
  176.             dat = dat | 0x01;
  177.         }
  178.         else
  179.         {
  180.             dat &= 0xfe;
  181.         }
  182.         S1Y_CLK_H   ;
  183.     }
  184.     return dat;
  185. }
  186. //-------------------------------------分割线---------------------------------
  187. //.h 文件
  189. #ifndef _GT20L16S1Y_H_
  190. #define _GT20L16S1Y_H_
  192. void S1Y_SendByte(u32 cmd);
  193. u8  S1Y_ReadByte(void);
  194. u8  S1Y_rdat_bat(u32 address,u8 byte_long,u8 *p_arr);
  196. u8  S1Y_ASCII_GetData(u8 ASCIICode,u32 BaseAdd,u8 *S1YDZ_Data);
  197. void S1Y_gt16_GetData (u8 MSB,u8 LSB,u8 *S1YDZ_Data);
  198. void S1Y_GB_EXT_816(u16 FontCode,u8 *S1YDZ_Data);
  200. void GT20L16_init(void);
  202. #endif

OLED显示就比较简单了，显示任意汉字字符串，也折腾了我几根头发，下面也贴出来分享一下：

  1. // .c文件
  2. #include "oled.h"
  3. #include "oledfont.h"
  4. #include "GT20L16S1Y.h"
  6. //OLED的显存
  7. //存放格式如下.
  8. //[0]0 1 2 3 ... 127
  9. //[1]0 1 2 3 ... 127
  10. //[2]0 1 2 3 ... 127
  11. //[3]0 1 2 3 ... 127
  12. //[4]0 1 2 3 ... 127
  13. //[5]0 1 2 3 ... 127
  14. //[6]0 1 2 3 ... 127
  15. //[7]0 1 2 3 ... 127
  16. void delay_ms( unsigned int ms )
  17. {
  18.     unsigned int a;
  19.     while( ms )
  20.     {
  21.         a = 1800;
  22.         while( a-- );
  23.         ms--;
  24.     }
  25.     return;
  26. }
  28. //反显函数
  29. void OLED_ColorTurn( u8 i )
  30. {
  31.     if( i == 0 )
  32.     {
  33.         OLED_WR_Byte( 0xA6, OLED_CMD ); //正常显示
  34.     }
  35.     if( i == 1 )
  36.     {
  37.         OLED_WR_Byte( 0xA7, OLED_CMD ); //反色显示
  38.     }
  39. }
  41. //屏幕旋转180度
  42. void OLED_DisplayTurn( u8 i )
  43. {
  44.     if( i == 0 )
  45.     {
  46.         OLED_WR_Byte( 0xC8, OLED_CMD ); //正常显示
  47.         OLED_WR_Byte( 0xA1, OLED_CMD );
  48.     }
  49.     if( i == 1 )
  50.     {
  51.         OLED_WR_Byte( 0xC0, OLED_CMD ); //反转显示
  52.         OLED_WR_Byte( 0xA0, OLED_CMD );
  53.     }
  54. }
  57. //延时
  58. void IIC_delay( void )
  59. {
  60.     u8 t = 1;
  61.     while( t-- );
  62. }
  64. //起始信号
  65. void I2C_Start( void )
  66. {
  67.     OLED_SDA_Set();
  68.     OLED_SCL_Set();
  69.     IIC_delay();
  70.     OLED_SDA_Clr();
  71.     IIC_delay();
  72.     OLED_SCL_Clr();
  73. }
  75. //结束信号
  76. void I2C_Stop( void )
  77. {
  78.     OLED_SDA_Clr();
  79.     OLED_SCL_Set();
  80.     IIC_delay();
  81.     OLED_SDA_Set();
  82. }
  84. //等待信号响应
  85. void I2C_WaitAck( void ) //测数据信号的电平
  86. {
  87.     OLED_SDA_Set();
  88.     IIC_delay();
  89.     OLED_SCL_Set();
  90.     IIC_delay();
  91.     OLED_SCL_Clr();
  92.     IIC_delay();
  93. }
  95. //写入一个字节
  96. void Send_Byte( u8 dat )
  97. {
  98.     u8 i;
  99.     for( i = 0; i < 8; i++ )
  100.     {
  101.         OLED_SCL_Clr();//将时钟信号设置为低电平
  102.         if( dat & 0x80 ) //将dat的8位从最高位依次写入
  103.         {
  104.             OLED_SDA_Set();
  105.         }
  106.         else
  107.         {
  108.             OLED_SDA_Clr();
  109.         }
  110.         IIC_delay();
  111.         OLED_SCL_Set();
  112.         IIC_delay();
  113.         OLED_SCL_Clr();
  114.         dat <<= 1;
  115.     }
  116. }
  118. //发送一个字节
  119. //向SSD1306写入一个字节。
  120. //mode:数据/命令标志 0,表示命令;1,表示数据;
  121. void OLED_WR_Byte( u8 dat, u8 mode )
  122. {
  123.     I2C_Start();
  124.     Send_Byte( 0x78 );
  125.     I2C_WaitAck();
  126.     if( mode )
  127.     {
  128.         Send_Byte( 0x40 );
  129.     }
  130.     else
  131.     {
  132.         Send_Byte( 0x00 );
  133.     }
  134.     I2C_WaitAck();
  135.     Send_Byte( dat );
  136.     I2C_WaitAck();
  137.     I2C_Stop();
  138. }
  140. //坐标设置
  142. void OLED_Set_Pos( u8 x, u8 y )
  143. {
  144.     OLED_WR_Byte( 0xb0 + y, OLED_CMD );
  145.     OLED_WR_Byte( ( ( x & 0xf0 ) >> 4 ) | 0x10, OLED_CMD );
  146.     OLED_WR_Byte( ( x & 0x0f ), OLED_CMD );
  147. }
  148. //开启OLED显示
  149. void OLED_Display_On( void )
  150. {
  151.     OLED_WR_Byte( 0X8D, OLED_CMD ); //SET DCDC命令
  152.     OLED_WR_Byte( 0X14, OLED_CMD ); //DCDC ON
  153.     OLED_WR_Byte( 0XAF, OLED_CMD ); //DISPLAY ON
  154. }
  155. //关闭OLED显示
  156. void OLED_Display_Off( void )
  157. {
  158.     OLED_WR_Byte( 0X8D, OLED_CMD ); //SET DCDC命令
  159.     OLED_WR_Byte( 0X10, OLED_CMD ); //DCDC OFF
  160.     OLED_WR_Byte( 0XAE, OLED_CMD ); //DISPLAY OFF
  161. }
  162. //清屏函数,清完屏,整个屏幕是黑色的!和没点亮一样!!!
  163. void OLED_Clear( void )
  164. {
  165.     u8 i, n;
  166.     for( i = 0; i < 4; i++ )
  167.     {
  168.         OLED_WR_Byte( 0xb0 + i, OLED_CMD ); //设置页地址（0~7）
  169.         OLED_WR_Byte( 0x00, OLED_CMD );    //设置显示位置—列低地址
  170.         OLED_WR_Byte( 0x10, OLED_CMD );    //设置显示位置—列高地址
  171.         for( n = 0; n < 128; n++ )
  172.         {
  173.             OLED_WR_Byte( 0, OLED_DATA );
  174.         }
  175.     } //更新显示
  176. }
  178. //在指定位置显示一个字符,包括部分字符
  179. //x:0~127
  180. //y:0~63
  181. //sizey:选择字体 6x8  8x16
  182. void OLED_ShowChar( u8 x, u8 y, u8 chr, u8 sizey )
  183. {
  184.     u8 c = 0, sizex = sizey / 2;
  185.     u16 i = 0, size1;
  186.     if( sizey == 8 )
  187.     {
  188.         size1 = 6;
  189.     }
  190.     else
  191.     {
  192.         size1 = ( sizey / 8 + ( ( sizey % 8 ) ? 1 : 0 ) ) * ( sizey / 2 );
  193.     }
  194.     c = chr - ' '; //得到偏移后的值
  195.     OLED_Set_Pos( x, y );
  196.     for( i = 0; i < size1; i++ )
  197.     {
  198.         if( i % sizex == 0 && sizey != 8 )
  199.         {
  200.             OLED_Set_Pos( x, y++ );
  201.         }
  202.         if( sizey == 8 )
  203.         {
  204.             OLED_WR_Byte( asc2_0806[c][i], OLED_DATA );    //6X8字号
  205.         }
  206.         else if( sizey == 16 )
  207.         {
  208.             OLED_WR_Byte( asc2_1608[c][i], OLED_DATA );    //8x16字号
  209.         }
  210.         //      else if(sizey==xx) OLED_WR_Byte(asc2_xxxx[c][i],OLED_DATA);//用户添加字号
  211.         else
  212.         {
  213.             return;
  214.         }
  215.     }
  216. }
  217. //m^n函数
  218. u32 oled_pow( u8 m, u8 n )
  219. {
  220.     u32 result = 1;
  221.     while( n-- )
  222.     {
  223.         result *= m;
  224.     }
  225.     return result;
  226. }
  227. //显示数字
  228. //x,y :起点坐标
  229. //num:要显示的数字
  230. //len :数字的位数
  231. //sizey:字体大小
  232. void OLED_ShowNum( u8 x, u8 y, u32 num, u8 len, u8 sizey )
  233. {
  234.     u8 t, temp, m = 0;
  235.     u8 enshow = 0;
  236.     if( sizey == 8 )
  237.     {
  238.         m = 2;
  239.     }
  240.     for( t = 0; t < len; t++ )
  241.     {
  242.         temp = ( num / oled_pow( 10, len - t - 1 ) ) % 10;
  243.         if( enshow == 0 && t < ( len - 1 ) )
  244.         {
  245.             if( temp == 0 )
  246.             {
  247.                 OLED_ShowChar( x + ( sizey / 2 + m )*t, y, ' ', sizey );
  248.                 continue;
  249.             }
  250.             else
  251.             {
  252.                 enshow = 1;
  253.             }
  254.         }
  255.         OLED_ShowChar( x + ( sizey / 2 + m )*t, y, temp + '0', sizey );
  256.     }
  257. }
  258. //显示一个字符号串
  259. void OLED_ShowString( u8 x, u8 y, u8* chr, u8 sizey )
  260. {
  261.     u8 j = 0;
  262.     while( chr[j] != '\0' )
  263.     {
  264.         OLED_ShowChar( x, y, chr[j++], sizey );
  265.         if( sizey == 8 )
  266.         {
  267.             x += 6;
  268.         }
  269.         else
  270.         {
  271.             x += sizey / 2;
  272.         }
  273.     }
  274. }
  275. //显示汉字
  276. void OLED_ShowChinese( u8 x, u8 y, u8 *temp, u8 sizey )
  277. {
  278.     u16 i, size1 = ( sizey / 8 + ( ( sizey % 8 ) ? 1 : 0 ) ) * sizey;
  279.     for( i = 0; i < size1; i++ )
  280.     {
  281.         if( i % sizey == 0 )
  282.         {
  283.             OLED_Set_Pos( x, y++ );
  284.         }
  285.         if( sizey == 16 )
  286.         {
  287.             OLED_WR_Byte( temp[i], OLED_DATA );    //16x16字号
  288.         }
  289.         //      else if(sizey==xx) OLED_WR_Byte(xxx[c][i],OLED_DATA);//用户添加字号
  290.         else
  291.         {
  292.             return;
  293.         }
  294.     }
  295. }
  296. //----------------------------------------------------------
  297. //显示一个gb2312汉字（从字库读数据）
  298. void OLED_ShowGB2312(unsigned char x,unsigned char y,unsigned char textH,unsigned char textL)
  299. {
  301.   unsigned char fontbuf[32];
  303.   S1Y_gt16_GetData(textH,textL,fontbuf);
  304.   OLED_ShowChinese( x, y, fontbuf, 16 );
  305. //  OLED_Set_Pos(x,y);
  306. //  for(t=0;t<16;t++)
  307. //    OLED_WR_Byte(fontbuf[t],OLED_DATA);
  308. //  OLED_Set_Pos(x,y+1);
  309. //  for(t=0;t<16;t++)
  310. //    OLED_WR_Byte(fontbuf[t+16],OLED_DATA);
  311. }
  312. void OLED_ShowStr(unsigned char x,unsigned char y,unsigned char* text)
  313. {
  314.   unsigned char i=0;
  315.   while((text[i]>0x00))
  316.   {
  317.     if(((text[i]>=0xb0) &&(text[i]<=0xf7))&&(text[i+1]>=0xa1))
  318.     {
  319.       OLED_ShowGB2312(x,y,text[i],text[i+1]);
  320.       i+=2;
  321.       x+=16;
  322.     }
  323.     else if((text[i]>=0x20) && (text[i]<=0x7e))
  324.     {
  325.       //OLED_ShowASCII(x,y,text[i]);
  326.       i+=1;
  327.       x+=8;
  328.     }
  329.     else
  330.       i++;
  331.   }
  332. }
  333. //--------------------------------------------------------------------
  334. //显示图片
  335. //x,y显示坐标
  336. //sizex,sizey,图片长宽
  337. //BMP：要显示的图片
  338. void OLED_DrawBMP( u8 x, u8 y, u8 sizex, u8 sizey, u8 BMP[] )
  339. {
  340.     u16 j = 0;
  341.     u8 i, m;
  342.     sizey = sizey / 8 + ( ( sizey % 8 ) ? 1 : 0 );
  343.     for( i = 0; i < sizey; i++ )
  344.     {
  345.         OLED_Set_Pos( x, i + y );
  346.         for( m = 0; m < sizex; m++ )
  347.         {
  348.             OLED_WR_Byte( BMP[j++], OLED_DATA );
  349.         }
  350.     }
  351. }
  355. //初始化
  356. void OLED_Init( void )
  357. {
  358.   GPIO_Init( OLED_PORT,OLED_SCL,GPIO_Mode_Out_PP_High_Fast );
  359.   GPIO_Init( OLED_PORT,OLED_SDA,GPIO_Mode_Out_PP_High_Fast );
  361.     OLED_WR_Byte( 0xAE, OLED_CMD ); /*display off*/
  362.     OLED_WR_Byte( 0x00, OLED_CMD ); /*set lower column address*/
  363.     OLED_WR_Byte( 0x10, OLED_CMD ); /*set higher column address*/
  364.     OLED_WR_Byte( 0x00, OLED_CMD ); /*set display start line*/
  365.     OLED_WR_Byte( 0xB0, OLED_CMD ); /*set page address*/
  366.     OLED_WR_Byte( 0x81, OLED_CMD ); /*contract control*/
  367.     OLED_WR_Byte( 0xff, OLED_CMD ); /*128*/
  368.     OLED_WR_Byte( 0xA1, OLED_CMD ); /*set segment remap*/
  369.     OLED_WR_Byte( 0xA6, OLED_CMD ); /*normal / reverse*/
  370.     OLED_WR_Byte( 0xA8, OLED_CMD ); /*multiplex ratio*/
  371.     OLED_WR_Byte( 0x1F, OLED_CMD ); /*duty = 1/32*/
  372.     OLED_WR_Byte( 0xC8, OLED_CMD ); /*Com scan direction*/
  373.     OLED_WR_Byte( 0xD3, OLED_CMD ); /*set display offset*/
  374.     OLED_WR_Byte( 0x00, OLED_CMD );
  375.     OLED_WR_Byte( 0xD5, OLED_CMD ); /*set osc division*/
  376.     OLED_WR_Byte( 0x80, OLED_CMD );
  377.     OLED_WR_Byte( 0xD9, OLED_CMD ); /*set pre-charge period*/
  378.     OLED_WR_Byte( 0x1f, OLED_CMD );
  379.     OLED_WR_Byte( 0xDA, OLED_CMD ); /*set COM pins*/
  380.     OLED_WR_Byte( 0x00, OLED_CMD );
  381.     OLED_WR_Byte( 0xdb, OLED_CMD ); /*set vcomh*/
  382.     OLED_WR_Byte( 0x40, OLED_CMD );
  383.     OLED_WR_Byte( 0x8d, OLED_CMD ); /*set charge pump enable*/
  384.     OLED_WR_Byte( 0x14, OLED_CMD );
  385.     OLED_Clear();
  386.     OLED_WR_Byte( 0xAF, OLED_CMD ); /*display ON*/
  387. }
  389. //-----------------------------------分割线------------------------------------------
  391. // .h文件
  392. #ifndef __OLED_H
  393. #define __OLED_H
  395. #include "stm8l15x.h"//STM8L051/151等系列共用库函数   
  397. #define  u8 unsigned char 
  398. #define  u16 unsigned int
  399. #define  u32 unsigned int
  401. #define OLED_CMD  0//写命令
  402. #define OLED_DATA 1//写数据
  404. #define  OLED_PORT     GPIOC//SCL
  407.  老板子线：
  408. //#define  OLED_SCL      GPIO_Pin_1//SCL
  409. //#define  OLED_SDA      GPIO_Pin_0//SDA
  411. // 新板子线：
  412. #define  OLED_SCL      GPIO_Pin_0//SCL
  413. #define  OLED_SDA      GPIO_Pin_1//SDA
  415. //-----------------OLED端口定义----------------
  418. #define OLED_SCL_Clr()          GPIO_ResetBits(OLED_PORT, OLED_SCL)//SCL IIC接口的数据信号
  419. #define OLED_SCL_Set()          GPIO_SetBits(OLED_PORT, OLED_SCL)
  421. #define OLED_SDA_Clr()          GPIO_ResetBits(OLED_PORT, OLED_SDA )//SDA IIC接口的时钟信号
  422. #define OLED_SDA_Set()          GPIO_SetBits(OLED_PORT, OLED_SDA )
  425. //--------------------------------------------------
  428. //OLED控制用函数
  429. void delay_ms(unsigned int ms);
  430. void OLED_ColorTurn(u8 i);
  431. void OLED_DisplayTurn(u8 i);
  432. void OLED_WR_Byte(u8 dat,u8 cmd);
  433. void OLED_Set_Pos(u8 x, u8 y);
  434. void OLED_Display_On(void);
  435. void OLED_Display_Off(void);
  436. void OLED_Clear(void);
  437. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 sizey);
  438. u32 oled_pow(u8 m,u8 n);
  439. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 sizey);
  440. void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 sizey);
  441. //void OLED_ShowChinese(u8 x,u8 y,u8 no,u8 sizey);
  442. void OLED_ShowChinese( u8 x, u8 y, u8 *temp, u8 sizey );
  443. void OLED_DrawBMP(u8 x,u8 y,u8 sizex, u8 sizey,u8 BMP[]);
  444. void OLED_Init(void);
  446. void OLED_ShowStr(unsigned char x,unsigned char y,unsigned char* text);
  448. #endif

最后是调用过程伪代码：

  1. // 调用显示任意汉字字符串伪代码段
  2. void main(void)
  3. {
  4.     if(key.code == true)
  5.     {
  6.         OLED_Clear();
  7.         OLED_ShowStr( 0, 0, tab[HZ] );// tab[]里面存放的是汉字字符串，例如："华温冷链巴拉巴拉"
  8.         Delay( 100 );
  9.     }
  10. }

最后的最后，刚忙完，写博客的时候有点累，有任何不明白的地方，欢迎一起探讨 QQ741684134。PS：遇到很多网友找我聊很基础的单片机应用问题，请自行百度，因为实在很忙。

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： rookie > 《技术帖》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多