21ic电子技术开发论坛 › 单片机与嵌入式系统 › 雅特力AT32 MCU › 【AT-START-L021测评】硬件I2C/IIC 驱动OLED
返回列表 发新帖我要提问

[AT32L021] 【AT-START-L021测评】硬件I2C/IIC 驱动OLED

[复制链接]
 楼主| 南来之风 发表于 2024-12-23 13:24 | 显示全部楼层 |阅读模式
I2c, LED, OLED, ic, AT-START-L021测评
先看效果：

3D99B7A8-CCC2-4318-8481-278362601878-16613-00000F1426BA7F70.gif

首先进行OLED初始化：
复制
  1. void OLED_Init(void)
    

  2. {        
    

  3.         delay_ms(1000);
    

  4.         
    

  5.         WriteCmd(0xAE);//--turn off oled panel
    

  6.         WriteCmd(0x00);//---set low column address
    

  7.         WriteCmd(0x10);//---set high column address
    

  8.         WriteCmd(0x40);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
    

  9.         WriteCmd(0x81);//--set contrast control register
    

  10.         WriteCmd(0xCF);// Set SEG Output Current Brightness
    

  11.         WriteCmd(0xA1);//--Set SEG/Column Mapping     0xa0���ҷ��� 0xa1����
    

  12.         WriteCmd(0xC8);//Set COM/Row Scan Direction   0xc0���·��� 0xc8����
    

  13.         WriteCmd(0xA6);//--set normal display
    

  14.         WriteCmd(0xA8);//--set multiplex ratio(1 to 64)
    

  15.         WriteCmd(0x3f);//--1/64 duty
    

  16.         WriteCmd(0xD3);//-set display offset        Shift Mapping RAM Counter (0x00~0x3F)
    

  17.         WriteCmd(0x00);//-not offset
    

  18.         WriteCmd(0xd5);//--set display clock divide ratio/oscillator frequency
    

  19.         WriteCmd(0x80);//--set divide ratio, Set Clock as 100 Frames/Sec
    

  20.         WriteCmd(0xD9);//--set pre-charge period
    

  21.         WriteCmd(0xF1);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
    

  22.         WriteCmd(0xDA);//--set com pins hardware configuration
    

  23.         WriteCmd(0x12);
    

  24.         WriteCmd(0xDB);//--set vcomh
    

  25.         WriteCmd(0x40);//Set VCOM Deselect Level
    

  26.         WriteCmd(0x20);//-Set Page Addressing Mode (0x00/0x01/0x02)
    

  27.         WriteCmd(0x02);//
    

  28.         WriteCmd(0x8D);//--set Charge Pump enable/disable
    

  29.         WriteCmd(0x14);//--set(0x10) disable
    

  30.         WriteCmd(0xA4);// Disable Entire Display On (0xa4/0xa5)
    

  31.         WriteCmd(0xA6);// Disable Inverse Display On (0xa6/a7)
    

  32.         OLED_Clear();
    

  33.         WriteCmd(0xAF);        //Set display on added by sensoryoung
    

  34.         delay_ms(200);
    

  35. }
    


  36.
然后刷新屏幕：
复制
  1. void OLED_Refresh(void)
    

  2. {
    

  3.         uint8_t i,n;
    

  4.         for(i=0;i<8;i++)
    

  5.         {
    

  6.                 WriteCmd(0xb0+i);
    

  7.                 WriteCmd(0x00);
    

  8.                 WriteCmd(0x10);
    


  9. 

  10.                 for(n=0;n<128;n++)
    

  11.                 {
    

  12.                         WriteDat(OLED_GRAM[n][i]);
    

  13.                 }
    

  14.   }
    

  15. }
