21ic电子技术开发论坛 › 单片机与嵌入式系统 › 灵动MM32 MCU › 【MM32+模块】系列：10、OLED显示驱动及u8g2移植与演示 ...
返回列表 发新帖我要提问本帖赏金: 100.00元(功能说明)

[MM32生态] 【MM32+模块】系列：10、OLED显示驱动及u8g2移植与演示

[复制链接]
3210|18
 楼主| xld0932 发表于 2022-4-21 18:02 | 显示全部楼层 |阅读模式
MM32, MM32F0140, OLED, u8g2
#申请原创#   @21小跑堂




简介

OLED，是一种有机电质发光器件，又称为有机电激光显示。与之前提到的LCD1602、LCD1284相比，具有更低的功耗、更快的响应速度、更宽的可视角度、更高的显示分辨率、更轻的质量等等优点，而被广泛使用。淘宝上找到一款常见的是由SSD1306驱动的0.96寸的OLED，驱动接口有3线串行、4线串行和I2C这3种接口类型；另外OLED还有支持并行接口驱动的，这个会在后面的帖子来给大家分享。
3.png

u8g2是用于嵌入式设备支持单色OLED或LCD的图形库软件，支持市面上决大多数的显示屏驱动控制器，SSD1306就包含在内。u8g2图形库包含3个部分：u8g2、u8x8和u8log，其中u8g2包括了所有的图形功能，支持多种字体；u8x8可以直接将显示内容输出到显示屏显示，无需显示缓存；u8log则是一个输出终端的功能。另外u8g2还支持3种不同的绘图模式：全屏缓冲模式、页面模式和u8x8仅字符模式；全屏缓冲模式和页面模式支持所有的图形，区别在于所占用的显示缓存大小不同，从而致使刷新速度的快慢；而u8x8仅字符模式不需要显示缓存，可以直接将需要显示的内容输出显示，缺点就是不支持u8g8的图形显示，同时也依赖于显示驱动芯片是否支持该模式。


实现功能

1、OLED底层驱动：分别使用硬件I2C、软件模拟I2C、硬件SPI、软件模拟SPI这4种方式来实现对OLED显示屏的驱动，并实现一幅动画效果的演示。
2、u8g2移植：基于I2C和SPI这两种不同接口的驱动方式，分别移植u8g2的GUI，对移植过程和注意事项进行说明。
3、u8g2演示：通过一个简单的示例完成u8g2的效果演示。



1、OLED底层驱动

使用自制的MM32F0140最小系统板，结合I2C和SPI接口的两块0.96寸的OLED模块，实现驱动显示。在上图中SPI接口的OLED模块中，CS是片选信号连接PA4、DC是数据或命令切换连接PB0、RES是复位连接PB1、DI是SPI数据线连接PB5、DO是SPI时钟线连接PB7；在I2C接口的OLED中，SCL和SDA与MM32F0140的硬件I2C相连接，分别连接PB10和PB11。按照这样线序连接方式，一方面是按照MCU引脚I2C/SPI复用功能连接的，可以通过硬件I2C/SPI接口来驱动OLED显示；另一方面可以直接使用GPIO来模拟I2C/SPI时序来驱动OLED显示，如下图所示：
1.png
2.png

