21ic电子技术开发论坛 › 单片机与嵌入式系统 › 芯源CW32 MCU › 【CW32F030CxTx StartKit测评】4.软件模拟SPI驱动OLED ...
返回列表 发新帖我要提问

[CW32F030系列] 【CW32F030CxTx StartKit测评】4.软件模拟SPI驱动OLED

[复制链接]
2198|12
 楼主| zhouminjie 发表于 2022-8-8 00:37 | 显示全部楼层 |阅读模式
模拟SPI

SPI是一种高速、全双工、同步串行总线，SPI与I2C对比：

    SPI是全双工，I2C是半双工

    SPI只能有一个主机，I2C支持多主机多从机

    I2C占用更少的GPIO，更节省资源
    SPI的数据位宽更灵活，可以根据需要选择多位数数据宽度
    SPI协议没有响应机制，主机无法得知从机是否接收到所发的数据，需采用一些方法来防止数据丢帧
    SPI协议可以做到非常高的速率，每一个SCLK都可以进行数据的传输，通过引入CRC等校验方法，可以即高速传输数据，又能保持数据的准确度
    I2C通过器件地址来选择从机，从机数量的增加不会导致GPIO的增加，而SPI通过CS片选信号选择从机，每增加一个从机就要多占用一个GPIO；也可以通过加入译码器来实现多从机控制
    SPI、I2C都应用于板内器件短距离通讯

SPI总线详解可参考： SPI Block Guide V04.01.pdf (428.89 KB, 下载次数: 2)

此篇主要介绍GPIO软件模拟实现SPI来驱动0.96寸OLED显示屏

硬件连接

GND ——  GND

VCC ——  3.3V

DO  ——  PA5
DI  ——  PA7
RES ——  PB1
DC  ——  PB0
CS  ——  PA4

软件代码

SPI代码：

复制
  1. //SPI初始化
    

  2. void SPI_Initial(void)
    

  3. {
    

  4.     GPIO_InitTypeDef GPIO_InitStructure;
    


  5. 

  6.     //根据GPIO组初始化GPIO时钟
    

  7.     RCC_AHBPeriphClk_Enable( RCC_SPI_CS | RCC_SPI_SCK | RCC_SPI_MOSI | RCC_SPI_MISO, ENABLE);
    


  8. 

  9.     //GPIO_CS初始化设置
    

  10.     GPIO_InitStructure.Pins = PIN_SPI_CS;
    

  11.     GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
    

  12.     GPIO_InitStructure.IT = GPIO_IT_NONE;
    

  13.     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
    

  14.     GPIO_Init(PORT_SPI_CS, &GPIO_InitStructure);
    

  15.     //GPIO_SCK初始化设置
    

  16.     GPIO_InitStructure.Pins = PIN_SPI_SCK;
    

  17.     GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
    

  18.     GPIO_InitStructure.IT = GPIO_IT_NONE;
    

  19.     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
    

  20.     GPIO_Init(PORT_SPI_SCK, &GPIO_InitStructure);
    

  21.     //GPIO_MISO初始化设置
    

  22.     GPIO_InitStructure.Pins = PIN_SPI_MISO;
    

  23.     GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
    

  24.     GPIO_InitStructure.IT = GPIO_IT_NONE;
    

  25.     GPIO_InitStructure.Mode = GPIO_MODE_INPUT_PULLUP;
    

  26.     GPIO_Init(PORT_SPI_MISO, &GPIO_InitStructure);
    

  27.     //GPIO_MOSI初始化设置
    

  28.     GPIO_InitStructure.Pins = PIN_SPI_MOSI;
    

  29.     GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
    

  30.     GPIO_InitStructure.IT = GPIO_IT_NONE;
    

  31.     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
    

  32.     GPIO_Init(PORT_SPI_MOSI, &GPIO_InitStructure);
    


  33. 

  34.     SPI_CS_DISABLE;
    

  35.     SPI_SCK_HIGH;
    

  36.     SPI_MOSI_HIGH;
    


  37. 

  38. }
    


  39. 


  40. 

  41. //SPI写一字节数据,TxData --- 发送的字节数据
    

  42. void SPI_WriteByte(unsigned char TxData)
    

  43. {
    

  44.     unsigned char cnt;
    


  45. 

  46.     for(cnt = 0; cnt < 8; cnt++)
    

  47.     {
    

  48.         SPI_SCK_LOW;                                 //时钟 - 低
    

  49.         Delay_Us(1);
    


  50. 

  51.         if(TxData & 0x80)                            //发送数据
    

  52.             SPI_MOSI_HIGH;
    

  53.         else
    

  54.             SPI_MOSI_LOW;
    


  55. 

  56.         TxData <<= 1;
    


  57. 

  58.         Delay_Us(1);
    

  59.         SPI_SCK_HIGH;                                //时钟 - 高
    

  60.         Delay_Us(1);
    

  61.     }
    

  62. }
    


  63. 


  64. 

  65. //SPI读一字节数据,读回来的字节数据
    

  66. unsigned char SPI_ReadByte(void)
    

  67. {
    

  68.     unsigned char cnt;
    

  69.     unsigned char RxData = 0;
    


  70. 

  71.     for(cnt = 0; cnt < 8; cnt++)
    

  72.     {
    

  73.         SPI_SCK_LOW;                                 //时钟 - 低
    

  74.         Delay_Us(1);
    


  75. 

  76.         RxData <<= 1;
    


  77. 

  78.         if(SPI_MISO_READ)                            //读取数据
    

  79.         {
    

  80.             RxData |= 0x01;
    

  81.         }
    


  82. 

  83.         SPI_SCK_HIGH;                                //时钟 - 高
    

  84.         Delay_Us(1);
    

  85.     }
    


  86. 

  87.     return RxData;
    

  88. }

