你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

STM32CubeIDE的基于SPI通信OLED点亮及字符显示经验分享

[复制链接]
攻城狮Melo 发布时间：2023-4-7 15:18
一、SPI 通信技术
        显示屏（LCD、OLED）接口一般有I2C、SPI、UART、RGB、LVDS、MIPI、EDP和DP等。一般3.5寸以下的小尺寸LCD屏，显示数据量比较少，普遍采用低速串口，如I2C、SPI、UART。SPI（Serial Peripheral Interface）是全双工，同步的通信总线，以主从方式工作，这种模式通常有一个主设备和一个或多个从设备，需要至少4根线，事实上3根也可以（单向传输时，MISO、MISI取其一），节约了芯片的管脚。

        这些数据线是MISO（主设备数据输入）、MOSI（主设备数据输出）、SCLK（时钟）、CS（片选）。

（1）MISO– Master Input Slave Output，主设备数据输入，从设备数据输出；

（2）MOSI– Master Output Slave Input，主设备数据输出，从设备数据输入；

（3）SCLK – Serial Clock，时钟信号，由主设备产生；

（4）CS – Chip Select，从设备使能信号，由主设备控制。

        CS是控制芯片是否被选中的，也就是说只有片选信号为预先规定的使能信号时（高电位或低电位），对此芯片的操作才有效。。SCK提供时钟脉冲，SDI，SDO则基于此脉冲完成数据传输。


二、SPI通信参配
        本文采用的开发板是stm32L496VGT3,该开发板的OLED屏是240*240像素，采用SPI协议通讯，MCU采用4-Line SPI 的接口加上电源、重置等接口，实现 LCD 显示屏控制及输出显示，原理图如下：

 2694f5640ab14349920321a185890cb4.png

         LCD 显示屏针脚定义：

 7d51cd294e324ad4aa5667e93c40529c.png

         MCU连接LCD的芯片引脚定义如下：

 ef70a1aa3a054715a25b762f79bbd2ce.png

         各个引脚的具体参数：

 190d1b75537e45859cdab765cc9a94a1.png

三、SPI设置（cubeMx）
        在cubeIDE基于stm32L496VGT3芯片创建工程，打开界面配置（cubeMx），配置OLED屏的通信相关信息。本文是在一定基础上直接操作

        假设已经做好了时钟配置、lpusart调试输出，先直接设置OLED的SPI接口信息：

        1）开启SPI1
        本文只是纯粹的MCU向OLED屏输出信号，因此选择Transmit Only Master模式。

 55dd5447240a4432a4791f1cf3fa9aba.png

         2）添加SPI1的DMA支持

 949ebc104a5c44dcbff3521af2e2de0b.png

         3）开启spi1的中断功能

 16dbb4ba87fc43cfb258c834c4a46e9d.png

         4）设置oled屏控制的辅助引脚、设置名称及调整配置参数

 b3bd769e1cfb428883a460af666b1522.png

         5）调整SPI1配置参数

 82d00ed1b91c44a5bb6bb07aa286e189.png

         6）完成配置后，点击保存或生成代码的按钮生成代码
四、SPI通信及OLED屏点亮
        在ICore目录创建oled文件夹，创建oled.h、oled.c的LCD驱动文件。

        1）辅助引脚设值
        在oled.h中加入对LCD引脚（GPIO）设值控制函数
  1. //对该位写1或0
  2. #define Data_Cmd_State(__D_C_State__)        HAL_GPIO_WritePin(LCD_DCX_GPIO_Port, LCD_DCX_Pin, (GPIO_PinState)(__D_C_State__))
  3. #define OLED_RST_State(__RST_State__)        HAL_GPIO_WritePin(LCD_RST_GPIO_Port, LCD_RST_Pin, (GPIO_PinState)(__RST_State__))
  4. #define LCD_PWR_State(__PWR_State__)        HAL_GPIO_WritePin(LCD_PWR_GPIO_Port, LCD_PWR_Pin, (GPIO_PinState)(__PWR_State__))
复制代码

        2）spi1写入数据实现
        通过调用HAL标准库的HAL_SPI_Transmit函数实现对spi1(hspi1)实现写入命令函数或数据写入函数，也提供LcdWriteDataMultiple函数一次写入多个数据
  1. /********************************************************************
  2. *
  3. *   LcdWriteReg
  4. *
  5. *         Function description:
  6. *   Sets display register
  7. */
  8. void LcdWriteReg(uint8_t Data)
  9. {
  10.           Data_Cmd_State(0);
  11.           HAL_SPI_Transmit(&hspi1, &Data, 1, 10);
  12. }

  14. /********************************************************************
  15. *
  16. *          LcdWriteData
  17. *
  18. *         Function description:
  19. *   Writes a value to a display register
  20. */
  21. void LcdWriteData(uint8_t Data)
  22. {
  23.           Data_Cmd_State(1);
  24.           HAL_SPI_Transmit(&hspi1, &Data, 1, 10);
  25. }

  27. /********************************************************************
  28. *
  29. *        LcdWriteDataMultiple
  30. *
  31. *         Function description:
  32. *   Writes multiple values to a display register.
  33. */
  34. void LcdWriteDataMultiple(uint8_t * pData, uint32_t NumItems)
  35. {
  36.           Data_Cmd_State(1);
  37.           HAL_SPI_Transmit(&hspi1, pData, NumItems, 10);
  38. }
复制代码

        3）OLED初始化指令执行
        定义OLED屏的初始化指令集及指令设置函数
  1. /* Init script function */
  2. struct OLED_function {
  3.   uint8_t cmd;
  4.   uint16_t data;
  5. };

  7. /* Init script commands */
  8. enum OLED_cmd {
  9.   OLED_START,
  10.   OLED_END,
  11.   OLED_CMD,
  12.   OLED_DATA,
  13.   OLED_DELAY
  14. };
  15. //以上可放置头文件中
  16. //以下放置源文件中
  17. //初始化命令集
  18. static struct OLED_function OLED_cfg_script[] = {
  19.   {OLED_START, OLED_START},
  20.   {OLED_CMD, 0x11},
  21.   {OLED_DELAY, 120},
  22.   {OLED_CMD, 0x36},
  23.   {OLED_DATA, 0x00},
  24.   {OLED_CMD, 0x3a},
  25.   {OLED_DATA, 0x65},
  26.   {OLED_CMD, 0xb2},
  27.   {OLED_DATA, 0x0c},
  28.   {OLED_DATA, 0x0c},
  29.   {OLED_DATA, 0x00},
  30.   {OLED_DATA, 0x33},
  31.   {OLED_DATA, 0x33},
  32.   {OLED_CMD, 0xb7},
  33.   {OLED_DATA, 0x72},
  34.   {OLED_CMD, 0xbb},
  35.   {OLED_DATA, 0x3d},
  36.   {OLED_CMD, 0xc0},
  37.   {OLED_DATA, 0x2c},
  38.   {OLED_CMD, 0xc2},
  39.   {OLED_DATA, 0x01},
  40.   {OLED_CMD, 0xc3},
  41.   {OLED_DATA, 0x19},
  42.   {OLED_CMD, 0xc4},
  43.   {OLED_DATA, 0x20},
  44.   {OLED_CMD, 0xc6},
  45.   {OLED_DATA, 0x0f},
  46.   {OLED_CMD, 0xd0},
  47.   {OLED_DATA, 0xa4},
  48.   {OLED_DATA, 0xa1},
  49.   {OLED_CMD, 0xe0},
  50.   {OLED_DATA, 0x70},
  51.   {OLED_DATA, 0x04},
  52.   {OLED_DATA, 0x08},
  53.   {OLED_DATA, 0x09},
  54.   {OLED_DATA, 0x09},
  55.   {OLED_DATA, 0x05},
  56.   {OLED_DATA, 0x2a},
  57.   {OLED_DATA, 0x33},
  58.   {OLED_DATA, 0x41},
  59.   {OLED_DATA, 0x07},
  60.   {OLED_DATA, 0x13},
  61.   {OLED_DATA, 0x13},
  62.   {OLED_DATA, 0x29},
  63.   {OLED_DATA, 0x2f},
  64.   {OLED_CMD, 0xe1},
  65.   {OLED_DATA, 0x70},
  66.   {OLED_DATA, 0x03},
  67.   {OLED_DATA, 0x09},
  68.   {OLED_DATA, 0x0a},
  69.   {OLED_DATA, 0x09},
  70.   {OLED_DATA, 0x06},
  71.   {OLED_DATA, 0x2b},
  72.   {OLED_DATA, 0x34},
  73.   {OLED_DATA, 0x41},
  74.   {OLED_DATA, 0x07},
  75.   {OLED_DATA, 0x12},
  76.   {OLED_DATA, 0x14},
  77.   {OLED_DATA, 0x28},
  78.   {OLED_DATA, 0x2e},
  79.   {OLED_CMD, 0x21},
  80.   {OLED_CMD, 0x29},
  81.   {OLED_CMD, 0x2a},
  82.   {OLED_DATA, 0x00},
  83.   {OLED_DATA, 0x00},
  84.   {OLED_DATA, 0x00},
  85.   {OLED_DATA, 0xef},
  86.   {OLED_CMD, 0x2b},
  87.   {OLED_DATA, 0x00},
  88.   {OLED_DATA, 0x00},
  89.   {OLED_DATA, 0x00},
  90.   {OLED_DATA, 0xef},
  91.   {OLED_CMD, 0x2c},
  92.   {OLED_END, OLED_END},
  93. };

  95. static void OLED_run_cfg_script()
  96. {
  97.           uint8_t data[2] = {0};
  98.           int i = 0;
  99.           int end_script = 0;

  101.           do {
  102.             switch (OLED_cfg_script[i].cmd) {
  103.             case OLED_START:
  104.               break;
  105.             case OLED_CMD:
  106.               data[0] = OLED_cfg_script[i].data & 0xff;
  107.               LcdWriteReg(data[0]);
  108.               break;
  109.             case OLED_DATA:
  110.               data[0] = OLED_cfg_script[i].data & 0xff;
  111.               LcdWriteData(data[0]);
  112.               break;
  113.             case OLED_DELAY:
  114.               HAL_Delay(OLED_cfg_script[i].data);
  115.               break;
  116.             case OLED_END:
  117.               end_script = 1;
  118.             }
  119.             i++;
  120.           } while (!end_script);
  121. }