在OLED初始化过程中先根据宏定义对MCU的I2C和SPI进行初始化配置，然后配置OLED显示屏有参数并清空显示内容，最后通过TASK调用OLED_Handler来显示一个动画效果。对于使用硬件I2C还是软件模拟I2C、硬件SPI还是软件模拟SPI可以通过OLED_HW_I2C和OLED_HW_SPI宏来配置，参考代码如下所示：
复制
  1. void OLED_I2C_SendData(uint8_t Address, uint8_t Data)
    

  2. {
    

  3. #if OLED_HW_I2C /* 硬件I2C */
    


  4. 

  5.     I2C_SendData(I2C1, Address);
    

  6.     while(!I2C_GetFlagStatus(I2C1, I2C_STATUS_FLAG_TFE));
    


  7. 

  8.     I2C_SendData(I2C1, Data);
    

  9.     while(!I2C_GetFlagStatus(I2C1, I2C_STATUS_FLAG_TFE));
    


  10. 

  11.     I2C_GenerateSTOP(I2C1, ENABLE);
    

  12.     while(!I2C_GetFlagStatus(I2C1, I2C_FLAG_STOP_DET));
    


  13. 

  14. #else           /* 模拟I2C */
    


  15. 

  16.     sI2C_GenerateStart(&sI2C_OLED);
    


  17. 

  18.     sI2C_WriteByte(&sI2C_OLED, 0x78);
    


  19. 

  20.     if(sI2C_GetACK(&sI2C_OLED))
    

  21.     {
    

  22.         sI2C_GenerateStop(&sI2C_OLED);    return;
    

  23.     }
    


  24. 

  25.     sI2C_WriteByte(&sI2C_OLED, Address);
    


  26. 

  27.     if(sI2C_GetACK(&sI2C_OLED))
    

  28.     {
    

  29.         sI2C_GenerateStop(&sI2C_OLED);    return;
    

  30.     }
    


  31. 

  32.     sI2C_WriteByte(&sI2C_OLED, Data);
    


  33. 

  34.     if(sI2C_GetACK(&sI2C_OLED))
    

  35.     {
    

  36.         sI2C_GenerateStop(&sI2C_OLED);    return;
    

  37.     }
    


  38. 

  39.     sI2C_GenerateStop(&sI2C_OLED);
    


  40. 

  41. #endif
    

  42. }
    


  43. 

  44. void OLED_SPI_SendData(uint8_t Data)
    

  45. {
    

  46. #if OLED_HW_SPI /* 硬件SPI */
    


  47. 

  48.     uint32_t Timeout = 0;
    


  49. 

  50.     SPI_SendData(SPI1, Data);
    

  51.     while(!SPI_GetFlagStatus(SPI1, SPI_FLAG_TXEPT))
    

  52.     {
    

  53.         if(Timeout++ > 0xFFFF) break;
    

  54.     }
    


  55. 

  56. #else           /* 模拟SPI */
    


  57. 

  58.     for(uint8_t i = 0; i < 8; i++)
    

  59.     {
    

  60.         if((Data << i) & 0x80) OLED_DI_H();
    

  61.         else                   OLED_DI_L();
    


  62. 

  63.         OLED_DO_H();
    

  64.         OLED_DO_L();
    

  65.     }
    


  66. 

  67. #endif
    

  68. }
    


  69. 

  70. void OLED_WriteCMD(uint8_t Command)
    

  71. {
    

  72.     OLED_I2C_SendData(0x00, Command);
    


  73. 

  74.     OLED_DC_L();
    

  75.     OLED_CS_L();
    

  76.     OLED_SPI_SendData(Command);
    

  77.     OLED_CS_H();
    

  78. }
    


  79. 

  80. void OLED_WriteDAT(uint8_t Data)
    

  81. {
    

  82.     OLED_I2C_SendData(0x40, Data);
    


  83. 

  84.     OLED_DC_H();
    

  85.     OLED_CS_L();
    

  86.     OLED_SPI_SendData(Data);
    

  87.     OLED_CS_H();
    

  88. }
    


  89. 

  90. void OLED_WriteBuffer(uint8_t *Buffer, uint8_t Length)
    

  91. {
    

  92.     for(uint8_t i = 0; i < Length; i++)
    

  93.     {
    

  94.         OLED_WriteDAT(*Buffer++);
    

  95.     }
    

  96. }
    


  97. 

  98. void OLED_InitI2C(void)
    

  99. {
    

  100. #if OLED_HW_I2C /* 硬件I2C */
    


  101. 

  102.     GPIO_InitTypeDef GPIO_InitStructure;
    

  103.     I2C_InitTypeDef  I2C1_InitStructure;
    


  104. 

  105.     RCC_APB1PeriphClockCmd(RCC_APB1ENR_I2C1, ENABLE);
    


  106. 

  107.     I2C_StructInit(&I2C1_InitStructure);
    

  108.     I2C1_InitStructure.I2C_Mode       = I2C_Mode_MASTER;
    

  109.     I2C1_InitStructure.I2C_OwnAddress = 0;
    

  110.     I2C1_InitStructure.I2C_Speed      = I2C_Speed_FAST;
    

  111.     I2C1_InitStructure.I2C_ClockSpeed = 400000;
    

  112.     I2C_Init(I2C1, &I2C1_InitStructure);
    


  113. 

  114.     I2C_Send7bitAddress(I2C1, 0x78, I2C_Direction_Transmitter);
    


  115. 

  116.     I2C_Cmd(I2C1, ENABLE);
    


  117. 

  118.     RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOB, ENABLE);
    


  119. 

  120.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_1);
    

  121.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource11, GPIO_AF_1);
    


  122. 

  123.     GPIO_StructInit(&GPIO_InitStructure);
    

  124.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_10 | GPIO_Pin_11;
    

  125.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    

  126.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_OD;
    

  127.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    


  128. 

  129. #else           /* 模拟I2C */
    


  130. 

  131.     sI2C_Init(&sI2C_OLED);
    


  132. 

  133. #endif
    

  134. }
    


  135. 

  136. void OLED_InitSPI(void)
    

  137. {
    

  138. #if OLED_HW_SPI /* 硬件SPI */
    


  139. 

  140.     GPIO_InitTypeDef GPIO_InitStructure;
    

  141.     SPI_InitTypeDef  SPI_InitStructure;
    


  142. 

  143.     RCC_APB2PeriphClockCmd(RCC_APB2ENR_SPI1, ENABLE);
    


  144. 

  145.     SPI_StructInit(&SPI_InitStructure);
    

  146.     SPI_InitStructure.SPI_Mode              = SPI_Mode_Master;
    

  147.     SPI_InitStructure.SPI_DataSize          = SPI_DataSize_8b;
    

  148.     SPI_InitStructure.SPI_DataWidth         = 8;
    

  149.     SPI_InitStructure.SPI_CPOL              = SPI_CPOL_Low;
    

  150.     SPI_InitStructure.SPI_CPHA              = SPI_CPHA_1Edge;
    

  151.     SPI_InitStructure.SPI_NSS               = SPI_NSS_Soft;
    

  152.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
    

  153.     SPI_InitStructure.SPI_FirstBit          = SPI_FirstBit_MSB;
    

  154.     SPI_Init(SPI1, &SPI_InitStructure);
    


  155. 

  156.     SPI_Cmd(SPI1, ENABLE);
    


  157. 

  158.     RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOA, ENABLE);
    


  159. 

  160.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource4, GPIO_AF_0);   /* PA4 SPI1_NSS  */
    

  161.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_0);   /* PA5 SPI1_SCK  */
    

  162.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_0);   /* PA6 SPI1_MISO */
    

  163.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_0);   /* PA7 SPI1_MOSI */
    


  164. 

  165.     GPIO_StructInit(&GPIO_InitStructure);
    

  166.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
    

  167.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  168.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
    

  169.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  170. 

  171.     GPIO_StructInit(&GPIO_InitStructure);
    

  172.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_6;
    

  173.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  174.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPU;
    

  175.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  176. 

  177.     SPI_BiDirectionalLineConfig(SPI1, SPI_Direction_Rx);
    

  178.     SPI_BiDirectionalLineConfig(SPI1, SPI_Direction_Tx);
    


  179. 

  180.     RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOB, ENABLE);
    


  181. 

  182.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_0 | GPIO_Pin_1;
    

  183.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  184.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;
    

  185.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    


  186. 

  187. #else           /* 模拟SPI */
    


  188. 

  189.     GPIO_InitTypeDef GPIO_InitStructure;
    


  190. 

  191.     RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOA, ENABLE);
    


  192. 

  193.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
    

  194.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  195.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;
    

  196.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    


  197. 

  198.     RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOB, ENABLE);
    


  199. 

  200.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_0 | GPIO_Pin_1;
    

  201.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  202.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;
    

  203.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    


  204. 

  205.     OLED_CS_H();  OLED_DC_L();
    

  206.     OLED_DI_L();  OLED_DO_L();
    


  207. 

  208. #endif
    


  209. 

  210.     OLED_RES_H(); SysTick_DelayMS(100);
    

  211.     OLED_RES_L(); SysTick_DelayMS(100);
    

  212.     OLED_RES_H(); SysTick_DelayMS(100);  
    

  213. }
    


  214. 

  215. void OLED_InitCFG(void)
    

  216. {
    

  217.     SysTick_DelayMS(1000);  /* 这里的延时很重要,上电后延时，没有错误的冗余设计 */
    


  218. 

  219.     OLED_WriteCMD(0xAE);    /* Display Off */
    

  220.     OLED_WriteCMD(0x20);    /* Set Memory Addressing Mode */
    

  221.     OLED_WriteCMD(0x10);    /* 00  Horizontal Addressing Mode
    

  222.                                01  Vertical Addressing Mode
    

  223.                                10  Page Addressing Mode (RESET)
    

  224.                                11  Invalid */
    

  225.     OLED_WriteCMD(0xB0);    /* Set Page Start Address for Page Addressing Mode,0-7 */
    

  226.     OLED_WriteCMD(0xC8);    /* Set COM Output Scan Direction */
    

  227.     OLED_WriteCMD(0x00);    /* Set Low  Column Address */
    

  228.     OLED_WriteCMD(0x10);    /* Set High Column Address */
    

  229.     OLED_WriteCMD(0x40);    /* Set Start Line Address */
    

  230.     OLED_WriteCMD(0x81);    /* Set Contrast Control Register */
    

  231.     OLED_WriteCMD(0xFF);    /* Brightness 0x00~0xff */
    

  232.     OLED_WriteCMD(0xA1);    /* Set Segment Re-map 0 to 127 */
    

  233.     OLED_WriteCMD(0xA6);    /* Set Normal Display */
    

  234.     OLED_WriteCMD(0xA8);    /* Set Multiplex Ratio(1 to 64) */
    

  235.     OLED_WriteCMD(0x3F);
    

  236.     OLED_WriteCMD(0xA4);    /* 0xA4: Output Follows RAM Content
    

  237.                                0xA5: Output Ignores RAM Content */
    

  238.     OLED_WriteCMD(0xD3);    /* Aet Display offset */
    

  239.     OLED_WriteCMD(0x00);    /* Not Offset */
    

  240.     OLED_WriteCMD(0xD5);    /* Set Display Clock Divide Ratio/Oscillator Frequency */
    

  241.     OLED_WriteCMD(0xF0);    /* Set Divide Ratio */
    

  242.     OLED_WriteCMD(0xD9);    /* Set Pre-charge Period */
    

  243.     OLED_WriteCMD(0x22);
    

  244.     OLED_WriteCMD(0xDA);    /* Set Com Pins Hardware Configuration */
    

  245.     OLED_WriteCMD(0x12);
    

  246.     OLED_WriteCMD(0xDB);    /* Set VCOMH */
    

  247.     OLED_WriteCMD(0x20);    /* 0x20=0.77*VCC */
    

  248.     OLED_WriteCMD(0x8D);    /* Set DC-DC Enable */
    

  249.     OLED_WriteCMD(0x14);
    

  250.     OLED_WriteCMD(0xAF);    /* Turn On OLED Panel */
    

  251. }
    


  252. 

  253. void OLED_SetPosition(uint8_t x, uint8_t y)
    

  254. {
    

  255.         OLED_WriteCMD(0xB0 + y);
    

  256.         OLED_WriteCMD(((x & 0xF0) >> 4) | 0x10);
    

  257.         OLED_WriteCMD(((x & 0x0F) >> 0) | 0x00);
    

  258. }
    


  259. 

  260. void OLED_Clear(uint8_t Data)
    

  261. {
    

  262.     uint8_t x = 0, y = 0;
    


  263. 

  264.     for(y = 0; y < 8; y++)
    

  265.     {
    

  266.         OLED_SetPosition(0, y);
    


  267. 

  268.         for(x = 0; x < 128; x++)
    

  269.         {
    

  270.             OLED_WriteDAT(Data);
    

  271.         }
    

  272.     }
    

  273. }
    


  274. 

  275. void OLED_Init(void)
    

  276. {
    

  277.     OLED_InitI2C();
    


  278. 

  279.     OLED_InitSPI();
    


  280. 

  281.     OLED_InitCFG();
    


  282. 

  283.     OLED_Clear(0x00);
    


  284. 

  285.     TASK_Append(TASK_ID_OLED, OLED_Handler, 50);
    

  286. }
    


  287. 

  288. #include "DOG02.c"
    

  289. #include "DOG03.c"
    

  290. #include "DOG04.c"
    

  291. #include "DOG05.c"
    

  292. #include "DOG06.c"
    

  293. #include "DOG07.c"
    

  294. #include "DOG08.c"
    

  295. #include "DOG09.c"
    

  296. #include "DOG10.c"
    

  297. #include "DOG11.c"
    

  298. #include "DOG12.c"
    

  299. #include "DOG13.c"
    

  300. #include "DOG14.c"
    

  301. #include "DOG15.c"
    

  302. #include "DOG16.c"
    

  303. #include "DOG17.c"
    

  304. #include "DOG18.c"
    

  305. #include "DOG19.c"
    

  306. #include "DOG20.c"
    

  307. #include "DOG21.c"
    

  308. #include "DOG22.c"
    

  309. #include "DOG23.c"
    

  310. #include "DOG24.c"
    

  311. #include "DOG25.c"
    

  312. #include "DOG26.c"
    

  313. #include "DOG27.c"
    


  314. 

  315. void OLED_DrawImage(uint8_t Width, uint8_t Height, const uint8_t *ImageData)
    

  316. {
    

  317.     uint8_t  x = 0, y = 0;
    

  318.     uint8_t  Buffer[0x80];
    

  319.     uint16_t Index    = 0;
    


  320. 

  321.     for(y = 0; y < Height / 8; y++)
    

  322.     {
    

  323.         OLED_SetPosition(32, y);
    


  324. 

  325.         for(x = 0; x < Width; x++)
    

  326.         {
    

  327.             Buffer[x] = ~ImageData[Index++];
    

  328.         }
    


  329. 

  330.         OLED_WriteBuffer(Buffer, Width);
    

  331.     }
    

  332. }
    


  333. 

  334. void OLED_Handler(void)
    

  335. {
    

  336.     static uint8_t Index = 0;
    


  337. 

  338.     switch(Index)
    

  339.     {
    

  340.         case  0 : OLED_DrawImage(64, 64, gImage_DOG02); break;
    

  341.         case  1 : OLED_DrawImage(64, 64, gImage_DOG03); break;
    

  342.         case  2 : OLED_DrawImage(64, 64, gImage_DOG04); break;
    

  343.         case  3 : OLED_DrawImage(64, 64, gImage_DOG05); break;
    

  344.         case  4 : OLED_DrawImage(64, 64, gImage_DOG06); break;
    

  345.         case  5 : OLED_DrawImage(64, 64, gImage_DOG07); break;
    

  346.         case  6 : OLED_DrawImage(64, 64, gImage_DOG08); break;
    

  347.         case  7 : OLED_DrawImage(64, 64, gImage_DOG09); break;
    

  348.         case  8 : OLED_DrawImage(64, 64, gImage_DOG10); break;
    

  349.         case  9 : OLED_DrawImage(64, 64, gImage_DOG11); break;
    

  350.         case  10: OLED_DrawImage(64, 64, gImage_DOG12); break;
    

  351.         case  11: OLED_DrawImage(64, 64, gImage_DOG13); break;
    

  352.         case  12: OLED_DrawImage(64, 64, gImage_DOG14); break;
    

  353.         case  13: OLED_DrawImage(64, 64, gImage_DOG15); break;
    

  354.         case  14: OLED_DrawImage(64, 64, gImage_DOG16); break;
    

  355.         case  15: OLED_DrawImage(64, 64, gImage_DOG17); break;
    

  356.         case  16: OLED_DrawImage(64, 64, gImage_DOG18); break;
    

  357.         case  17: OLED_DrawImage(64, 64, gImage_DOG19); break;
    

  358.         case  18: OLED_DrawImage(64, 64, gImage_DOG20); break;
    

  359.         case  19: OLED_DrawImage(64, 64, gImage_DOG21); break;
    

  360.         case  20: OLED_DrawImage(64, 64, gImage_DOG22); break;
    

  361.         case  21: OLED_DrawImage(64, 64, gImage_DOG23); break;
    

  362.         case  22: OLED_DrawImage(64, 64, gImage_DOG24); break;
    

  363.         case  23: OLED_DrawImage(64, 64, gImage_DOG25); break;
    

  364.         case  24: OLED_DrawImage(64, 64, gImage_DOG26); break;
    

  365.         case  25: OLED_DrawImage(64, 64, gImage_DOG27); break;
    

  366.     }
    


  367. 

  368.     Index = (Index + 1) % 26;
    

  369. }