OLED代码：

复制
  1. //向设备写控制命令
    

  2. static void OLED_Write_CMD(unsigned char cmd)
    

  3. {
    

  4.     #ifdef HW_I2C
    

  5.     unsigned char tx_buf[BUF_SIZE] = {0x00, cmd};
    

  6.     I2C_MasterSendDataToSlave(CW_I2C2, tx_buf, BUF_SIZE);
    

  7.     #endif
    

  8.     #ifdef SW_I2C
    

  9.     I2C_Start();
    

  10.     I2C_Send_Byte(0x78);
    

  11.     I2C_Wait_Ack();
    

  12.     I2C_Send_Byte(0x00);
    

  13.     I2C_Wait_Ack();
    

  14.     I2C_Send_Byte(cmd);
    

  15.     I2C_Wait_Ack();
    

  16.     I2C_Stop();
    

  17.     #endif
    

  18.     #ifdef HW_SPI
    

  19.     OLED_CS_LOW;
    

  20.     OLED_DC_LOW;
    


  21. 

  22.     while (SPI_GetFlagStatus(SPI_MASTER, SPI_FLAG_TXE) == RESET);
    


  23. 

  24.     SPI_SendData(SPI_MASTER, cmd);
    


  25. 

  26.     while (SPI_GetFlagStatus(SPI_MASTER, SPI_FLAG_RXNE) == RESET);
    


  27. 

  28.     SPI_ReceiveData(SPI_MASTER);
    

  29.     OLED_CS_HIGH;
    

  30.     #endif
    

  31.     #ifdef SW_SPI
    

  32.     OLED_CS_LOW;
    

  33.     OLED_DC_LOW;
    

  34.     SPI_WriteByte(cmd);
    

  35.     OLED_CS_HIGH;
    

  36.     #endif
    

  37. }
    


  38. 

  39. //向设备写数据
    

  40. static void OLED_Write_Date(unsigned char date)
    

  41. {
    

  42.     #ifdef HW_I2C
    

  43.     unsigned char tx_buf[BUF_SIZE] = {0x40, date};
    

  44.     I2C_MasterSendDataToSlave(CW_I2C2, tx_buf, BUF_SIZE);
    

  45.     #endif
    

  46.     #ifdef SW_I2C
    

  47.     I2C_Start();
    

  48.     I2C_Send_Byte(0x78);
    

  49.     I2C_Wait_Ack();
    

  50.     I2C_Send_Byte(0x40);
    

  51.     I2C_Wait_Ack();
    

  52.     I2C_Send_Byte(date);
    

  53.     I2C_Wait_Ack();
    

  54.     I2C_Stop();
    

  55.     #endif
    

  56.     #ifdef HW_SPI
    

  57.     OLED_CS_LOW;
    

  58.     OLED_DC_HIGH;
    


  59. 

  60.     while (SPI_GetFlagStatus(SPI_MASTER, SPI_FLAG_TXE) == RESET);
    


  61. 

  62.     SPI_SendData(SPI_MASTER, date);
    


  63. 

  64.     while (SPI_GetFlagStatus(SPI_MASTER, SPI_FLAG_RXNE) == RESET);
    


  65. 

  66.     SPI_ReceiveData(SPI_MASTER);
    

  67.     OLED_CS_HIGH;
    

  68.     #endif
    

  69.     #ifdef SW_SPI
    

  70.     OLED_CS_LOW;
    

  71.     OLED_DC_HIGH;
    

  72.     SPI_WriteByte(date);
    

  73.     OLED_CS_HIGH;
    

  74.     #endif
    

  75. }
    


  76. 

  77. //坐标设置
    

  78. static void OLED_Set_Pos(unsigned char x, unsigned char y)
    

  79. {
    

  80.     OLED_Write_CMD(0xB0 + y);
    

  81.     OLED_Write_CMD(((x & 0xF0) >> 4) | 0x10);
    

  82.     OLED_Write_CMD(x & 0x0F);
    

  83. }
    


  84. 

  85. //开启OLED显示
    

  86. static void OLED_Display_On(void)
    

  87. {
    

  88.     OLED_Write_CMD(0x8D); //SET DCDC命令
    

  89.     OLED_Write_CMD(0x14); //DCDC ON
    

  90.     OLED_Write_CMD(0xAF); //DISPLAY ON
    

  91. }
    


  92. 

  93. //关闭OLED显示
    

  94. static void OLED_Display_Off(void)
    

  95. {
    

  96.     OLED_Write_CMD(0x8D); //SET DCDC命令
    

  97.     OLED_Write_CMD(0x10); //DCDC OFF
    

  98.     OLED_Write_CMD(0xAE); //DISPLAY OFF
    

  99. }
    


  100. 

  101. //OLED清屏
    

  102. void OLED_Clear(void)
    

  103. {
    

  104.     unsigned char cnt, count;
    


  105. 

  106.     for(cnt = 0; cnt < 8; cnt++)
    

  107.     {
    

  108.         OLED_Write_CMD(0xB0 + cnt);
    

  109.         OLED_Write_CMD(0x00);
    

  110.         OLED_Write_CMD(0x10);
    


  111. 

  112.         for(count = 0; count < 128; count++)
    

  113.         {
    

  114.             OLED_Write_Date(0x00);
    

  115.         }
    

  116.     }
    

  117. }
    


  118. 

  119. //OLED清行
    

  120. void OLED_Clear_Row(unsigned char n)
    

  121. {
    

  122.     unsigned char count;
    


  123. 

  124.     OLED_Write_CMD(0xB0 + n);
    

  125.     OLED_Write_CMD(0x00);
    

  126.     OLED_Write_CMD(0x10);
    


  127. 

  128.     for(count = 0; count < 128; count++)
    

  129.     {
    

  130.         OLED_Write_Date(0x00);
    

  131.     }
    

  132. }
    


  133. 

  134. //OLED填满屏幕
    

  135. void OLED_Fill(void)
    

  136. {
    

  137.     unsigned char cnt, count;
    


  138. 

  139.     for(cnt = 0; cnt < 8; cnt++)
    

  140.     {
    

  141.         OLED_Write_CMD(0xB0 + cnt); //设置页地址（0~7）
    

  142.         OLED_Write_CMD(0x00); //设置显示位置—列低地址
    

  143.         OLED_Write_CMD(0x10); //设置显示位置—列高地址
    


  144. 

  145.         for(count = 0; count < 128; count++)
    

  146.         {
    

  147.             OLED_Write_Date(0x01);
    

  148.         }
    

  149.     }
    

  150. }
    


  151. 

  152. //指定位置显示一个字符
    

  153. //x:0~127
    

  154. //y:0~63
    

  155. //chr:字符
    

  156. //mode:0,反白显示;1,正常显示
    

  157. //size:选择字体 16/12
    

  158. void OLED_ShowChar(unsigned char x, unsigned char y, unsigned char chr, unsigned char size)
    

  159. {
    

  160.     unsigned char offset = 0, cnt = 0;
    


  161. 

  162.     offset = chr - ' '; //计算偏移量
    


  163. 

  164.     if(x > 128 - 1)
    

  165.     {
    

  166.         x = 0;
    

  167.         y = y + 2;
    

  168.     }
    


  169. 

  170.     if(size == 16)
    

  171.     {
    

  172.         OLED_Set_Pos(x, y);
    


  173. 

  174.         for(cnt = 0; cnt < 8; cnt++)
    

  175.         {
    

  176.             OLED_Write_Date(F8x16[offset * 16 + cnt]);
    

  177.         }
    


  178. 

  179.         OLED_Set_Pos(x, y + 1);
    


  180. 

  181.         for(cnt = 0; cnt < 8; cnt++)
    

  182.         {
    

  183.             OLED_Write_Date(F8x16[offset * 16 + cnt + 8]);
    

  184.         }
    

  185.     }
    

  186.     else
    

  187.     {
    

  188.         OLED_Set_Pos(x, y);
    


  189. 

  190.         for(cnt = 0; cnt < 6; cnt++)
    

  191.         {
    

  192.             OLED_Write_Date(F6x8[offset][cnt]);
    

  193.         }
    

  194.     }
    

  195. }
    


  196. 

  197. unsigned int oled_pow(unsigned char m, unsigned char n)
    

  198. {
    

  199.     unsigned int result = 1;
    


  200. 

  201.     while(n--)
    

  202.     {
    

  203.         result *= m;
    

  204.     }
    


  205. 

  206.     return result;
    

  207. }
    


  208. 

  209. //指定位置显示一个数字
    

  210. //x,y:起点坐标
    

  211. //num:数值(0~4294967295)
    

  212. //len:数字的位数
    

  213. //size:字体大小
    

  214. //mode:模式        0,填充模式;1,叠加模式
    

  215. void OLED_ShowNum(unsigned char x, unsigned char y, unsigned int num, unsigned char len, unsigned char size)
    

  216. {
    

  217.     unsigned char cnt, temp;
    

  218.     unsigned char show = 0;
    


  219. 

  220.     for(cnt = 0; cnt < len; cnt++)
    

  221.     {
    

  222.         temp = (num / oled_pow(10, len - cnt - 1)) % 10;
    


  223. 

  224.         if(show == 0 && cnt < (len - 1))
    

  225.         {
    

  226.             if(temp == 0)
    

  227.             {
    

  228.                 OLED_ShowChar(x + (size / 2) * cnt, y, ' ', size);
    

  229.                 continue;
    

  230.             }
    

  231.             else
    

  232.             {
    

  233.                 show = 1;
    

  234.             }
    

  235.         }
    


  236. 

  237.         OLED_ShowChar(x + (size / 2) * cnt, y, temp + '0', size);
    

  238.     }
    

  239. }
    


  240. 

  241. //指定位置显示字符串
    

  242. void OLED_ShowString(unsigned char x, unsigned char y, unsigned char *chr, unsigned char size)
    

  243. {
    

  244.     unsigned char cnt = 0;
    


  245. 

  246.     while(chr[cnt] != '\0')
    

  247.     {
    

  248.         OLED_ShowChar(x, y, chr[cnt], size);
    

  249.         x += 8;
    


  250. 

  251.         if(x > 120)
    

  252.         {
    

  253.             x = 0;
    

  254.             y += 2;
    

  255.         }
    


  256. 

  257.         cnt++;
    

  258.     }
    

  259. }
    


  260. 

  261. //显示汉字
    

  262. void OLED_ShowCHinese(unsigned char x, unsigned char y, unsigned char no)
    

  263. {
    

  264.     unsigned char cnt, addr = 0;
    


  265. 

  266.     OLED_Set_Pos(x, y);
    


  267. 

  268.     for(cnt = 0; cnt < 16; cnt++)
    

  269.     {
    

  270.         OLED_Write_Date(Hzk[2 * no][cnt]);
    

  271.         addr++;
    

  272.     }
    


  273. 

  274.     OLED_Set_Pos(x, y + 1);
    


  275. 

  276.     for(cnt = 0; cnt < 16; cnt++)
    

  277.     {
    

  278.         OLED_Write_Date(Hzk[2 * no + 1][cnt]);
    

  279.         addr++;
    

  280.     }
    

  281. }
    


  282. 

  283. //显示图片
    

  284. /*
    

  285.         @brief                        显示图片
    

  286.         @param                        x0：起始列地址
    

  287.                                         y0：起始页地址
    

  288.                                         x1：终止列地址
    

  289.                                         y1：终止页地址
    

  290.                                         BMP[]：存放图片代码的数组
    

  291.         @retval                        无
    

  292.  */
    

  293. void OLED_DrawBMP(unsigned char x0, unsigned char y0, unsigned char x1, unsigned char y1, unsigned char BMP[])
    

  294. {
    

  295.     unsigned int j = 0; //定义变量
    

  296.     unsigned char x, y; //定义变量
    


  297. 

  298.     if(y1 % 8 == 0)
    

  299.     {
    

  300.         y = y1 / 8; //判断终止页是否为8的整数倍
    

  301.     }
    

  302.     else
    

  303.     {
    

  304.         y = y1 / 8 + 1;
    

  305.     }
    


  306. 

  307.     for(y = y0; y < y1; y++) //从起始页开始，画到终止页
    

  308.     {
    

  309.         OLED_Set_Pos(x0, y); //在页的起始列开始画
    


  310. 

  311.         for(x = x0; x < x1; x++) //画x1 - x0 列
    

  312.         {
    

  313.             OLED_Write_Date(BMP[j++]); //画图片的点
    

  314.         }
    

  315.     }
    

  316. }
    


  317. 

  318. //显示动图
    

  319. /*
    

  320.         @brief                        显示动图
    

  321.         @param                        x0：起始列地址
    

  322.                                 y0：起始页地址
    

  323.                                 x1：终止列地址
    

  324.                                 y1：终止页地址
    

  325.                                 k: 帧个数
    

  326.                                 m: 单帧数组大小
    

  327.                                 BMP[][m]：存放动图代码的数组
    

  328.         @retval                        无
    

  329.  */
    

  330. void OLED_DrawGIF(unsigned char x0, unsigned char y0, unsigned char x1, unsigned char y1, unsigned char k, int m, const unsigned char GIF[][m])
    

  331. {
    

  332.     unsigned int j = 0; //定义变量
    

  333.     unsigned char x, y, i; //定义变量
    


  334. 

  335.     if(y1 % 8 == 0)
    

  336.     {
    

  337.         y = y1 / 8; //判断终止页是否为8的整数倍
    

  338.     }
    

  339.     else
    

  340.     {
    

  341.         y = y1 / 8 + 1;
    

  342.     }
    


  343. 

  344.     for (i = 0; i < k; i++) //从第一帧开始画
    

  345.     {
    

  346.         j = 0;
    


  347. 

  348.         for(y = y0; y < y1; y++) //从起始页开始，画到终止页
    

  349.         {
    

  350.             OLED_Set_Pos(x0, y); //在页的起始列开始画
    


  351. 

  352.             for(x = x0; x < x1; x++) //画x1 - x0 列
    

  353.             {
    

  354.                 OLED_Write_Date(GIF[i][j++]); //画图片的点
    

  355.             }
    

  356.         }
    


  357. 

  358.         //Delay_Ms(80);
    

  359.     }
    

  360. }
    


  361. 


  362. 

  363. #if defined SW_SPI || defined HW_SPI
    

  364. //SPI驱动方式DC、RES引脚初始化
    

  365. void OLED_SPI_GPIO_Init(void)
    

  366. {
    

  367.     GPIO_InitTypeDef GPIO_InitStructure;
    


  368. 

  369.     //根据GPIO组初始化GPIO时钟
    

  370.     RCC_AHBPeriphClk_Enable( RCC_OLED_DC | RCC_OLED_RES, ENABLE);
    

  371.     //GPIO_DC初始化设置
    

  372.     GPIO_InitStructure.Pins = PIN_OLED_DC;
    

  373.     GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
    

  374.     GPIO_InitStructure.IT = GPIO_IT_NONE;
    

  375.     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
    

  376.     GPIO_Init(PORT_OLED_DC, &GPIO_InitStructure);
    

  377.     //GPIO_RES初始化设置
    

  378.     GPIO_InitStructure.Pins = PIN_OLED_RES;
    

  379.     GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
    

  380.     GPIO_InitStructure.IT = GPIO_IT_NONE;
    

  381.     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
    

  382.     GPIO_Init(PORT_OLED_RES, &GPIO_InitStructure);
    


  383. 

  384.     OLED_RES_LOW;
    

  385.     Delay_Ms(200);
    

  386.     OLED_RES_HIGH;
    

  387. }
    

  388. #endif
    


  389. 


  390. 

  391. //OLED初始化
    

  392. void OLED_Init(void)
    

  393. {
    

  394.     #ifdef SW_I2C
    

  395.     I2C_Init();
    

  396.     #endif
    

  397.     #ifdef HW_I2C
    

  398.     I2C_Init();
    

  399.     #endif
    

  400.     #ifdef SW_SPI
    

  401.     SPI_Initial();
    

  402.     OLED_SPI_GPIO_Init();
    

  403.     #endif
    

  404.     #ifdef HW_SPI
    

  405.     SPI_Initial();
    

  406.     OLED_SPI_GPIO_Init();
    

  407.     #endif
    

  408.     Delay_Ms(200);
    

  409.     OLED_Write_CMD(0xAE); //display off
    

  410.     OLED_Write_CMD(0x00); //set low column address
    

  411.     OLED_Write_CMD(0x10); //set high column address
    

  412.     OLED_Write_CMD(0x40); //set start line address
    

  413.     OLED_Write_CMD(0xB0); //set page address
    

  414.     OLED_Write_CMD(0x81); //contract control
    

  415.     OLED_Write_CMD(0xFF); //128
    

  416.     OLED_Write_CMD(0xA1); //set segment remap
    

  417.     OLED_Write_CMD(0xA6); //normal / reverse
    

  418.     OLED_Write_CMD(0xA8); //set multiplex ratio(1 to 64)
    

  419.     OLED_Write_CMD(0x3F); //1/32 duty
    

  420.     OLED_Write_CMD(0xC8); //Com scan direction
    

  421.     OLED_Write_CMD(0xD3); //set display offset
    

  422.     OLED_Write_CMD(0x00); //
    

  423.     OLED_Write_CMD(0xD5); //set osc division
    

  424.     OLED_Write_CMD(0x80); //
    

  425.     OLED_Write_CMD(0xD8); //set area color mode off
    

  426.     OLED_Write_CMD(0x05); //
    

  427.     OLED_Write_CMD(0xD9); //Set Pre-Charge Period
    

  428.     OLED_Write_CMD(0xF1); //
    

  429.     OLED_Write_CMD(0xDA); //set com pin configuartion
    

  430.     OLED_Write_CMD(0x12); //
    

  431.     OLED_Write_CMD(0xDB); //set Vcomh
    

  432.     OLED_Write_CMD(0x30); //
    

  433.     OLED_Write_CMD(0x8D); //set charge pump enable
    

  434.     OLED_Write_CMD(0x14); //
    

  435.     OLED_Write_CMD(0xAF); //turn on oled panel
    

  436. }