复制代码

        4）oled初始化
        进行oled屏的初始化函数设计
  1. //olde屏重置
  2. static void OLED_reset()
  3. {
  4.           OLED_RST_State(0);
  5.           HAL_Delay(200);
  6.           OLED_RST_State(1);
  7.           HAL_Delay(150);
  8. }
  9. //oled屏初始化
  10. int OLED_init()
  11. {
  12.           LCD_PWR_State(0);//回显关闭
  13.           OLED_reset();    //屏重置
  14.           OLED_run_cfg_script();//初始化指令集依次执行脚本函数
  15.           LCD_PWR_State(1);//回显开启
  16.           OLED_display_picture();//条形码屏幕显示测试

  18.           return HAL_OK;
  19. }
复制代码

        5）oled屏幕的亮屏（条形码显示）代码
  1. #define LCD_MAX_MEM16_BLOCK             (1 << 6)
  2. #define LCD_PIXEL_PER_BLOCK             (LCD_MAX_MEM16_BLOCK >> 1)

  4. static void spec_send_fb(uint16_t color, uint16_t pixel_num)
  5. {
  6.           uint16_t real_mem[LCD_MAX_MEM16_BLOCK] = {0};

  8.           for (uint16_t i = 0; i < LCD_MAX_MEM16_BLOCK; ++i) {
  9.                   real_mem[i] = color;
  10.           }
  11.           Data_Cmd_State(GPIO_PIN_SET);
  12.           if (pixel_num <= LCD_MAX_MEM16_BLOCK) {
  13.                   LcdWriteDataMultiple((uint8_t*)real_mem, pixel_num << 1);
  14.           } else {
  15.                   uint16_t count = pixel_num / LCD_MAX_MEM16_BLOCK;
  16.                   uint16_t remain = pixel_num % LCD_MAX_MEM16_BLOCK;
  17.                   for (uint16_t i = 0; i < count; ++i) {
  18.                           LcdWriteDataMultiple((uint8_t*)real_mem, LCD_MAX_MEM16_BLOCK << 1);
  19.                   }
  20.                   LcdWriteDataMultiple((uint8_t*)real_mem, remain << 1);
  21.           }
  22. }

  24. static void OLED_display_picture(void)
  25. {
  26.   LcdWriteReg(OLED_RAMWR);
  27.   spec_send_fb(0x0, WIDTH * HEIGHT / 4);
  28.   spec_send_fb(0x1111, WIDTH * HEIGHT / 4);
  29.   spec_send_fb(0x7777, WIDTH * HEIGHT / 4);
  30.   spec_send_fb(0xeeee, WIDTH * HEIGHT / 4);
  31. }