OLED底层驱动显示效果：
dog.GIF


2、u8g2移植

首先我们到https://github.com/olikraus/u8g2这个网址下载开源代码，当前版本中有基于C和C++这两种代码库，并提供了示例参考例程；我们使用的是基于C的开发库，所以将cscr文件中的源代码添加到工程中，根据文件类型和功能，对其进行分文件夹归类，最终如附件源码工程中所示；然后将u8g2的源代码添加到工程中，其中包含了u8g2的图形实现的功能程序，也有根据显示驱动来添加的底层驱动文件，最后对工程头文件包含路径进行设置，具体参考附件中的源代码工程；接下来我们就可以通过代码来实现，因为我们同时是驱动两个OLED，分别是I2C和SPI接口的，所以在移植的时候，也同时包含了这两种实现方式；我们在main.c文件中实现接口和功能，先根据不同的接口定义2个u8g2结构体变量并进行初始化：
复制
  1. u8g2_t u8g2_spi;
    

  2. u8g2_t u8g2_i2c;
    


  3. 

  4. void u8g2_UserInit(void)
    

  5. {
    

  6.     /* 初始化u8g2 */
    

  7.     u8g2_Setup_ssd1306_128x64_noname_f(&u8g2_spi, U8G2_R0, u8x8_byte_4wire_sw_spi, u8x8_mm32_spi_gpio_and_delay);
    


  8. 

  9.     /* 初始化显示器 */
    

  10.     u8g2_InitDisplay(&u8g2_spi);
    


  11. 

  12.     /* 唤醒显示器 */
    

  13.     u8g2_SetPowerSave(&u8g2_spi, 0);
    


  14. 

  15.     /* 设置英文字体 */
    

  16.     u8g2_SetFont(&u8g2_spi, u8g2_font_6x12_mr);
    


  17. 


  18. 

  19.     /* 初始化u8g2 */
    

  20.     u8g2_Setup_ssd1306_i2c_128x64_noname_f(&u8g2_i2c, U8G2_R0, u8x8_byte_sw_i2c, u8x8_mm32_i2c_gpio_and_delay);
    


  21. 

  22.     /* 初始化显示器 */
    

  23.     u8g2_InitDisplay(&u8g2_i2c);
    


  24. 

  25.     /* 唤醒显示器 */
    

  26.     u8g2_SetPowerSave(&u8g2_i2c, 0);
    


  27. 

  28.     /* 设置英文字体 */
    

  29.     u8g2_SetFont(&u8g2_i2c, u8g2_font_6x12_mr);
    


  30. 


  31. 

  32.     TASK_Append(TASK_ID_U8G2, u8g2_UserHandler, 50);
    

  33. }