运行测试

WeChat_20220807224825_ (1).gif

测试代码

CW32F030CxTx_SW_SPI_OLED.zip (261.28 KB, 下载次数: 7)





回复

收藏 举报

相关帖子
duo点 发表于 2022-8-8 09:30 来自手机 | 显示全部楼层
屏幕上的几个图标是啥意思啊
回复

收藏 举报

 楼主| zhouminjie 发表于 2022-8-8 16:39 | 显示全部楼层
duo点 发表于 2022-8-8 09:30
屏幕上的几个图标是啥意思啊

几个车标
回复

收藏 举报

weifeng90 发表于 2022-8-8 21:14 来自手机 | 显示全部楼层
软件模拟效率不高啊
回复

收藏 举报

 楼主| zhouminjie 发表于 2022-8-8 23:36 | 显示全部楼层
weifeng90 发表于 2022-8-8 21:14
软件模拟效率不高啊

速度?
回复

收藏 举报

updownq 发表于 2022-8-16 20:30 | 显示全部楼层
模拟spi可以。  
回复

收藏 举报

hearstnorman323 发表于 2022-8-20 16:25 | 显示全部楼层
有硬件iic或者spi驱动的吗   
回复

收藏 举报

 楼主| zhouminjie 发表于 2022-8-22 23:26 | 显示全部楼层
hearstnorman323 发表于 2022-8-20 16:25
有硬件iic或者spi驱动的吗

有的，硬件SPI https://bbs.21ic.com/icview-3244756-1-1.html；硬件I2C https://bbs.21ic.com/icview-3244752-1-1.html
回复

收藏 举报

wwk1996 发表于 2022-8-23 06:31 来自手机 | 显示全部楼层
OLED的驱动芯片是？
回复

收藏 举报

 楼主| zhouminjie 发表于 2022-8-31 21:04 | 显示全部楼层
wwk1996 发表于 2022-8-23 06:31
OLED的驱动芯片是？

内部芯片是SSD1306
回复

收藏 举报

abotomson 发表于 2022-9-8 09:02 | 显示全部楼层
这个模拟spi的速度快吗   
回复

收藏 举报

bartonalfred 发表于 2022-9-8 15:42 | 显示全部楼层
CW32F030CxTx 价格可以吗   
回复

收藏 举报

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

本版积分规则

zhouminjie

33

主题

140

帖子

3

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