这里有关键的两个函数：WriteCmd 与 WriteDat。实现如下：
复制

  1. 

  2. /**************************************************************
    

  3.          Prototype      : void WriteCmd(uint8_t IIC_Command)
    

  4.          Parameters     : IIC_Command
    

  5.          return                                        : none
    

  6.          Description    : 写命令（通过HAL_I2C_WriteByte中的HAL_I2C_Master_Transmit
    

  7.                       向0x00写入命令）
    

  8. ***************************************************************/
    

  9. void WriteCmd(uint8_t IIC_Command)
    

  10. {
    

  11.         HAL_I2C_WriteByte(0x00, IIC_Command);
    

  12. }
    


  13. 

  14. /**************************************************************
    

  15.          Prototype      : void WriteDat(uint8_t IIC_Data)
    

  16.          Parameters     : IIC_Data
    

  17.          return                                        : none
    

  18.          Description    : 写数据（通过HAL_I2C_WriteByte中的HAL_I2C_Master_Transmit
    

  19.                       向0x40写入数据）
    

  20. ***************************************************************/
    

  21. void WriteDat(uint8_t IIC_Data)
    

  22. {
    

  23.         HAL_I2C_WriteByte(0x40, IIC_Data);
在调用I2C模块向总线发送数据之前，封装了一下：
复制

  1. 

  2. /***************************************************
    

  3.     I2C总线传出数据函数：
    

  4.                 addr  :    要写入的地址（OLED的地址一般为0x40;指令地址为0x00）
    

  5.                 data  :    要写入的数据
    

  6. ***************************************************/
    

  7. void HAL_I2C_WriteByte(uint8_t addr,uint8_t data)
    

  8. {
    

  9.         //uint8_t TxData[2] = {addr,data};
    

  10.         uint8_t TxData[2];
    

  11.         TxData[0] = addr;
    

  12.         TxData[1] = data;
    

  13.   if((i2c_status = i2c_master_transmit(&hi2cx, 0X78, TxData, 2, I2C_TIMEOUT)) != I2C_OK)
    

  14.   {
    

  15.     error_handler(i2c_status);
    

  16.   }        
    

  17. }
实际效果还不错，完整代码如下：
复制
  1. /*Reference: https://blog.csdn.net/Reasally/article/details/126789505*/
    

  2. #include "oled.h"
    

  3. #include "stdlib.h"
    

  4. #include "oledfont.h"           
    


  5. 

  6. //For ARTEY ATL021
    

  7. extern void error_handler(uint32_t error_code);
    

  8. extern i2c_handle_type hi2cx;
    

  9. extern i2c_status_type i2c_status;
    

  10. #define I2C_TIMEOUT                      0xFFFFFFF
    


  11. 

  12. uint8_t OLED_GRAM[144][8];
    


  13. 

  14. //���Ժ���
    

  15. void OLED_ColorTurn(uint8_t i)
    

  16. {
    

  17.         if(i==0)
    

  18.                 {
    

  19.                         WriteCmd(0xA6);
    

  20.                 }
    

  21.         if(i==1)
    

  22.                 {
    

  23.                         WriteCmd(0xA7);
    

  24.                 }
    

  25. }
    


  26. 

  27. //��Ļ��ת180��
    

  28. void OLED_DisplayTurn(uint8_t i)
    

  29. {
    

  30.         if(i==0)
    

  31.                 {
    

  32.                         WriteCmd(0xC8);
    

  33.                         WriteCmd(0xA1);
    

  34.                 }
    

  35.         if(i==1)
    

  36.                 {
    

  37.                         WriteCmd(0xC0);
    

  38.                         WriteCmd(0xA0);
    

  39.                 }
    

  40. }
    


  41. 

  42. //��ʱ
    

  43. void IIC_delay(void)
    

  44. {
    

  45.         uint16_t t=300;
    

  46.         while(t--);
    

  47. }
    


  48. 

  49. /***************************************************
    

  50.     I2C总线传出数据函数：
    

  51.                 addr  :    要写入的地址（OLED的地址一般为0x40;指令地址为0x00）
    

  52.                 data  :    要写入的数据
    

  53. ***************************************************/
    

  54. void HAL_I2C_WriteByte(uint8_t addr,uint8_t data)
    

  55. {
    

  56.         //uint8_t TxData[2] = {addr,data};
    

  57.         uint8_t TxData[2];
    

  58.         TxData[0] = addr;
    

  59.         TxData[1] = data;
    

  60.   if((i2c_status = i2c_master_transmit(&hi2cx, 0X78, TxData, 2, I2C_TIMEOUT)) != I2C_OK)
    

  61.   {
    

  62.     error_handler(i2c_status);
    

  63.   }        
    

  64. }
    


  65. 

  66. /**************************************************************
    

  67.          Prototype      : void WriteCmd(uint8_t IIC_Command)
    

  68.          Parameters     : IIC_Command
    

  69.          return                                        : none
    

  70.          Description    : 写命令（通过HAL_I2C_WriteByte中的HAL_I2C_Master_Transmit
    

  71.                       向0x00写入命令）
    

  72. ***************************************************************/
    

  73. void WriteCmd(uint8_t IIC_Command)
    

  74. {
    

  75.         HAL_I2C_WriteByte(0x00, IIC_Command);
    

  76. }
    


  77. 

  78. /**************************************************************
    

  79.          Prototype      : void WriteDat(uint8_t IIC_Data)
    

  80.          Parameters     : IIC_Data
    

  81.          return                                        : none
    

  82.          Description    : 写数据（通过HAL_I2C_WriteByte中的HAL_I2C_Master_Transmit
    

  83.                       向0x40写入数据）
    

  84. ***************************************************************/
    

  85. void WriteDat(uint8_t IIC_Data)
    

  86. {
    

  87.         HAL_I2C_WriteByte(0x40, IIC_Data);
    

  88. }
    


  89. 


  90. 

  91. //����һ���ֽ�
    

  92. //mode:����/�����־ 0,��ʾ����;1,��ʾ����;
    

  93. void OLED_WR_Byte(uint8_t dat,uint8_t mode)
    

  94. {
    

  95.         
    

  96.         if(mode){
    

  97.                 //Send_Byte(0x40);
    

  98.                 WriteDat(dat);
    

  99.         }
    

  100.         else{
    

  101.                 //Send_Byte(0x00);
    

  102.                 WriteCmd(dat);
    

  103.         }
    

  104.     //Send_Byte(dat);
    

  105.     //I2C_Stop();
    

  106. }
    


  107. 


  108. 


  109. 

  110. //����OLED��ʾ 
    

  111. void OLED_DisPlay_On(void)
    

  112. {
    

  113.         WriteCmd(0x8D);
    

  114.         WriteCmd(0x14);
    

  115.         WriteCmd(0xAF);
    

  116. }
    


  117. 

  118. //�ر�OLED��ʾ 
    

  119. void OLED_DisPlay_Off(void)
    

  120. {
    

  121.         WriteCmd(0x8D);
    

  122.         WriteCmd(0x10);
    

  123.         WriteCmd(0xAE);
    

  124. }
    


  125. 

  126. //�����Դ浽OLED        
    

  127. void OLED_Refresh(void)
    

  128. {
    

  129.         uint8_t i,n;
    

  130.         for(i=0;i<8;i++)
    

  131.         {
    

  132.                 WriteCmd(0xb0+i);
    

  133.                 WriteCmd(0x00);
    

  134.                 WriteCmd(0x10);
    


  135. 

  136.                 for(n=0;n<128;n++)
    

  137.                 {
    

  138.                         WriteDat(OLED_GRAM[n][i]);
    

  139.                 }
    

  140.   }
    

  141. }
    

  142. //��������
    

  143. void OLED_Clear(void)
    

  144. {
    

  145.         uint8_t i,n;
    

  146.         for(i=0;i<8;i++)
    

  147.         {
    

  148.            for(n=0;n<128;n++)
    

  149.                         {
    

  150.                          OLED_GRAM[n][i]=0;//�����������
    

  151.                         }
    

  152.   }
    

  153. }
    


  154. 

  155. //���� 
    

  156. //x:0~127
    

  157. //y:0~63
    

  158. //t:1 ��� 0,���        
    

  159. void OLED_DrawPoint(uint8_t x,uint8_t y,uint8_t t)
    

  160. {
    

  161.         uint8_t i,m,n;
    

  162.         i=y/8;
    

  163.         m=y%8;
    

  164.         n=1<<m;
    

  165.         if(t){OLED_GRAM[x][i]|=n;}
    

  166.         else
    

  167.         {
    

  168.                 OLED_GRAM[x][i]=~OLED_GRAM[x][i];
    

  169.                 OLED_GRAM[x][i]|=n;
    

  170.                 OLED_GRAM[x][i]=~OLED_GRAM[x][i];
    

  171.         }
    

  172. }
    


  173. 

  174. //����
    

  175. //x1,y1:�������
    

  176. //x2,y2:��������
    

  177. void OLED_DrawLine(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2,uint8_t mode)
    

  178. {
    

  179.         uint16_t t; 
    

  180.         int xerr=0,yerr=0,delta_x,delta_y,distance;
    

  181.         int incx,incy,uRow,uCol;
    

  182.         delta_x=x2-x1; //������������ 
    

  183.         delta_y=y2-y1;
    

  184.         uRow=x1;//�����������
    

  185.         uCol=y1;
    

  186.         if(delta_x>0)incx=1; //���õ������� 
    

  187.         else if (delta_x==0)incx=0;//��ֱ�� 
    

  188.         else {incx=-1;delta_x=-delta_x;}
    

  189.         if(delta_y>0)incy=1;
    

  190.         else if (delta_y==0)incy=0;//ˮƽ�� 
    

  191.         else {incy=-1;delta_y=-delta_x;}
    

  192.         if(delta_x>delta_y)distance=delta_x; //ѡȡ�������������� 
    

  193.         else distance=delta_y;
    

  194.         for(t=0;t<distance+1;t++)
    

  195.         {
    

  196.                 OLED_DrawPoint(uRow,uCol,mode);//����
    

  197.                 xerr+=delta_x;
    

  198.                 yerr+=delta_y;
    

  199.                 if(xerr>distance)
    

  200.                 {
    

  201.                         xerr-=distance;
    

  202.                         uRow+=incx;
    

  203.                 }
    

  204.                 if(yerr>distance)
    

  205.                 {
    

  206.                         yerr-=distance;
    

  207.                         uCol+=incy;
    

  208.                 }
    

  209.         }
    

  210. }
    

  211. //x,y:Բ������
    

  212. //r:Բ�İ뾶
    

  213. void OLED_DrawCircle(uint8_t x,uint8_t y,uint8_t r)
    

  214. {
    

  215.         int a, b,num;
    

  216.     a = 0;
    

  217.     b = r;
    

  218.     while(2 * b * b >= r * r)      
    

  219.     {
    

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

  221.         OLED_DrawPoint(x - a, y - b,1);
    

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

  223.         OLED_DrawPoint(x + a, y + b,1);
    

  224.  
    

  225.         OLED_DrawPoint(x + b, y + a,1);
    

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

  227.         OLED_DrawPoint(x - b, y - a,1);
    

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

  229.         
    

  230.         a++;
    

  231.         num = (a * a + b * b) - r*r;//���㻭�ĵ���Բ�ĵľ���
    

  232.         if(num > 0)
    

  233.         {
    

  234.             b--;
    

  235.             a--;
    

  236.         }
    

  237.     }
    

  238. }
    


  239. 


  240. 


  241. 

  242. //��ָ��λ����ʾһ���ַ�,���������ַ�
    

  243. //x:0~127
    

  244. //y:0~63
    

  245. //size1:ѡ������ 6x8/6x12/8x16/12x24
    

  246. //mode:0,��ɫ��ʾ;1,������ʾ
    

  247. void OLED_ShowChar(uint8_t x,uint8_t y,uint8_t chr,uint8_t size1,uint8_t mode)
    

  248. {
    

  249.         uint8_t i,m,temp,size2,chr1;
    

  250.         uint8_t x0=x,y0=y;
    

  251.         if(size1==8)size2=6;
    

  252.         else size2=(size1/8+((size1%8)?1:0))*(size1/2);  //�õ�����һ���ַ���Ӧ������ռ���ֽ���
    

  253.         chr1=chr-' ';  //����ƫ�ƺ��ֵ
    

  254.         for(i=0;i<size2;i++)
    

  255.         {
    

  256.                 if(size1==8)
    

  257.                           {temp=asc2_0806[chr1][i];} //����0806����
    

  258.                 else if(size1==12)
    

  259.         {temp=asc2_1206[chr1][i];} //����1206����
    

  260.                 else if(size1==16)
    

  261.         {temp=asc2_1608[chr1][i];} //����1608����
    

  262.                 else if(size1==24)
    

  263.         {temp=asc2_2412[chr1][i];} //����2412����
    

  264.                 else return;
    

  265.                 for(m=0;m<8;m++)
    

  266.                 {
    

  267.                         if(temp&0x01)OLED_DrawPoint(x,y,mode);
    

  268.                         else OLED_DrawPoint(x,y,!mode);
    

  269.                         temp>>=1;
    

  270.                         y++;
    

  271.                 }
    

  272.                 x++;
    

  273.                 if((size1!=8)&&((x-x0)==size1/2))
    

  274.                 {x=x0;y0=y0+8;}
    

  275.                 y=y0;
    

  276.   }
    

  277. }
    


  278. 


  279. 

  280. //��ʾ�ַ���
    

  281. //x,y:�������  
    

  282. //size1:�����С 
    

  283. //*chr:�ַ�����ʼ��ַ 
    

  284. //mode:0,��ɫ��ʾ;1,������ʾ
    

  285. void OLED_ShowString(uint8_t x,uint8_t y,uint8_t *chr,uint8_t size1,uint8_t mode)
    

  286. {
    

  287.         while((*chr>=' ')&&(*chr<='~'))//�ж��Dz��ǷǷ��ַ�!
    

  288.         {
    

  289.                 OLED_ShowChar(x,y,*chr,size1,mode);
    

  290.                 if(size1==8)x+=6;
    

  291.                 else x+=size1/2;
    

  292.                 chr++;
    

  293.   }
    

  294. }
    


  295. 

  296. //m^n
    

  297. uint32_t OLED_Pow(uint8_t m,uint8_t n)
    

  298. {
    

  299.         uint32_t result=1;
    

  300.         while(n--)
    

  301.         {
    

  302.           result*=m;
    

  303.         }
    

  304.         return result;
    

  305. }
    


  306. 

  307. //��ʾ����
    

  308. //x,y :�������
    

  309. //num :Ҫ��ʾ������
    

  310. //len :���ֵ�λ��
    

  311. //size:�����С
    

  312. //mode:0,��ɫ��ʾ;1,������ʾ
    

  313. void OLED_ShowNum(uint8_t x,uint8_t y,uint32_t num,uint8_t len,uint8_t size1,uint8_t mode)
    

  314. {
    

  315.         uint8_t t,temp,m=0;
    

  316.         if(size1==8)m=2;
    

  317.         for(t=0;t<len;t++)
    

  318.         {
    

  319.                 temp=(num/OLED_Pow(10,len-t-1))%10;
    

  320.                         if(temp==0)
    

  321.                         {
    

  322.                                 OLED_ShowChar(x+(size1/2+m)*t,y,'0',size1,mode);
    

  323.       }
    

  324.                         else 
    

  325.                         {
    

  326.                           OLED_ShowChar(x+(size1/2+m)*t,y,temp+'0',size1,mode);
    

  327.                         }
    

  328.   }
    

  329. }
    


  330. 

  331. //��ʾ����
    

  332. //x,y:�������
    

  333. //num:���ֶ�Ӧ�����
    

  334. //mode:0,��ɫ��ʾ;1,������ʾ
    

  335. void OLED_ShowChinese(uint8_t x,uint8_t y,uint8_t num,uint8_t size1,uint8_t mode)
    

  336. {
    

  337.         uint8_t m,temp;
    

  338.         uint8_t x0=x,y0=y;
    

  339.         uint16_t i,size3=(size1/8+((size1%8)?1:0))*size1;  //�õ�����һ���ַ���Ӧ������ռ���ֽ���
    

  340.         for(i=0;i<size3;i++)
    

  341.         {
    

  342.                 if(size1==16)
    

  343.                                 {temp=Hzk1[num][i];}//����16*16����
    

  344.                 else if(size1==24)
    

  345.                                 {temp=Hzk2[num][i];}//����24*24����
    

  346.                 else if(size1==32)       
    

  347.                                 {temp=Hzk3[num][i];}//����32*32����
    

  348.                 else if(size1==64)
    

  349.                                 {temp=Hzk4[num][i];}//����64*64����
    

  350.                 else return;
    

  351.                 for(m=0;m<8;m++)
    

  352.                 {
    

  353.                         if(temp&0x01)OLED_DrawPoint(x,y,mode);
    

  354.                         else OLED_DrawPoint(x,y,!mode);
    

  355.                         temp>>=1;
    

  356.                         y++;
    

  357.                 }
    

  358.                 x++;
    

  359.                 if((x-x0)==size1)
    

  360.                 {x=x0;y0=y0+8;}
    

  361.                 y=y0;
    

  362.         }
    

  363. }
    


  364. 

  365. //num ��ʾ���ֵĸ���
    

  366. //space ÿһ����ʾ�ļ��
    

  367. //mode:0,��ɫ��ʾ;1,������ʾ
    

  368. void OLED_ScrollDisplay(uint8_t num,uint8_t space,uint8_t mode)
    

  369. {
    

  370.         uint8_t i,n,t=0,m=0,r;
    

  371.         while(1)
    

  372.         {
    

  373.                 if(m==0)
    

  374.                 {
    

  375.             OLED_ShowChinese(128,24,t,16,mode); //д��һ�����ֱ�����OLED_GRAM[][]������
    

  376.                         t++;
    

  377.                 }
    

  378.                 if(t==num)
    

  379.                         {
    

  380.                                 for(r=0;r<16*space;r++)      //��ʾ���
    

  381.                                  {
    

  382.                                         for(i=1;i<144;i++)
    

  383.                                                 {
    

  384.                                                         for(n=0;n<8;n++)
    

  385.                                                         {
    

  386.                                                                 OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
    

  387.                                                         }
    

  388.                                                 }
    

  389.            OLED_Refresh();
    

  390.                                  }
    

  391.         t=0;
    

  392.       }
    

  393.                 m++;
    

  394.                 if(m==16){m=0;}
    

  395.                 for(i=1;i<144;i++)   //ʵ������
    

  396.                 {
    

  397.                         for(n=0;n<8;n++)
    

  398.                         {
    

  399.                                 OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
    

  400.                         }
    

  401.                 }
    

  402.                 OLED_Refresh();
    

  403.         }
    

  404. }
    


  405. 

  406. //x,y���������
    

  407. //sizex,sizey,ͼƬ����
    

  408. //BMP[]��Ҫд���ͼƬ����
    

  409. //mode:0,��ɫ��ʾ;1,������ʾ
    

  410. void OLED_ShowPicture(uint8_t x,uint8_t y,uint8_t sizex,uint8_t sizey,uint8_t BMP[],uint8_t mode)
    

  411. {
    

  412.         uint16_t j=0;
    

  413.         uint8_t i,n,temp,m;
    

  414.         uint8_t x0=x,y0=y;
    

  415.         sizey=sizey/8+((sizey%8)?1:0);
    

  416.         for(n=0;n<sizey;n++)
    

  417.         {
    

  418.                  for(i=0;i<sizex;i++)
    

  419.                  {
    

  420.                                 temp=BMP[j];
    

  421.                                 j++;
    

  422.                                 for(m=0;m<8;m++)
    

  423.                                 {
    

  424.                                         if(temp&0x01)OLED_DrawPoint(x,y,mode);
    

  425.                                         else OLED_DrawPoint(x,y,!mode);
    

  426.                                         temp>>=1;
    

  427.                                         y++;
    

  428.                                 }
    

  429.                                 x++;
    

  430.                                 if((x-x0)==sizex)
    

  431.                                 {
    

  432.                                         x=x0;
    

  433.                                         y0=y0+8;
    

  434.                                 }
    

  435.                                 y=y0;
    

  436.      }
    

  437.          }
    

  438. }
    

  439. //OLED�ij�ʼ��
    

  440. void OLED_Init(void)
    

  441. {        
    

  442.         delay_ms(1000);
    

  443.         
    

  444.         WriteCmd(0xAE);//--turn off oled panel
    

  445.         WriteCmd(0x00);//---set low column address
    

  446.         WriteCmd(0x10);//---set high column address
    

  447.         WriteCmd(0x40);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
    

  448.         WriteCmd(0x81);//--set contrast control register
    

  449.         WriteCmd(0xCF);// Set SEG Output Current Brightness
    

  450.         WriteCmd(0xA1);//--Set SEG/Column Mapping     0xa0���ҷ��� 0xa1����
    

  451.         WriteCmd(0xC8);//Set COM/Row Scan Direction   0xc0���·��� 0xc8����
    

  452.         WriteCmd(0xA6);//--set normal display
    

  453.         WriteCmd(0xA8);//--set multiplex ratio(1 to 64)
    

  454.         WriteCmd(0x3f);//--1/64 duty
    

  455.         WriteCmd(0xD3);//-set display offset        Shift Mapping RAM Counter (0x00~0x3F)
    

  456.         WriteCmd(0x00);//-not offset
    

  457.         WriteCmd(0xd5);//--set display clock divide ratio/oscillator frequency
    

  458.         WriteCmd(0x80);//--set divide ratio, Set Clock as 100 Frames/Sec
    

  459.         WriteCmd(0xD9);//--set pre-charge period
    

  460.         WriteCmd(0xF1);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
    

  461.         WriteCmd(0xDA);//--set com pins hardware configuration
    

  462.         WriteCmd(0x12);
    

  463.         WriteCmd(0xDB);//--set vcomh
    

  464.         WriteCmd(0x40);//Set VCOM Deselect Level
    

  465.         WriteCmd(0x20);//-Set Page Addressing Mode (0x00/0x01/0x02)
    

  466.         WriteCmd(0x02);//
    

  467.         WriteCmd(0x8D);//--set Charge Pump enable/disable
    

  468.         WriteCmd(0x14);//--set(0x10) disable
    

  469.         WriteCmd(0xA4);// Disable Entire Display On (0xa4/0xa5)
    

  470.         WriteCmd(0xA6);// Disable Inverse Display On (0xa6/a7)
    

  471.         OLED_Clear();
    

  472.         WriteCmd(0xAF);        //Set display on added by sensoryoung
    

  473.         delay_ms(200);
    

  474. }
    


  475.



回复 赏

举报

相关帖子
TimeRiddle 发表于 2025-3-25 11:41 | 显示全部楼层
硬件IIC，这个好，用上DMA更好
回复 赏

举报

justin0407 发表于 2025-3-31 13:42 | 显示全部楼层
IIC速率最高1Mbps，刷稍为大一点的OLED就会吃力。
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

南来之风

69

主题

290

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部