在初始化的时候，我们发现I2C和SPI调用的接口函数是不一样的，SPI接口调用的是u8g2_Setup_ssd1306_128x64_noname_f函数，I2C接口调用的是u8g2_Setup_ssd1306_i2c_128x64_noname_f函数；在这两个函数中形参功能都是类似的，第一个参数是全局u8g2结构体变量，第二个参数用于指示显示方向，第3个参数用于指明u8g2驱动操作函数，第4个参数用于指明u8g2底层GPIO操作的回调函数；不管是SPI还是I2C，对于u8g2底层驱动来说，都是用模拟时序的方式来实现的，所以在移植u8g2时，对之前的OLED_HW_I2C和OLED_HW_SPI这两个宏都要设置为0。

u8g2_Setup_ssd1306_128x64_noname_f和u8g2_Setup_ssd1306_i2c_128x64_noname_f这两个函数在u8g2_d_setup.c文件中，仅需要留下这两个函数就可以，将其它的函数进行屏蔽。在u8g2_d_memory.c文件中定义memory操作功能函数，我们这边选用u8g2_m_16_8_f这个函数，将其它的函数进行屏蔽。在后面示例中需要显示字符，所以就需要选择一个系统字库，通过调用u8g2_SetFont来进行设置；字体的选择在u8g2_fonts.c文件中，保留需要使用的字库，对其它的字库进行屏蔽。如上这些对没有使用的函数或者字体进行屏蔽是根据显示驱动、MEMORY管理和字体选择来决定的，屏蔽也是为了节省代码空间和未使用到的报错。