复制代码


      6）驱动调用
        基本功能完成后，在main.c文件实现函数调用
  1.   /* USER CODE BEGIN Includes */
  2. #include "../../ICore/key/key.h"
  3. #include "../../ICore/led/led.h"
  4. #include "../../ICore/print/print.h"
  5. #include "../../ICore/usart/usart.h"
  6. #include "../../ICore/oled/oled.h"
  7. /* USER CODE END Includes */
  8. ..............................................
  9.     /* USER CODE BEGIN 2 */
  10.   ResetPrintInit(&hlpuart1);
  11.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
  12.   HLPUSART_RX_STA = 0;
  13.   OLED_init();

  15.   set_led0_val(0);
  16.   set_led1_val(get_key0_val());
  17.   /* USER CODE END 2 */
  18.   /* USER CODE BEGIN WHILE */
  19.   while (1)
  20.   {
  21.     Toggle_led0();
  22.     /* USER CODE END WHILE */
复制代码

        7）编译加载到开发板上

 376beaff564d46e2a3d52ba0dd3f70f6.png

         8）屏幕效果点亮如下：

 d38922b1a0b644afa7150aa3942a6d9d.png


五、屏幕输出字符串设计
        【1】字符串编码表
        在ICore/oled目下字符串编码表ASCII.h，具体如下：
  1. /*
  2. * ASCII.h
  3. *
  4. *  Created on: Jun 11, 2022
  5. *      Author: Administrator
  6. */

  8. #ifndef OLED_ASCII_H_
  9. #define OLED_ASCII_H_

  11. // ------------------  ASCII字模的数据表 ------------------------ //
  12. // 码表从0x20~0x7e                                                //
  13. // 字库:  纵向取模下高位// （调用时要减512）
  14. // -------------------------------------------------------------- //
  15. const uint8_t ASCII_8x16[] =  {            // ASCII
  16.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  // - -
  17.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  19.         0x00,0x00,0x38,0xFC,0xFC,0x38,0x00,0x00,  // -!-
  20.         0x00,0x00,0x00,0x0D,0x0D,0x00,0x00,0x00,

  22.         0x00,0x0E,0x1E,0x00,0x00,0x1E,0x0E,0x00,  // -"-
  23.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  25.         0x20,0xF8,0xF8,0x20,0xF8,0xF8,0x20,0x00,  // -#-
  26.         0x02,0x0F,0x0F,0x02,0x0F,0x0F,0x02,0x00,

  28.         0x38,0x7C,0x44,0x47,0x47,0xCC,0x98,0x00,  // -$-
  29.         0x03,0x06,0x04,0x1C,0x1C,0x07,0x03,0x00,

  31.         0x30,0x30,0x00,0x80,0xC0,0x60,0x30,0x00,  // -%-
  32.         0x0C,0x06,0x03,0x01,0x00,0x0C,0x0C,0x00,

  34.         0x80,0xD8,0x7C,0xE4,0xBC,0xD8,0x40,0x00,  // -&-
  35.         0x07,0x0F,0x08,0x08,0x07,0x0F,0x08,0x00,

  37.         0x00,0x10,0x1E,0x0E,0x00,0x00,0x00,0x00,  // -'-
  38.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  40.         0x00,0x00,0xF0,0xF8,0x0C,0x04,0x00,0x00,  // -(-
  41.         0x00,0x00,0x03,0x07,0x0C,0x08,0x00,0x00,

  43.         0x00,0x00,0x04,0x0C,0xF8,0xF0,0x00,0x00,  // -)-
  44.         0x00,0x00,0x08,0x0C,0x07,0x03,0x00,0x00,

  46.         0x80,0xA0,0xE0,0xC0,0xC0,0xE0,0xA0,0x80,  // -*-
  47.         0x00,0x02,0x03,0x01,0x01,0x03,0x02,0x00,

  49.         0x00,0x80,0x80,0xE0,0xE0,0x80,0x80,0x00,  // -+-
  50.         0x00,0x00,0x00,0x03,0x03,0x00,0x00,0x00,

  52.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  // -,-
  53.         0x00,0x00,0x10,0x1E,0x0E,0x00,0x00,0x00,

  55.         0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x00,  // ---
  56.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  58.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  // -.-
  59.         0x00,0x00,0x00,0x0C,0x0C,0x00,0x00,0x00,

  61.         0x00,0x00,0x00,0x80,0xC0,0x60,0x30,0x00,  // -/-
  62.         0x0C,0x06,0x03,0x01,0x00,0x00,0x00,0x00,

  64.         0xF8,0xFC,0x04,0xC4,0x24,0xFC,0xF8,0x00,  // -0-
  65.         0x07,0x0F,0x09,0x08,0x08,0x0F,0x07,0x00,

  67.         0x00,0x10,0x18,0xFC,0xFC,0x00,0x00,0x00,  // -1-
  68.         0x00,0x08,0x08,0x0F,0x0F,0x08,0x08,0x00,

  70.         0x08,0x0C,0x84,0xC4,0x64,0x3C,0x18,0x00,  // -2-
  71.         0x0E,0x0F,0x09,0x08,0x08,0x0C,0x0C,0x00,

  73.         0x08,0x0C,0x44,0x44,0x44,0xFC,0xB8,0x00,  // -3-
  74.         0x04,0x0C,0x08,0x08,0x08,0x0F,0x07,0x00,

  76.         0xC0,0xE0,0xB0,0x98,0xFC,0xFC,0x80,0x00,  // -4-
  77.         0x00,0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,

  79.         0x7C,0x7C,0x44,0x44,0xC4,0xC4,0x84,0x00,  // -5-
  80.         0x04,0x0C,0x08,0x08,0x08,0x0F,0x07,0x00,

  82.         0xF0,0xF8,0x4C,0x44,0x44,0xC0,0x80,0x00,  // -6-
  83.         0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00,

  85.         0x0C,0x0C,0x04,0x84,0xC4,0x7C,0x3C,0x00,  // -7-
  86.         0x00,0x00,0x0F,0x0F,0x00,0x00,0x00,0x00,

  88.         0xB8,0xFC,0x44,0x44,0x44,0xFC,0xB8,0x00,  // -8-
  89.         0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00,

  91.         0x38,0x7C,0x44,0x44,0x44,0xFC,0xF8,0x00,  // -9-
  92.         0x00,0x08,0x08,0x08,0x0C,0x07,0x03,0x00,

  94.         0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00,  // -:-
  95.         0x00,0x00,0x00,0x06,0x06,0x00,0x00,0x00,

  97.         0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00,  // -;-
  98.         0x00,0x00,0x08,0x0E,0x06,0x00,0x00,0x00,

  100.         0x00,0x80,0xC0,0x60,0x30,0x18,0x08,0x00,  // -<-
  101.         0x00,0x00,0x01,0x03,0x06,0x0C,0x08,0x00,

  103.         0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00,  // -=-
  104.         0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x00,

  106.         0x00,0x08,0x18,0x30,0x60,0xC0,0x80,0x00,  // ->-
  107.         0x00,0x08,0x0C,0x06,0x03,0x01,0x00,0x00,

  109.         0x18,0x1C,0x04,0xC4,0xE4,0x3C,0x18,0x00,  // -?-
  110.         0x00,0x00,0x00,0x0D,0x0D,0x00,0x00,0x00,

  112.         0xF0,0xF8,0x08,0xC8,0xC8,0xF8,0xF0,0x00,  // -@-
  113.         0x07,0x0F,0x08,0x0B,0x0B,0x0B,0x01,0x00,

  115.         0xE0,0xF0,0x98,0x8C,0x98,0xF0,0xE0,0x00,  // -A-
  116.         0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00,

  118.         0x04,0xFC,0xFC,0x44,0x44,0xFC,0xB8,0x00,  // -B-
  119.         0x08,0x0F,0x0F,0x08,0x08,0x0F,0x07,0x00,

  121.         0xF0,0xF8,0x0C,0x04,0x04,0x0C,0x18,0x00,  // -C-
  122.         0x03,0x07,0x0C,0x08,0x08,0x0C,0x06,0x00,

  124.         0x04,0xFC,0xFC,0x04,0x0C,0xF8,0xF0,0x00,  // -D-
  125.         0x08,0x0F,0x0F,0x08,0x0C,0x07,0x03,0x00,

  127.         0x04,0xFC,0xFC,0x44,0xE4,0x0C,0x1C,0x00,  // -E-
  128.         0x08,0x0F,0x0F,0x08,0x08,0x0C,0x0E,0x00,

  130.         0x04,0xFC,0xFC,0x44,0xE4,0x0C,0x1C,0x00,  // -F-
  131.         0x08,0x0F,0x0F,0x08,0x00,0x00,0x00,0x00,

  133.         0xF0,0xF8,0x0C,0x84,0x84,0x8C,0x98,0x00,  // -G-
  134.         0x03,0x07,0x0C,0x08,0x08,0x07,0x0F,0x00,

  136.         0xFC,0xFC,0x40,0x40,0x40,0xFC,0xFC,0x00,  // -H-
  137.         0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00,

  139.         0x00,0x00,0x04,0xFC,0xFC,0x04,0x00,0x00,  // -I-
  140.         0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,

  142.         0x00,0x00,0x00,0x04,0xFC,0xFC,0x04,0x00,  // -J-
  143.         0x07,0x0F,0x08,0x08,0x0F,0x07,0x00,0x00,

  145.         0x04,0xFC,0xFC,0xC0,0xF0,0x3C,0x0C,0x00,  // -K-
  146.         0x08,0x0F,0x0F,0x00,0x01,0x0F,0x0E,0x00,

  148.         0x04,0xFC,0xFC,0x04,0x00,0x00,0x00,0x00,  // -L-
  149.         0x08,0x0F,0x0F,0x08,0x08,0x0C,0x0E,0x00,

  151.         0xFC,0xFC,0x38,0x70,0x38,0xFC,0xFC,0x00,  // -M-
  152.         0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00,

  154.         0xFC,0xFC,0x38,0x70,0xE0,0xFC,0xFC,0x00,  // -N-
  155.         0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00,

  157.         0xF0,0xF8,0x0C,0x04,0x0C,0xF8,0xF0,0x00,  // -O-
  158.         0x03,0x07,0x0C,0x08,0x0C,0x07,0x03,0x00,

  160.         0x04,0xFC,0xFC,0x44,0x44,0x7C,0x38,0x00,  // -P-
  161.         0x08,0x0F,0x0F,0x08,0x00,0x00,0x00,0x00,

  163.         0xF8,0xFC,0x04,0x04,0x04,0xFC,0xF8,0x00,  // -Q-
  164.         0x07,0x0F,0x08,0x0E,0x3C,0x3F,0x27,0x00,

  166.         0x04,0xFC,0xFC,0x44,0xC4,0xFC,0x38,0x00,  // -R-
  167.         0x08,0x0F,0x0F,0x00,0x00,0x0F,0x0F,0x00,

  169.         0x18,0x3C,0x64,0x44,0xC4,0x9C,0x18,0x00,  // -S-
  170.         0x06,0x0E,0x08,0x08,0x08,0x0F,0x07,0x00,

  172.         0x00,0x1C,0x0C,0xFC,0xFC,0x0C,0x1C,0x00,  // -T-
  173.         0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,

  175.         0xFC,0xFC,0x00,0x00,0x00,0xFC,0xFC,0x00,  // -U-
  176.         0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00,

  178.         0xFC,0xFC,0x00,0x00,0x00,0xFC,0xFC,0x00,  // -V-
  179.         0x01,0x03,0x06,0x0C,0x06,0x03,0x01,0x00,

  181.         0xFC,0xFC,0x00,0x80,0x00,0xFC,0xFC,0x00,  // -W-
  182.         0x03,0x0F,0x0E,0x03,0x0E,0x0F,0x03,0x00,

  184.         0x0C,0x3C,0xF0,0xC0,0xF0,0x3C,0x0C,0x00,  // -X-
  185.         0x0C,0x0F,0x03,0x00,0x03,0x0F,0x0C,0x00,

  187.         0x00,0x3C,0x7C,0xC0,0xC0,0x7C,0x3C,0x00,  // -Y-
  188.         0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,

  190.         0x1C,0x0C,0x84,0xC4,0x64,0x3C,0x1C,0x00,  // -Z-
  191.         0x0E,0x0F,0x09,0x08,0x08,0x0C,0x0E,0x00,

  193.         0x00,0x00,0xFC,0xFC,0x04,0x04,0x00,0x00,  // -[-
  194.         0x00,0x00,0x0F,0x0F,0x08,0x08,0x00,0x00,

  196.         0x38,0x70,0xE0,0xC0,0x80,0x00,0x00,0x00,  // -\-
  197.         0x00,0x00,0x00,0x01,0x03,0x07,0x0E,0x00,

  199.         0x00,0x00,0x04,0x04,0xFC,0xFC,0x00,0x00,  // -]-
  200.         0x00,0x00,0x08,0x08,0x0F,0x0F,0x00,0x00,

  202.         0x08,0x0C,0x06,0x03,0x06,0x0C,0x08,0x00,  // -^-
  203.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  205.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  // -_-
  206.         0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,

  208.         0x00,0x00,0x03,0x07,0x04,0x00,0x00,0x00,  // -`-
  209.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  211.         0x00,0xA0,0xA0,0xA0,0xE0,0xC0,0x00,0x00,  // -a-
  212.         0x07,0x0F,0x08,0x08,0x07,0x0F,0x08,0x00,

  214.         0x04,0xFC,0xFC,0x20,0x60,0xC0,0x80,0x00,  // -b-
  215.         0x08,0x0F,0x07,0x08,0x08,0x0F,0x07,0x00,

  217.         0xC0,0xE0,0x20,0x20,0x20,0x60,0x40,0x00,  // -c-
  218.         0x07,0x0F,0x08,0x08,0x08,0x0C,0x04,0x00,

  220.         0x80,0xC0,0x60,0x24,0xFC,0xFC,0x00,0x00,  // -d-
  221.         0x07,0x0F,0x08,0x08,0x07,0x0F,0x08,0x00,

  223.         0xC0,0xE0,0xA0,0xA0,0xA0,0xE0,0xC0,0x00,  // -e-
  224.         0x07,0x0F,0x08,0x08,0x08,0x0C,0x04,0x00,

  226.         0x40,0xF8,0xFC,0x44,0x0C,0x18,0x00,0x00,  // -f-
  227.         0x08,0x0F,0x0F,0x08,0x00,0x00,0x00,0x00,

  229.         0xC0,0xE0,0x20,0x20,0xC0,0xE0,0x20,0x00,  // -g-
  230.         0x27,0x6F,0x48,0x48,0x7F,0x3F,0x00,0x00,

  232.         0x04,0xFC,0xFC,0x40,0x20,0xE0,0xC0,0x00,  // -h-
  233.         0x08,0x0F,0x0F,0x00,0x00,0x0F,0x0F,0x00,

  235.         0x00,0x00,0x20,0xEC,0xEC,0x00,0x00,0x00,  // -i-
  236.         0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,

  238.         0x00,0x00,0x00,0x00,0x20,0xEC,0xEC,0x00,  // -j-
  239.         0x00,0x30,0x70,0x40,0x40,0x7F,0x3F,0x00,

  241.         0x04,0xFC,0xFC,0x80,0xC0,0x60,0x20,0x00,  // -k-
  242.         0x08,0x0F,0x0F,0x01,0x03,0x0E,0x0C,0x00,

  244.         0x00,0x00,0x04,0xFC,0xFC,0x00,0x00,0x00,  // -l-
  245.         0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,

  247.         0xE0,0xE0,0x60,0xC0,0x60,0xE0,0xC0,0x00,  // -m-
  248.         0x0F,0x0F,0x00,0x0F,0x00,0x0F,0x0F,0x00,

  250.         0x20,0xE0,0xC0,0x20,0x20,0xE0,0xC0,0x00,  // -n-
  251.         0x00,0x0F,0x0F,0x00,0x00,0x0F,0x0F,0x00,

  253.         0xC0,0xE0,0x20,0x20,0x20,0xE0,0xC0,0x00,  // -o-
  254.         0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00,

  256.         0x20,0xE0,0xC0,0x20,0x20,0xE0,0xC0,0x00,  // -p-
  257.         0x40,0x7F,0x7F,0x48,0x08,0x0F,0x07,0x00,

  259.         0xC0,0xE0,0x20,0x20,0xC0,0xE0,0x20,0x00,  // -q-
  260.         0x07,0x0F,0x08,0x48,0x7F,0x7F,0x40,0x00,

  262.         0x20,0xE0,0xC0,0x60,0x20,0x60,0xC0,0x00,  // -r-
  263.         0x08,0x0F,0x0F,0x08,0x00,0x00,0x00,0x00,

  265.         0x40,0xE0,0xA0,0x20,0x20,0x60,0x40,0x00,  // -s-
  266.         0x04,0x0C,0x09,0x09,0x0B,0x0E,0x04,0x00,

  268.         0x20,0x20,0xF8,0xFC,0x20,0x20,0x00,0x00,  // -t-
  269.         0x00,0x00,0x07,0x0F,0x08,0x0C,0x04,0x00,

  271.         0xE0,0xE0,0x00,0x00,0xE0,0xE0,0x00,0x00,  // -u-
  272.         0x07,0x0F,0x08,0x08,0x07,0x0F,0x08,0x00,

  274.         0x00,0xE0,0xE0,0x00,0x00,0xE0,0xE0,0x00,  // -v-
  275.         0x00,0x03,0x07,0x0C,0x0C,0x07,0x03,0x00,

  277.         0xE0,0xE0,0x00,0x00,0x00,0xE0,0xE0,0x00,  // -w-
  278.         0x07,0x0F,0x0C,0x07,0x0C,0x0F,0x07,0x00,

  280.         0x20,0x60,0xC0,0x80,0xC0,0x60,0x20,0x00,  // -x-
  281.         0x08,0x0C,0x07,0x03,0x07,0x0C,0x08,0x00,

  283.         0xE0,0xE0,0x00,0x00,0x00,0xE0,0xE0,0x00,  // -y-
  284.         0x47,0x4F,0x48,0x48,0x68,0x3F,0x1F,0x00,

  286.         0x60,0x60,0x20,0xA0,0xE0,0x60,0x20,0x00,  // -z-
  287.         0x0C,0x0E,0x0B,0x09,0x08,0x0C,0x0C,0x00,

  289.         0x00,0x40,0x40,0xF8,0xBC,0x04,0x04,0x00,  // -{-
  290.         0x00,0x00,0x00,0x07,0x0F,0x08,0x08,0x00,

  292.         0x00,0x00,0x00,0xBC,0xBC,0x00,0x00,0x00,  // -|-
  293.         0x00,0x00,0x00,0x0F,0x0F,0x00,0x00,0x00,

  295.         0x00,0x04,0x04,0xBC,0xF8,0x40,0x40,0x00,  // -}-
  296.         0x00,0x08,0x08,0x0F,0x07,0x00,0x00,0x00,

  298.         0x08,0x0C,0x04,0x0C,0x08,0x0C,0x04,0x00,  // -~-
  299.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  301.         0x80,0xC0,0x60,0x30,0x60,0xC0,0x80,0x00,  // --
  302.         0x07,0x07,0x04,0x04,0x04,0x07,0x07,0x00,
  303. };

  305. #endif /* OLED_ASCII_H_ */
复制代码

【2】将创建屏幕打印函数，输出显示字符串能力
        （1）首选了解ASCII_8x16字库表如何使用的，例如我们取"!"为例：
  1. ！16个8bit的字段的二进制表示如下
  2. 0X00     0 0 0 0 0 0 0 0
  3. 0X00     0 0 0 0 0 0 0 0
  4. 0X38     0 0 1 1 1 0 0 0
  5. 0XFC     1 1 1 1 1 1 0 0
  6. 0XFC     1 1 1 1 1 1 0 0
  7. 0X38     0 0 1 1 1 0 0 0
  8. 0X00     0 0 0 0 0 0 0 0
  9. 0X00     0 0 0 0 0 0 0 0

  11. 0X00     0 0 0 0 0 0 0 0
  12. 0X00     0 0 0 0 0 0 0 0
  13. 0X00     0 0 0 0 0 0 0 0
  14. 0X0D     0 0 0 0 1 1 0 1
  15. 0X0D     0 0 0 0 1 1 0 1
  16. 0X00     0 0 0 0 0 0 0 0
  17. 0X00     0 0 0 0 0 0 0 0
  18. 0X00     0 0 0 0 0 0 0 0
复制代码

        （2）将划分为前8*8和后8*8的的二进制矩阵，将8*8矩阵做逆时针（90度）翻转，将翻转后矩阵进行紧凑（去掉空格），这些“1”组成了一个大的“！”字符如下：
  1. //将8*8二进制矩阵翻转
  2. 0X000X000X380XFC0XFC0X380X000X00
  3. 0        0        0        0        0        0        0        0
  4. 0        0        0        0        0        0        0        0
  5. 0        0        0        1        1        0        0        0
  6. 0        0        1        1        1        1        0        0
  7. 0        0        1        1        1        1        0        0
  8. 0        0        1        1        1        1        0        0
  9. 0        0        0        1        1        0        0        0
  10. 0        0        0        1        1        0        0        0
  11. 0X000X000X000X0D0X0D0X000X000X00
  12. 0        0        0        1        1        0        0        0
  13. 0        0        0        0        0        0        0        0
  14. 0        0        0        1        1        0        0        0
  15. 0        0        0        1        1        0        0        0
  16. 0        0        0        0        0        0        0        0
  17. 0        0        0        0        0        0        0        0
  18. 0        0        0        0        0        0        0        0
  19. 0        0        0        0        0        0        0        0

  21. 将上述矩阵进行紧凑（去掉空格），这些“1”组成了一个大的“！”字符
  22. 00000000
  23. 00000000
  24. 00011000
  25. 00111100
  26. 00111100
  27. 00111100
  28. 00011000
  29. 00011000
  30. 00011000
  31. 00000000
  32. 00011000
  33. 00011000
  34. 00000000
  35. 00000000
  36. 00000000
  37. 00000000
  38. //显然，在代码实现中，每个字符就是8*16像素的二进制矩阵，我们将“1”的绘制前景色，“0”的绘制背景色，就能显示字符
复制代码

        （3）显然，在代码实现中，每个字符就是8*16像素的二进制矩阵，我们将“1”的绘制前景色，“0”的绘制背景色，就能显示字符

        现在给出字符8*16二进制矩阵获取代码：
  1. //addr为字符的地址信息
  2.         uint8_t buffer[16][8]={0};
  3.         for(uint8_t i=0; i<16; i++)
  4.         {
  5.                 uint16_t buf=ASCII_8x16[(addr*16)+i-512];
  6.                 printf("0X%02X ",buf);
  7.                 for(uint8_t j=0;j<8;j++){
  8.                         printf("%d ",(0x01&(buf>>j))>0?0x01:0x00);//注意这里低字节开始取值,与前面分析的就刚好反至了,但原理是一样的
  9.                         buffer[8*(i/8)+j][i%8]=(0x01&(buf>>j))>0?1:0;
  10.                 }
  11.                 printf("\r\n");
  12.         }
  13.         for(uint8_t i=0; i<16; i++)
  14.         {
  15.                 for(uint8_t j=0;j<8;j++){
  16.                         printf("%d",buffer[i][j]);
  17.                 }
  18.                 printf("\r\n");
  19.         }
复制代码

        （4）测试“！”输出如下，妥妥的一个!，需要注意的是，下图第一部分的打印输出，由于我们打印时从低字节位开始取数，和前面分析（步骤（1）是从高位取数）的呈现出反至效果：

 881370147d4d419095351e2f7926aea1.png

【3】字符串olde输出
        知道一个字符如何在屏幕输出，那么一个字符串输出就是逐个8*16的像素格子渲染输出，具体代码设置如下，OLED_printf实现在屏幕指定位置开始，打印输出字符串，字符串如果过大，将更换到下一行（即y方向下移16像素，屏幕左上角位置为0,0，向右为X轴方向递增，向下位Y轴方向递增），因此该函数会将输入的字符串进行切分成多行。OLED_DISPLAY_8x16函数用于在oled屏幕上输出一个字符的8*16像素绘制。OLED_printf_US测试通过调研OLED_DISPLAY_8x16实现一行字符的输出。
  1. //显示英文与数字8*16的ASCII码
  2. void OLED_DISPLAY_8x16(uint8_t x, uint8_t y, uint16_t w){ //要显示汉字的编号
  3. //        printf("x=%d,y=%d,w=0X%04X w*16-512=%d\r\n",x,y,w,w*16-512);
  4.         uint16_t color = 0;
  5.         uint16_t textData[16][8]={0};
  6. //        uint8_t buffer[16][8]={0};
  7.         for(uint8_t i=0; i<16; i++)
  8.         {
  9.                 uint16_t buf=ASCII_8x16[(w*16)+i-512];
  10. //                printf("0X%02X ",buf);
  11.                 for(uint8_t j=0;j<8;j++){
  12. //                        printf("%d ",(0x01&(buf>>j))>0?0x01:0x00);
  13. //                        buffer[8*(i/8)+j][i%8]=(0x01&(buf>>j))>0?1:0;
  14.                         color = (0x01&(buf>>j))>0?LCD_DISP_BLACK:LCD_DISP_BLUE;
  15.                         textData[8*(i/8)+j][i%8] = color;
  16. //                        OLED_WritePixel(x+i%8,y+8*(i/8)+j,color);//单像素渲染
  17.                 }
  18. //                printf("\r\n");
  19.         }
  20.         for(uint8_t i=0; i<16; i++)
  21.         {
  22.                 OLED_WriteLine(x,y+i,textData[i],8);//列像素渲染
  23. //                for(uint8_t j=0;j<8;j++){
  24. //                        printf("%d",buffer[i][j]);
  25. //                }
  26. //                printf("\r\n");
  27.         }
  28. }

  30. //用于OLED_printf函数专用的显示程序
  31. void OLED_printf_US(uint8_t xpos,uint8_t ypos,uint8_t *str,uint8_t i){
  32.         uint8_t r=0;
  33.         while(i != r){//i是长度值，当显示到i之后退出
  34.                 OLED_DISPLAY_8x16(xpos+r*8,ypos,*str++);//显示英文与数字8*16的ASCII码
  35.                 r++;
  36.     }
  37. }
  38. //OLED专用的printf函数
  39. //调用方法：OLED_printf(0,0,"123");
  40. //注意若xpos或ypos过大，并内容较多时，会出现溢出边界
  41. #define line_size 29
  42. #define row_size 16
  43. void OLED_printf (uint8_t xpos,uint8_t ypos,char *fmt, ...)
  44. {
  45.     char buff[line_size];  //用于存放转换后的数据 [长度],限定30字符长度，每个字符8像素宽度，屏幕宽240
  46.     uint16_t size=0;
  47.     uint16_t row = 1+strlen(fmt)/line_size;//暂时没考虑自带换行符号情况
  48. //    printf("row=%d\r\n",row);
  49.     for(uint16_t i=0;i<row;i++){
  50.         va_list arg_ptr;
  51.         va_start(arg_ptr,fmt);
  52.         vsnprintf(buff, line_size,fmt+i*line_size,arg_ptr);//数据转换
  53.         size=strlen(buff);                                        //得出数据长度
  54.         if(strlen(buff)>line_size)size=line_size;                        //如果长度大于最大值，则长度等于最大值（多出部分忽略）
  55.         OLED_printf_US(xpos,ypos+i*row_size,(uint8_t *)buff,size);//最终调用OLED专用的printf函数来显示
  56.         va_end(arg_ptr);
  57.     }
  58. }
复制代码

【4】SPI的直接输出和DMA输出区别实现
        设置两个清屏函数BSP_LCD_Clear和BSP_LCD_Clear_DMA，一个采用HAL_SPI_Transmit写入数据显示，前面所述都是这种方式（通过调用LcdWriteData、LcdWriteDataMultiple，这个函数采用HAL_SPI_Transmit实现的），一个调用HAL_SPI_Transmit_DMA写入数据显示。

        BSP_LCD_Clear实现就是调用LcdWriteDataMultiple绘制240行的线，BSP_LCD_Clear_DMA实现就是分为两个半屏绘制（HAL_SPI_Transmit_DMA的接收数据组大小类型是uint16_t，最大支持0xfff,65535）。
  1. static void LCD_Address_Set(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2)
  2. {
  3.     /* 指定X方向操作区域 */
  4.         LcdWriteReg(0x2a);
  5.         LcdWriteData(x1 >> 8);
  6.         LcdWriteData(x1);
  7.         LcdWriteData(x2 >> 8);
  8.         LcdWriteData(x2);

  10.     /* 指定Y方向操作区域 */
  11.         LcdWriteReg(0x2b);
  12.     LcdWriteData(y1 >> 8);
  13.     LcdWriteData(y1);
  14.     LcdWriteData(y2 >> 8);
  15.     LcdWriteData(y2);

  17.     /* 发送该命令，LCD开始等待接收显存数据 */
  18.     LcdWriteReg(0x2C);
  19. }
  20. //指定位置，绘制一行像素直到屏幕右侧
  21. void OLED_SetCursor(uint16_t Xpos, uint16_t Ypos)
  22. {
  23.         LCD_Address_Set(Xpos,Ypos,WIDTH-1,Ypos);
  24. }

  26. void BSP_LCD_Clear(uint16_t Color)
  27. {
  28.         uint8_t black_gui[480] = {0};
  29.         memset(black_gui, Color, sizeof(black_gui));

  31.         for (uint32_t counter = 0; counter < 240; counter++)
  32.         {
  33.                 /* Set Cursor */
  34.                 OLED_SetCursor(0, counter);
  35.                 /* Prepare to write to LCD RAM */
  36.                 OLED_WriteReg(0x2C, (uint8_t*)NULL, 0);
  37.                 /* RAM write data command */
  38.                 LcdWriteDataMultiple(black_gui, 480);
  39.         }
  40. }

  42. extern volatile uint8_t one_frame_done;
  43. void BSP_LCD_Clear_DMA(uint16_t Color)
  44. {
  45.         uint8_t black_gui_DMA[WIDTH*HEIGHT*2] = {0X00};
  46.         for(uint32_t i=0; i<WIDTH*HEIGHT; i++)
  47.         {
  48.                 black_gui_DMA[2*i]=Color>>8;
  49.                 black_gui_DMA[2*i+1] = Color;
  50.         }
  51.         printf("0X%02x%02x\r\n",black_gui_DMA[0],black_gui_DMA[1]);
  52.         //需要分两次写入HAL_SPI_Transmit_DMA写入缓存大小uint16_t(0xfff,65535)
  53.         one_frame_done = 0;
  54.     /* 指定显存操作地址为全屏*/
  55.     LCD_Address_Set(0, 0, WIDTH - 1, HEIGHT/2 - 1);
  56.     Data_Cmd_State(1);/* 指定接下来的数据为数据 */
  57.     /*DMA 写前半屏*/
  58.     HAL_SPI_Transmit_DMA(&hspi1,black_gui_DMA, WIDTH*HEIGHT);
  59.     while(!one_frame_done){/*release cpu and doing something else*/}
  60.         one_frame_done = 0;
  61.     /* 指定显存操作地址为全屏*/
  62.     LCD_Address_Set(0, HEIGHT/2, WIDTH - 1, HEIGHT - 1);
  63.     Data_Cmd_State(1);/* 指定接下来的数据为数据 */
  64.     /*DMA 写后半屏*/
  65.     HAL_SPI_Transmit_DMA(&hspi1,black_gui_DMA+WIDTH*HEIGHT, WIDTH*HEIGHT);
  66.     while(!one_frame_done){/*release cpu and doing something else*/}
  67. }
复制代码

        前文3.3小节，已经开启了SPI的外部中断功能，则SPI的回调函数会被调用。one_frame_done是一个全局变量，在spi.c中定义，需要在spi.c加上HAL_SPI_TxCpltCallback的函数，用来替换stm32l4xx_hal_spi.c文件的spi中断回调实现：
  1. //spi.c末加上spi的中断回调实现
  2. /* USER CODE BEGIN 1 */
  3. volatile uint8_t one_frame_done;
  4. void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)
  5. {
  6.         one_frame_done = 1;
  7. }
  8. /* USER CODE END 1 */

  10. //用来替换调stm32l4xx_hal_spi.c的弱函数
  11. __weak void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)
  12. {
  13.   /* Prevent unused argument(s) compilation warning */
  14.   UNUSED(hspi);

  16.   /* NOTE : This function should not be modified, when the callback is needed,
  17.             the HAL_SPI_TxCpltCallback should be implemented in the user file
  18.    */
  19. }