最后就是要实现底层对GPIO操作和延时的回调函数，供u8g2底层驱动来调用；在SPI接口调用时使用到SPI_DATA、SPI_CLOCK、SPI_CS、DC、RESET和DELAY_NANO，在I2C接口调用时使用到了I2C_DATA、I2C_CLOCK和DELAY_I2C；具体的函数接口实现如下所示：
复制
  1. uint8_t u8x8_mm32_spi_gpio_and_delay(
    

  2.     U8X8_UNUSED u8x8_t *u8x8,
    

  3.     U8X8_UNUSED uint8_t msg,
    

  4.     U8X8_UNUSED uint8_t arg_int,
    

  5.     U8X8_UNUSED void   *arg_ptr)
    

  6. {
    

  7.     switch (msg)
    

  8.     {
    

  9.         case U8X8_MSG_GPIO_AND_DELAY_INIT:
    

  10.             OLED_Init();                    
    

  11.             break;
    


  12. 

  13.         case U8X8_MSG_GPIO_SPI_DATA:
    

  14.             if(arg_int) OLED_DI_H();
    

  15.             else        OLED_DI_L();
    

  16.             break;
    


  17. 

  18.         case U8X8_MSG_GPIO_SPI_CLOCK:
    

  19.             if(arg_int) OLED_DO_H();
    

  20.             else        OLED_DO_L();
    

  21.             break;
    


  22. 

  23.         case U8X8_MSG_GPIO_CS:
    

  24.             if(arg_int) OLED_CS_H();
    

  25.             else        OLED_CS_L();
    

  26.             break;
    


  27. 

  28.         case U8X8_MSG_GPIO_DC:
    

  29.             if(arg_int) OLED_DC_H();
    

  30.             else        OLED_DC_L();
    

  31.             break;
    


  32. 

  33.         case U8X8_MSG_GPIO_RESET:
    

  34.             if(arg_int) OLED_RES_H();
    

  35.             else        OLED_RES_L();
    

  36.             break;
    


  37. 

  38.         case U8X8_MSG_DELAY_NANO:
    

  39.             __nop();
    

  40.             break;
    


  41. 

  42.         default: return 0;
    

  43.     }
    


  44. 

  45.     return 1;
    

  46. }
    


  47. 

  48. uint8_t u8x8_mm32_i2c_gpio_and_delay(
    

  49.     U8X8_UNUSED u8x8_t *u8x8,
    

  50.     U8X8_UNUSED uint8_t msg,
    

  51.     U8X8_UNUSED uint8_t arg_int,
    

  52.     U8X8_UNUSED void   *arg_ptr)
    

  53. {
    

  54.     switch (msg)
    

  55.     {
    

  56.         case U8X8_MSG_GPIO_AND_DELAY_INIT:
    

  57.             OLED_Init();                    
    

  58.             break;
    


  59. 

  60.         case U8X8_MSG_GPIO_I2C_DATA:
    

  61.             if(arg_int) OLED_SDA_H();
    

  62.             else        OLED_SDA_L();
    

  63.             break;
    


  64. 

  65.         case U8X8_MSG_GPIO_I2C_CLOCK:
    

  66.             if(arg_int) OLED_SCL_H();
    

  67.             else        OLED_SCL_L();
    

  68.             break;
    


  69. 

  70.         case U8X8_MSG_DELAY_I2C:
    

  71.             __nop();
    

  72.             break;
    


  73. 

  74.         default: return 0;
    

  75.     }
    


  76. 

  77.     return 1;
    

  78. }

至此u8g2移植和初始化就完成了。


3、u8g2演示
演示的功能是分别在I2C和SPI接口的OLED显示屏上显示3个半径相同坐标不同的圆，圆半径由小到大，再由大到小进行变化显示，在屏幕顶端居中的位置显示当前的圆半径数值，具体代码实现如下：
复制
  1. void u8g2_UserHandler(void)
    

  2. {
    

  3.     static int rad = 0, direction = 0, select = 0;
    


  4. 

  5.     char str[10];
    

  6.     memset(str, 0, sizeof(str));
    


  7. 

  8.     if(direction == 0)
    

  9.     {
    

  10.         if(++rad == 0x1F) direction = 1;
    

  11.     }
    

  12.     else
    

  13.     {
    

  14.         if(--rad == 0x01) direction = 0;
    

  15.     }
    


  16. 

  17.     sprintf(str, "%02d", rad);
    


  18. 

  19.     if(select == 0)
    

  20.     {
    

  21.         /* 清空缓冲区的内容 */
    

  22.         u8g2_ClearBuffer(&u8g2_spi);
    


  23. 

  24.         /* 画圆 */
    

  25.         u8g2_DrawCircle(&u8g2_spi, 32, 32, rad, U8G2_DRAW_ALL);
    

  26.         u8g2_DrawCircle(&u8g2_spi, 64, 32, rad, U8G2_DRAW_ALL);
    

  27.         u8g2_DrawCircle(&u8g2_spi, 96, 32, rad, U8G2_DRAW_ALL);
    


  28. 

  29.         u8g2_DrawStr(&u8g2_spi, 58, 10, str);
    


  30. 

  31.         /* 绘制缓冲区的内容 */
    

  32.         u8g2_SendBuffer(&u8g2_spi);
    

  33.     }
    

  34.     else
    

  35.     {
    

  36.         /* 清空缓冲区的内容 */
    

  37.         u8g2_ClearBuffer(&u8g2_i2c);
    


  38. 

  39.         /* 画圆 */
    

  40.         u8g2_DrawCircle(&u8g2_i2c, 32, 32, rad, U8G2_DRAW_ALL);
    

  41.         u8g2_DrawCircle(&u8g2_i2c, 64, 32, rad, U8G2_DRAW_ALL);
    

  42.         u8g2_DrawCircle(&u8g2_i2c, 96, 32, rad, U8G2_DRAW_ALL);
    


  43. 

  44.         u8g2_DrawStr(&u8g2_i2c, 58, 10, str);
    


  45. 

  46.         /* 绘制缓冲区的内容 */
    

  47.         u8g2_SendBuffer(&u8g2_i2c);
    

  48.     }
    


  49. 

  50.     if((direction == 0) && (rad == 1))
    

  51.     {
    

  52.         if(select == 0) select = 1;
    

  53.         else            select = 0;
    

  54.     }
    

  55. }