复制代码

六、程序编译及测试
        在main.c中加入按键功能，一个按键直接写入方式清屏（黑屏），一个按键DMA写入方式清屏（蓝屏幕），一个按键实现屏幕输出一段文字，另外通过串口发送字符串，实现在屏幕输出显示。
  1. /* USER CODE BEGIN WHILE */
  2.   while (1)
  3.   {
  4.           if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
  5.                   OLED_printf(10,10,"%.*s",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
  6.                   HLPUSART_RX_STA=0;//接收错误,重新开始
  7.                   HAL_Delay(100);//等待
  8.           }
  9.           if(KEY_0())
  10.           {
  11.                   OLED_printf(10,10,"hello world to stm32!I am an embedded enthusiast.");
  12.                   OLED_printf(10,48,"  STM32CubeIDE is an advanced C/C++ development platform "
  13.                                   "with peripheral configuration, code generation, code compilation, "
  14.                                   "and debug features for STM32 micro controllers and microprocessors.");
  15. //                  OLED_printf(10,10,"!");
  16.           }
  17.           if(KEY_1())
  18.           {
  19.                   BSP_LCD_Clear(0xF800);
  20.                   printf("OLED_Clear\r\n");
  21.           }
  22.           if(KEY_2())
  23.           {
  24.                   BSP_LCD_Clear_DMA(LCD_DISP_BLUE);
  25.                   printf("OLED_Clear_DMA\r\n");
  26.           }
  27.         Toggle_led0();
  28.     /* USER CODE END WHILE */
复制代码

        编译完成后测试效果如下：

        1）按键key1清屏，发送字符串

 2e9a5bb3b7d045989cff15c0cb8bc46d.png

b568c269e9924186bbdc42a1f67fb951.png


        2）按键key0，输出一段文字

 8ac981ffb14548348592079d236efe9b.png


七、附件
        oled.h
  1. #ifndef _OLED_H_
  2. #define _OLED_H_
  3. /*
  4. * for st7789 oled 模组
  5. */
  6. #define WIDTH                240
  7. #define HEIGHT                240
  8. #define BPP                16

  10. /* Init script function */
  11. struct OLED_function {
  12.   uint8_t cmd;
  13.   uint16_t data;
  14. };

  16. /* Init script commands */
  17. enum OLED_cmd {
  18.   OLED_START,
  19.   OLED_END,
  20.   OLED_CMD,
  21.   OLED_DATA,
  22.   OLED_DELAY
  23. };

  25. /************** 颜色(RGB 5,6,5) **************/
  26. #define LCD_DISP_RED                    0xF800       //先高字节，后低字节
  27. #define LCD_DISP_GREEN                  0x07E0
  28. #define LCD_DISP_BLUE                   0x001F
  29. #define LCD_DISP_WRITE                  0xFFFF
  30. #define LCD_DISP_BLACK                  0x0000
  31. #define LCD_DISP_GRAY                   0xEF5D
  32. #define LCD_DISP_GRAY75                 0x39E7
  33. #define LCD_DISP_GRAY50                 0x7BEF
  34. #define LCD_DISP_GRAY25                 0xADB5

  36. /* oled Commands */
  37. #define OLED_CASET        0x2A
  38. #define OLED_RASET        0x2B
  39. #define OLED_RAMWR        0x2C
  40. #define OLED_RAMRD        0x2E

  42. //对该位写1或0
  43. #define Data_Cmd_State(__D_C_State__)        HAL_GPIO_WritePin(LCD_DCX_GPIO_Port, LCD_DCX_Pin, (GPIO_PinState)(__D_C_State__))
  44. #define OLED_RST_State(__RST_State__)        HAL_GPIO_WritePin(LCD_RST_GPIO_Port, LCD_RST_Pin, (GPIO_PinState)(__RST_State__))
  45. #define LCD_PWR_State(__PWR_State__)        HAL_GPIO_WritePin(LCD_PWR_GPIO_Port, LCD_PWR_Pin, (GPIO_PinState)(__PWR_State__))

  47. int OLED_init();
  48. void LcdWriteReg(uint8_t Data);
  49. void LcdWriteData(uint8_t Data);
  50. void LcdWriteDataMultiple(uint8_t * pData, uint32_t NumItems);

  52. void OLED_WritePixel(uint16_t Xpos, uint16_t Ypos, uint16_t RGBCode);
  53. void OLED_WriteLine(uint16_t Xpos, uint16_t Ypos, uint16_t *RGBCode, uint16_t pointNum);

  55. void BSP_LCD_Clear(uint16_t Color);
  56. void BSP_LCD_Clear_DMA(uint16_t Color);
  57. void OLED_printf (uint8_t xpos,uint8_t ypos,char *fmt, ...);

  59. #endif /* __oled_H */
复制代码

oled.c
  1. #include "stm32l4xx_hal.h"
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <stdarg.h>
  6. #include "main.h"
  7. #include "ASCII.h"
  8. #include "oled.h"

  10. extern SPI_HandleTypeDef hspi1;
  11. //初始化命令集
  12. static struct OLED_function OLED_cfg_script[] = {
  13.   {OLED_START, OLED_START},
  14.   {OLED_CMD, 0x11},
  15.   {OLED_DELAY, 120},
  16.   {OLED_CMD, 0x36},
  17.   {OLED_DATA, 0x00},
  18.   {OLED_CMD, 0x3a},
  19.   {OLED_DATA, 0x65},
  20.   {OLED_CMD, 0xb2},
  21.   {OLED_DATA, 0x0c},
  22.   {OLED_DATA, 0x0c},
  23.   {OLED_DATA, 0x00},
  24.   {OLED_DATA, 0x33},
  25.   {OLED_DATA, 0x33},
  26.   {OLED_CMD, 0xb7},
  27.   {OLED_DATA, 0x72},
  28.   {OLED_CMD, 0xbb},
  29.   {OLED_DATA, 0x3d},
  30.   {OLED_CMD, 0xc0},
  31.   {OLED_DATA, 0x2c},
  32.   {OLED_CMD, 0xc2},
  33.   {OLED_DATA, 0x01},
  34.   {OLED_CMD, 0xc3},
  35.   {OLED_DATA, 0x19},
  36.   {OLED_CMD, 0xc4},
  37.   {OLED_DATA, 0x20},
  38.   {OLED_CMD, 0xc6},
  39.   {OLED_DATA, 0x0f},
  40.   {OLED_CMD, 0xd0},
  41.   {OLED_DATA, 0xa4},
  42.   {OLED_DATA, 0xa1},
  43.   {OLED_CMD, 0xe0},
  44.   {OLED_DATA, 0x70},
  45.   {OLED_DATA, 0x04},
  46.   {OLED_DATA, 0x08},
  47.   {OLED_DATA, 0x09},
  48.   {OLED_DATA, 0x09},
  49.   {OLED_DATA, 0x05},
  50.   {OLED_DATA, 0x2a},
  51.   {OLED_DATA, 0x33},
  52.   {OLED_DATA, 0x41},
  53.   {OLED_DATA, 0x07},
  54.   {OLED_DATA, 0x13},
  55.   {OLED_DATA, 0x13},
  56.   {OLED_DATA, 0x29},
  57.   {OLED_DATA, 0x2f},
  58.   {OLED_CMD, 0xe1},
  59.   {OLED_DATA, 0x70},
  60.   {OLED_DATA, 0x03},
  61.   {OLED_DATA, 0x09},
  62.   {OLED_DATA, 0x0a},
  63.   {OLED_DATA, 0x09},
  64.   {OLED_DATA, 0x06},
  65.   {OLED_DATA, 0x2b},
  66.   {OLED_DATA, 0x34},
  67.   {OLED_DATA, 0x41},
  68.   {OLED_DATA, 0x07},
  69.   {OLED_DATA, 0x12},
  70.   {OLED_DATA, 0x14},
  71.   {OLED_DATA, 0x28},
  72.   {OLED_DATA, 0x2e},
  73.   {OLED_CMD, 0x21},
  74.   {OLED_CMD, 0x29},
  75.   {OLED_CMD, 0x2a},
  76.   {OLED_DATA, 0x00},
  77.   {OLED_DATA, 0x00},
  78.   {OLED_DATA, 0x00},
  79.   {OLED_DATA, 0xef},
  80.   {OLED_CMD, 0x2b},
  81.   {OLED_DATA, 0x00},
  82.   {OLED_DATA, 0x00},
  83.   {OLED_DATA, 0x00},
  84.   {OLED_DATA, 0xef},
  85.   {OLED_CMD, 0x2c},
  86.   {OLED_END, OLED_END},
  87. };

  89. static void OLED_run_cfg_script()
  90. {
  91.           uint8_t data[2] = {0};
  92.           int i = 0;
  93.           int end_script = 0;

  95.           do {
  96.             switch (OLED_cfg_script[i].cmd) {
  97.             case OLED_START:
  98.               break;
  99.             case OLED_CMD:
  100.               data[0] = OLED_cfg_script[i].data & 0xff;
  101.               LcdWriteReg(data[0]);
  102.               break;
  103.             case OLED_DATA:
  104.               data[0] = OLED_cfg_script[i].data & 0xff;
  105.               LcdWriteData(data[0]);
  106.               break;
  107.             case OLED_DELAY:
  108.               HAL_Delay(OLED_cfg_script[i].data);
  109.               break;
  110.             case OLED_END:
  111.               end_script = 1;
  112.             }
  113.             i++;
  114.           } while (!end_script);
  115. }

  117. static void OLED_reset()
  118. {
  119.           OLED_RST_State(0);
  120.           HAL_Delay(200);
  121.           OLED_RST_State(1);
  122.           HAL_Delay(150);
  123. }

  125. #define LCD_MAX_MEM16_BLOCK             (1 << 6)
  126. #define LCD_PIXEL_PER_BLOCK             (LCD_MAX_MEM16_BLOCK >> 1)

  128. static void spec_send_fb(uint16_t color, uint16_t pixel_num)
  129. {
  130.           uint16_t real_mem[LCD_MAX_MEM16_BLOCK] = {0};

  132.           for (uint16_t i = 0; i < LCD_MAX_MEM16_BLOCK; ++i) {
  133.                   real_mem[i] = color;
  134.           }
  135. //          HAL_GPIO_WritePin(LCD_DCX_GPIO_Port, LCD_DCX_Pin, GPIO_PIN_SET);
  136.           Data_Cmd_State(GPIO_PIN_SET);
  137.           if (pixel_num <= LCD_MAX_MEM16_BLOCK) {
  138.                   LcdWriteDataMultiple((uint8_t*)real_mem, pixel_num << 1);
  139.           } else {
  140.                   uint16_t count = pixel_num / LCD_MAX_MEM16_BLOCK;
  141.                   uint16_t remain = pixel_num % LCD_MAX_MEM16_BLOCK;
  142.                   for (uint16_t i = 0; i < count; ++i) {
  143.                           LcdWriteDataMultiple((uint8_t*)real_mem, LCD_MAX_MEM16_BLOCK << 1);
  144.                   }
  145.                   LcdWriteDataMultiple((uint8_t*)real_mem, remain << 1);
  146.           }
  147. }

  149. static void OLED_display_picture(void)
  150. {
  151.   LcdWriteReg(OLED_RAMWR);
  152.   spec_send_fb(0x0, WIDTH * HEIGHT / 4);
  153.   spec_send_fb(0x1111, WIDTH * HEIGHT / 4);
  154.   spec_send_fb(0x7777, WIDTH * HEIGHT / 4);
  155.   spec_send_fb(0xeeee, WIDTH * HEIGHT / 4);
  156. }


  159. int OLED_init()
  160. {
  161.           LCD_PWR_State(0);//回显关闭
  162.           OLED_reset();
  163.           OLED_run_cfg_script();
  164.           LCD_PWR_State(1);//回显开启
  165.           OLED_display_picture();

  167.           return HAL_OK;
  168. }

  170. void OLED_WriteReg(uint8_t Command, uint8_t *Parameters, uint8_t NbParameters)
  171. {
  172.           /* Send command */
  173.           LcdWriteReg(Command);

  175.           /* Send command's parameters if any */
  176.           for (uint8_t i=0; i<NbParameters; i++)
  177.           {
  178.             LcdWriteData(Parameters[i]);
  179.           }
  180. }

  182. static void LCD_Address_Set(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2)
  183. {
  184.     /* 指定X方向操作区域 */
  185.         LcdWriteReg(0x2a);
  186.         LcdWriteData(x1 >> 8);
  187.         LcdWriteData(x1);
  188.         LcdWriteData(x2 >> 8);
  189.         LcdWriteData(x2);

  191.     /* 指定Y方向操作区域 */
  192.         LcdWriteReg(0x2b);
  193.     LcdWriteData(y1 >> 8);
  194.     LcdWriteData(y1);
  195.     LcdWriteData(y2 >> 8);
  196.     LcdWriteData(y2);

  198.     /* 发送该命令，LCD开始等待接收显存数据 */
  199.     LcdWriteReg(0x2C);
  200. }

  202. void OLED_SetCursor(uint16_t Xpos, uint16_t Ypos)
  203. {
  204.         LCD_Address_Set(Xpos,Ypos,WIDTH-1,Ypos);
  205. }

  207. void BSP_LCD_Clear(uint16_t Color)
  208. {
  209.         uint8_t black_gui[480] = {0};
  210.         memset(black_gui, Color, sizeof(black_gui));

  212.         for (uint32_t counter = 0; counter < 240; counter++)
  213.         {
  214.                 /* Set Cursor */
  215.                 OLED_SetCursor(0, counter);
  216.                 /* Prepare to write to LCD RAM */
  217.                 OLED_WriteReg(0x2C, (uint8_t*)NULL, 0);
  218.                 /* RAM write data command */
  219.                 LcdWriteDataMultiple(black_gui, 480);
  220.         }
  221. }

  223. extern volatile uint8_t one_frame_done;
  224. void BSP_LCD_Clear_DMA(uint16_t Color)
  225. {
  226.         uint8_t black_gui_DMA[WIDTH*HEIGHT*2] = {0X00};
  227.         for(uint32_t i=0; i<WIDTH*HEIGHT; i++)
  228.         {
  229.                 black_gui_DMA[2*i]=Color>>8;
  230.                 black_gui_DMA[2*i+1] = Color;
  231.         }
  232.         printf("0X%02x%02x\r\n",black_gui_DMA[0],black_gui_DMA[1]);
  233.         //需要分两次写入HAL_SPI_Transmit_DMA写入缓存大小uint16_t(0xfff,65535)
  234.         one_frame_done = 0;
  235.     /* 指定显存操作地址为全屏*/
  236.     LCD_Address_Set(0, 0, WIDTH - 1, HEIGHT/2 - 1);
  237.     Data_Cmd_State(1);/* 指定接下来的数据为数据 */
  238.     /*DMA 写前半屏*/
  239.     HAL_SPI_Transmit_DMA(&hspi1,black_gui_DMA, WIDTH*HEIGHT);
  240.     while(!one_frame_done){/*release cpu and doing something else*/}
  241.         one_frame_done = 0;
  242.     /* 指定显存操作地址为全屏*/
  243.     LCD_Address_Set(0, HEIGHT/2, WIDTH - 1, HEIGHT - 1);
  244.     Data_Cmd_State(1);/* 指定接下来的数据为数据 */
  245.     /*DMA 写后半屏*/
  246.     HAL_SPI_Transmit_DMA(&hspi1,black_gui_DMA+WIDTH*HEIGHT, WIDTH*HEIGHT);
  247.     while(!one_frame_done){/*release cpu and doing something else*/}
  248. }

  250. //显示英文与数字8*16的ASCII码
  251. void OLED_DISPLAY_8x16(uint8_t x, uint8_t y, uint16_t w){ //要显示汉字的编号
  252. //        printf("x=%d,y=%d,w=0X%04X w*16-512=%d\r\n",x,y,w,w*16-512);
  253.         uint16_t color = 0;
  254.         uint16_t textData[16][8]={0};
  255. //        uint8_t buffer[16][8]={0};
  256.         for(uint8_t i=0; i<16; i++)
  257.         {
  258.                 uint16_t buf=ASCII_8x16[(w*16)+i-512];
  259. //                printf("0X%02X ",buf);
  260.                 for(uint8_t j=0;j<8;j++){
  261. //                        printf("%d ",(0x01&(buf>>j))>0?0x01:0x00);
  262. //                        buffer[8*(i/8)+j][i%8]=(0x01&(buf>>j))>0?1:0;
  263.                         color = (0x01&(buf>>j))>0?LCD_DISP_BLACK:LCD_DISP_BLUE;
  264.                         textData[8*(i/8)+j][i%8] = color;
  265. //                        OLED_WritePixel(x+i%8,y+8*(i/8)+j,color);//单像素渲染
  266.                 }
  267. //                printf("\r\n");
  268.         }
  269.         for(uint8_t i=0; i<16; i++)
  270.         {
  271.                 OLED_WriteLine(x,y+i,textData[i],8);//列像素渲染
  272. //                for(uint8_t j=0;j<8;j++){
  273. //                        printf("%d",buffer[i][j]);
  274. //                }
  275. //                printf("\r\n");
  276.         }
  277. }

  279. //用于OLED_printf函数专用的显示程序
  280. void OLED_printf_US(uint8_t xpos,uint8_t ypos,uint8_t *str,uint8_t i){
  281.         uint8_t r=0;
  282.         while(i != r){//i是长度值，当显示到i之后退出
  283.                 OLED_DISPLAY_8x16(xpos+r*8,ypos,*str++);//显示英文与数字8*16的ASCII码
  284.                 r++;
  285.     }
  286. }
  287. //OLED专用的printf函数
  288. //调用方法：OLED_printf(0,0,"123");
  289. //注意若xpos或ypos过大，并内容较多时，会出现溢出边界
  290. #define line_size 29
  291. #define row_size 16
  292. void OLED_printf (uint8_t xpos,uint8_t ypos,char *fmt, ...)
  293. {
  294.     char buff[line_size];  //用于存放转换后的数据 [长度],限定30字符长度，每个字符8像素宽度，屏幕宽240
  295.     uint16_t size=0;
  296.     uint16_t row = 1+strlen(fmt)/line_size;//暂时没考虑自带换行符号情况
  297. //    printf("row=%d\r\n",row);
  298.     for(uint16_t i=0;i<row;i++){
  299.         va_list arg_ptr;
  300.         va_start(arg_ptr,fmt);
  301.         vsnprintf(buff, line_size,fmt+i*line_size,arg_ptr);//数据转换
  302.         size=strlen(buff);                                        //得出数据长度
  303.         if(strlen(buff)>line_size)size=line_size;                        //如果长度大于最大值，则长度等于最大值（多出部分忽略）
  304.         OLED_printf_US(xpos,ypos+i*row_size,(uint8_t *)buff,size);//最终调用OLED专用的printf函数来显示
  305.         va_end(arg_ptr);
  306.     }
  307. }

  309. void OLED_WritePixel(uint16_t Xpos, uint16_t Ypos, uint16_t data)
  310. {
  311.           uint8_t dataB = 0;

  313.           /* Set Cursor */
  314.           OLED_SetCursor(Xpos, Ypos);

  316.           /* Prepare to write to LCD RAM */
  317.           OLED_WriteReg(0x2C, (uint8_t*)NULL, 0);   /* RAM write data command */

  319.           /* Write RAM data */
  320.           dataB = (uint8_t)(data >> 8);
  321.           LcdWriteData(dataB);
  322.           dataB = (uint8_t)data;
  323.           LcdWriteData(dataB);
  324. }

  326. uint8_t endian_buffer[480];

  328. void OLED_WriteLine(uint16_t Xpos, uint16_t Ypos, uint16_t *RGBCode, uint16_t pointNum)
  329. {
  330.           /* Set Cursor */
  331.           OLED_SetCursor(Xpos, Ypos);

  333.           /* Prepare to write to LCD RAM */
  334.           OLED_WriteReg(0x2C, (uint8_t*)NULL, 0);   /* RAM write data command */

  336.           for (uint16_t i = 0; i < pointNum; i++) {
  337.             endian_buffer[2*i] = (uint8_t)(RGBCode[i] >> 8);
  338.             endian_buffer[2*i + 1] = (uint8_t)RGBCode[i];
  339.           }

  341.           /* Write RAM data */
  342.           LcdWriteDataMultiple(endian_buffer, pointNum*2);
  343. }

  345. /********************************************************************
  346. *
  347. *   LcdWriteReg
  348. *
  349. *         Function description:
  350. *   Sets display register
  351. */
  352. void LcdWriteReg(uint8_t Data)
  353. {
  354.           Data_Cmd_State(0);
  355.           HAL_SPI_Transmit(&hspi1, &Data, 1, 10);
  356. }

  358. /********************************************************************
  359. *
  360. *          LcdWriteData
  361. *
  362. *         Function description:
  363. *   Writes a value to a display register
  364. */
  365. void LcdWriteData(uint8_t Data)
  366. {
  367.           Data_Cmd_State(1);
  368.           HAL_SPI_Transmit(&hspi1, &Data, 1, 10);
  369. }

  371. /********************************************************************
  372. *
  373. *        LcdWriteDataMultiple
  374. *
  375. *         Function description:
  376. *   Writes multiple values to a display register.
  377. */
  378. void LcdWriteDataMultiple(uint8_t * pData, uint32_t NumItems)
  379. {
  380.           Data_Cmd_State(1);
  381.           HAL_SPI_Transmit(&hspi1, pData, NumItems, 10);
  382. }
复制代码

ASCII.h源码前文已给出，mian.c部分源码：
  1. /* USER CODE END Header */
  2. /* Includes ------------------------------------------------------------------*/
  3. #include "main.h"
  4. #include "dcmi.h"
  5. #include "dma.h"
  6. #include "i2c.h"
  7. #include "usart.h"
  8. #include "spi.h"
  9. #include "gpio.h"

  11. /* Private includes ----------------------------------------------------------*/
  12. /* USER CODE BEGIN Includes */
  13. #include "../../ICore/key/key.h"
  14. #include "../../ICore/led/led.h"
  15. #include "../../ICore/print/print.h"
  16. #include "../../ICore/usart/usart.h"
  17. #include "../../ICore/oled/oled.h"
  18. /* USER CODE END Includes */

  20. /* Private typedef -----------------------------------------------------------*/
  21. /* USER CODE BEGIN PTD */

  23. /* USER CODE END PTD */

  25. /* Private define ------------------------------------------------------------*/
  26. /* USER CODE BEGIN PD */
  27. /* USER CODE END PD */

  29. /* Private macro -------------------------------------------------------------*/
  30. /* USER CODE BEGIN PM */

  32. /* USER CODE END PM */

  34. /* Private variables ---------------------------------------------------------*/

  36. /* USER CODE BEGIN PV */

  38. /* USER CODE END PV */

  40. /* Private function prototypes -----------------------------------------------*/
  41. void SystemClock_Config(void);
  42. /* USER CODE BEGIN PFP */

  44. /* USER CODE END PFP */

  46. /* Private user code ---------------------------------------------------------*/
  47. /* USER CODE BEGIN 0 */
  48. //volatile uint8_t data1[LCD_RAM_SIZE];
  49. //volatile uint8_t data2[LCD_RAM_SIZE];
  50. //extern volatile uint8_t one_frame_done;
  51. /* USER CODE END 0 */

  53. /**
  54.   * @brief  The application entry point.
  55.   * @retval int
  56.   */
  57. int main(void)
  58. {
  59.   /* USER CODE BEGIN 1 */

  61.   /* USER CODE END 1 */

  63.   /* MCU Configuration--------------------------------------------------------*/

  65.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  66.   HAL_Init();

  68.   /* USER CODE BEGIN Init */

  70.   /* USER CODE END Init */

  72.   /* Configure the system clock */
  73.   SystemClock_Config();

  75.   /* USER CODE BEGIN SysInit */

  77.   /* USER CODE END SysInit */

  79.   /* Initialize all configured peripherals */
  80.   MX_GPIO_Init();
  81.   MX_DMA_Init();
  82.   MX_LPUART1_UART_Init();
  83.   MX_SPI1_Init();
  84.   /* USER CODE BEGIN 2 */
  85.   ResetPrintInit(&hlpuart1);
  86.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
  87.   HLPUSART_RX_STA = 0;
  88.   OLED_init();
  89.   //
  90.   set_led0_val(0);
  91.   set_led1_val(get_key0_val());
  92.   /* USER CODE END 2 */

  94.   /* Infinite loop */
  95.   /* USER CODE BEGIN WHILE */
  96.   while (1)
  97.   {
  98.           if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
  99.                   OLED_printf(10,10,"%.*s",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
  100.                   HLPUSART_RX_STA=0;//接收错误,重新开始
  101.                   HAL_Delay(100);//等待
  102.           }
  103.           if(KEY_0())
  104.           {
  105.                   OLED_printf(10,10,"hello world to stm32!I am an embedded enthusiast.");
  106.                   OLED_printf(10,48,"  STM32CubeIDE is an advanced C/C++ development platform "
  107.                                   "with peripheral configuration, code generation, code compilation, "
  108.                                   "and debug features for STM32 micro controllers and microprocessors.");
  109. //                  OLED_printf(10,10,"!");
  110.           }
  111.           if(KEY_1())
  112.           {
  113.                   BSP_LCD_Clear(0xF800);
  114.                   printf("OLED_Clear\r\n");
  115.           }
  116.           if(KEY_2())
  117.           {
  118.                   BSP_LCD_Clear_DMA(LCD_DISP_BLUE);
  119.                   printf("OLED_Clear_DMA\r\n");
  120.           }
  121.         Toggle_led0();
  122.     /* USER CODE END WHILE */

  124.     /* USER CODE BEGIN 3 */
  125.   }
  126.   /* USER CODE END 3 */
  127. }
复制代码

————————————————
版权声明：py_free-物联智能
如有侵权请联系删除





赞 收藏 评论0 发布时间：2023-4-7 15:18

举报

0个回答

所属标签

相似分享

官网相关资源

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
st-img 微信公众号
st-img 手机版