GUI演示效果：
u8g2.GIF

附件
软件工程源代码： OLED.part1.rar (5 MB, 下载次数: 55) OLED.part2.rar (3.12 MB, 下载次数: 45)

回复

收藏4 举报

打赏榜单

21小跑堂 打赏了 100.00 元 2022-04-24
理由：恭喜通过原创文章审核！请多多加油哦！

评论

21小跑堂
使用了软件和硬件两种方式，运用了SPI和I2C两种通信，在MM32平台均实现了OLED的显示，并移植了基本涵盖了u8g2，用户基于该**可快速在灵动平台搭建OLED开发，其软件模拟也可移植到其他平台。功能齐全，讲解详细。  发表于 2022-4-24 15:51

相关帖子
 楼主| xld0932 发表于 2022-4-21 18:07 | 显示全部楼层
本帖分别使用硬件I2C、SPI、软件模拟I2C、SPI来驱动OLED显示，并基于I2C、SPI这两种不同的接口移植u8g2来进行演示
回复

收藏4 举报

评分

参与人数 1威望 +1 收起 理由
wujac + 1 很给力!

查看全部评分

www5911839 发表于 2022-4-21 22:38 | 显示全部楼层
强
回复

收藏4 举报

www5911839 发表于 2022-4-21 22:48 | 显示全部楼层
个人感觉 gif 动图感觉太小了，效果没体现出来。大侠，方不方便录制成视频，上传到 B 站呢
回复

收藏4 举报

 楼主| xld0932 发表于 2022-4-22 07:56 | 显示全部楼层
www5911839 发表于 2022-4-21 22:48
个人感觉 gif 动图感觉太小了，效果没体现出来。大侠，方不方便录制成视频，上传到 B 站呢 ...

已经反馈需求了，等后面21ic可以在帖子里上传视频就完美了其实后面有很多是需要结合视频演示的分享呢，文字结合视频效果会更好些，现在只能上传GIF的动图，每次都是把视频转换成GIF，质量和大小都有缺失
回复

收藏4 举报

terryzhouhz 发表于 2022-4-28 09:13 | 显示全部楼层
强
回复

收藏4 举报

 楼主| xld0932 发表于 2022-4-28 10:44 | 显示全部楼层
terryzhouhz 发表于 2022-4-28 09:13
强

回复

收藏4 举报

tpgf 发表于 2022-5-4 10:10 | 显示全部楼层
特羡慕这种显示的
回复

收藏4 举报

drer 发表于 2022-5-4 10:24 | 显示全部楼层
图像真是很不错
回复

收藏4 举报

tfqi 发表于 2022-5-4 10:31 | 显示全部楼层
这是什么种类的屏啊
回复

收藏4 举报

coshi 发表于 2022-5-4 10:39 | 显示全部楼层
楼主简直就是全能啊
回复

收藏4 举报

kxsi 发表于 2022-5-4 10:47 | 显示全部楼层
视频还是非常不错的
回复

收藏4 举报

wiba 发表于 2022-5-4 10:54 | 显示全部楼层
一般这种移植 修改的额地方多吗
回复

收藏4 举报

 楼主| xld0932 发表于 2022-5-4 21:26 | 显示全部楼层
wiba 发表于 2022-5-4 10:54
一般这种移植 修改的额地方多吗

如果是u8g2支持的屏驱动，只需要根据硬件配置相应的GPIO，对LCD进行初始化配置，然后再实现u8g2驱动架构的回调函数，就可以啦
回复

收藏4 举报

 楼主| xld0932 发表于 2022-5-4 21:51 | 显示全部楼层
coshi 发表于 2022-5-4 10:39
楼主简直就是全能啊

回复

收藏4 举报

 楼主| xld0932 发表于 2022-5-4 21:52 | 显示全部楼层
tfqi 发表于 2022-5-4 10:31
这是什么种类的屏啊

OLED显示屏，128*64点阵
回复

收藏4 举报

 楼主| xld0932 发表于 2022-5-4 21:53 | 显示全部楼层
drer 发表于 2022-5-4 10:24
图像真是很不错

嗯，还是要靠取模软件来取数据的
回复

收藏4 举报

fuyuqingfeng 发表于 2022-10-13 16:21 | 显示全部楼层
楼主，请教下u8g2中文怎么显示？我这边显示英文 数字 符号都没问题，就中文显示不出来
回复

收藏4 举报

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

本版积分规则

xld0932 Image
个人签名：King.Xu

77

主题

3023

帖子

38

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