21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › stm32c8t6矩阵控制led亮灯 显示时间在4线oled屏幕 ...
12下一页
返回列表 发新帖我要提问

[其他ST产品] stm32c8t6矩阵控制led亮灯 显示时间在4线oled屏幕

[复制链接]
 楼主| 9dome猫 发表于 2022-8-22 23:17 | 显示全部楼层 |阅读模式
LED屏, ST, STM32C8T6, oled屏幕, stm32c8

直接上代码文章末尾讲解 注文章篇幅较长可能需要点阅读时间

首先是key.h文件

复制
  1.  
    

  2. #define KEY_HANG1 GPIO_Pin_0
    

  3. #define KEY_HANG2 GPIO_Pin_1
    

  4. #define KEY_HANG3 GPIO_Pin_2
    

  5. #define KEY_HANG4 GPIO_Pin_3
    

  6.  
    

  7.  
    

  8. #define KEY1  GPIO_Pin_4 
    

  9. #define KEY2  GPIO_Pin_5
    

  10. #define KEY3  GPIO_Pin_6
    

  11. #define KEY4  GPIO_Pin_7
    

  12.  
    

  13.  
    

  14. #define KEY1_Input  GPIO_ReadInputDataBit(KEY_PROT,KEY1)
    

  15. #define KEY2_Input  GPIO_ReadInputDataBit(KEY_PROT,KEY2)
    

  16. #define KEY3_Input  GPIO_ReadInputDataBit(KEY_PROT,KEY3)
    

  17. #define KEY4_Input  GPIO_ReadInputDataBit(KEY_PROT,KEY4)
    

  18.  
    

  19.  
    

  20. #define KEY_PROT GPIOA
    

  21.  
    

  22.  
    

  23. extern  u8  flag;  
    

  24. u16 *abc_read();
    

  25. int sun1_read();
    

  26.  
    

  27. void KEY_Init(void);//IO初始化
    

  28. void KEY_config(u8 *key);
    

  29. u8 Read_KeyValue(void);
    

  30. void Key_Input( u8 *key1);
    


  31.



回复 赏

举报

评论

9dome猫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/shihuntz/article/details/123933145 ———————————————— 版权声明：本文为CSDN博主「shihuntz」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/shihuntz/article/details/1  发表于 2022-8-22 23:20

相关帖子
 楼主| 9dome猫 发表于 2022-8-22 23:23 | 显示全部楼层
oled.h文件
复制
  1. #ifndef __OLED_H
    

  2. #define __OLED_H 
    

  3.  
    

  4. #include "sys.h"
    

  5. #include "stdlib.h"        
    

  6.  
    

  7. //-----------------OLED端口定义---------------- 
    

  8.  
    

  9.  
    

  10.  
    

  11. #define OLED_SCL_Clr() GPIO_ResetBits(GPIOB,GPIO_Pin_1)//SCL   A 0
    

  12. #define OLED_SCL_Set() GPIO_SetBits(GPIOB,GPIO_Pin_1)
    

  13.  
    

  14. #define OLED_SDA_Clr() GPIO_ResetBits(GPIOB,GPIO_Pin_10)//DIN   A 1
    

  15. #define OLED_SDA_Set() GPIO_SetBits(GPIOB,GPIO_Pin_10)
    

  16.  
    

  17. #define OLED_RES_Clr() GPIO_ResetBits(GPIOB,GPIO_Pin_7)//RES   A 2
    

  18. #define OLED_RES_Set() GPIO_SetBits(GPIOB,GPIO_Pin_7)
    

  19.  
    

  20.  
    

  21. #define OLED_CMD  0        //写命令
    

  22. #define OLED_DATA 1        //写数据
    

  23.  
    

  24.  
    

  25. extern  u8  flag;  
    

  26.  
    

  27. void KEY_Init(void);//IO初始化
    

  28. void KEY_config(u8 *key);
    

  29. u8 Read_KeyValue(void);
    

  30. void Key_Input( u8 *key1);
    

  31.  
    

  32.  
    

  33.  
    

  34.  
    

  35. void OLED_ClearPoint(u8 x,u8 y);
    

  36. void OLED_ColorTurn(u8 i);
    

  37. void OLED_DisplayTurn(u8 i);
    

  38. void I2C_Start(void);
    

  39. void I2C_Stop(void);
    

  40. void I2C_WaitAck(void);
    

  41. void Send_Byte(u8 dat);
    

  42. void OLED_WR_Byte(u8 dat,u8 mode);
    

  43. void OLED_DisPlay_On(void);
    

  44. void OLED_DisPlay_Off(void);
    

  45. void OLED_Refresh(void);
    

  46. void OLED_Clear(void);
    

  47. void OLED_DrawPoint(u8 x,u8 y,u8 t);
    

  48. void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2,u8 mode);
    

  49. void OLED_DrawCircle(u8 x,u8 y,u8 r);
    

  50. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1,u8 mode);
    

  51. void OLED_ShowChar6x8(u8 x,u8 y,u8 chr,u8 mode);
    

  52. void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1,u8 mode);
    

  53. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1,u8 mode);
    

  54. void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1,u8 mode);
    

  55. void OLED_ScrollDisplay(u8 num,u8 space,u8 mode);
    

  56. void OLED_ShowPicture(u8 x,u8 y,u8 sizex,u8 sizey,u8 BMP[],u8 mode);
    

  57. void OLED_Init(void);
    

  58.  
    

  59. #endif
    

  60.  
    


  61.
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:30 | 显示全部楼层
oled.c
复制
  1. #include "oled.h"
    

  2. #include "stdlib.h"
    

  3. #include "oledfont.h"
    

  4. #include "delay.h"
    

  5. #include "stm32f10x.h"
    

  6. #include "usart.h"
    

  7.  
    

  8. u8 OLED_GRAM[144][8];
    

  9.  
    

  10.  
    

  11.  
    

  12. //反显函数
    

  13. void OLED_ColorTurn(u8 i)
    

  14. {
    

  15.         if(i==0)
    

  16.                 {
    

  17.                         OLED_WR_Byte(0xA6,OLED_CMD);//正常显示
    

  18.                 }
    

  19.         if(i==1)
    

  20.                 {
    

  21.                         OLED_WR_Byte(0xA7,OLED_CMD);//反色显示
    

  22.                 }
    

  23. }
    

  24.  
    

  25. //屏幕旋转180度
    

  26. void OLED_DisplayTurn(u8 i)
    

  27. {
    

  28.         if(i==0)
    

  29.                 {
    

  30.                         OLED_WR_Byte(0xC8,OLED_CMD);//正常显示
    

  31.                         OLED_WR_Byte(0xA1,OLED_CMD);
    

  32.                 }
    

  33.         if(i==1)
    

  34.                 {
    

  35.                         OLED_WR_Byte(0xC0,OLED_CMD);//反转显示
    

  36.                         OLED_WR_Byte(0xA0,OLED_CMD);
    

  37.                 }
    

  38. }
    

  39.  
    

  40. //延时
    

  41. void IIC_delay(void)
    

  42. {
    

  43.         u8 t=3;
    

  44.         while(t--);
    

  45. }
    

  46.  
    

  47. //起始信号
    

  48. void I2C_Start(void)
    

  49. {
    

  50.         OLED_SDA_Set();
    

  51.         OLED_SCL_Set();
    

  52.         IIC_delay();
    

  53.         OLED_SDA_Clr();
    

  54.         IIC_delay();
    

  55.         OLED_SCL_Clr();
    

  56.         IIC_delay();
    

  57. }
    

  58.  
    

  59. //结束信号
    

  60. void I2C_Stop(void)
    

  61. {
    

  62.         OLED_SDA_Clr();
    

  63.         OLED_SCL_Set();
    

  64.         IIC_delay();
    

  65.         OLED_SDA_Set();
    

  66. }
    

  67.  
    

  68. //等待信号响应
    

  69. void I2C_WaitAck(void) //测数据信号的电平
    

  70. {
    

  71.         OLED_SDA_Set();
    

  72.         IIC_delay();
    

  73.         OLED_SCL_Set();
    

  74.         IIC_delay();
    

  75.         OLED_SCL_Clr();
    

  76.         IIC_delay();
    

  77. }
    

  78.  
    

  79. //写入一个字节
    

  80. void Send_Byte(u8 dat)
    

  81. {
    

  82.         u8 i;
    

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

  84.         {
    

  85.                 if(dat&0x80)//将dat的8位从最高位依次写入
    

  86.                 {
    

  87.                         OLED_SDA_Set();
    

  88.     }
    

  89.                 else
    

  90.                 {
    

  91.                         OLED_SDA_Clr();
    

  92.     }
    

  93.                 IIC_delay();
    

  94.                 OLED_SCL_Set();
    

  95.                 IIC_delay();
    

  96.                 OLED_SCL_Clr();//将时钟信号设置为低电平
    

  97.                 dat<<=1;
    

  98.   }
    

  99. }
    

  100.  
    

  101. //发送一个字节
    

  102. //mode:数据/命令标志 0,表示命令;1,表示数据;
    

  103. void OLED_WR_Byte(u8 dat,u8 mode)
    

  104. {
    

  105.         I2C_Start();
    

  106.         Send_Byte(0x78);
    

  107.         I2C_WaitAck();
    

  108.         if(mode){Send_Byte(0x40);}
    

  109.   else{Send_Byte(0x00);}
    

  110.         I2C_WaitAck();
    

  111.         Send_Byte(dat);
    

  112.         I2C_WaitAck();
    

  113.         I2C_Stop();
    

  114. }
    

  115.  
    

  116. //开启OLED显示 
    

  117. void OLED_DisPlay_On(void)
    

  118. {
    

  119.         OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
    

  120.         OLED_WR_Byte(0x14,OLED_CMD);//开启电荷泵
    

  121.         OLED_WR_Byte(0xAF,OLED_CMD);//点亮屏幕
    

  122. }
    

  123.  
    

  124. //关闭OLED显示 
    

  125. void OLED_DisPlay_Off(void)
    

  126. {
    

  127.         OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
    

  128.         OLED_WR_Byte(0x10,OLED_CMD);//关闭电荷泵
    

  129.         OLED_WR_Byte(0xAE,OLED_CMD);//关闭屏幕
    

  130. }
    

  131.  
    

  132. //更新显存到OLED        
    

  133. void OLED_Refresh(void)
    

  134. {
    

  135.         u8 i,n;
    

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

  137.         {
    

  138.                 OLED_WR_Byte(0xb0+i,OLED_CMD); //设置行起始地址
    

  139.                 OLED_WR_Byte(0x00,OLED_CMD);   //设置低列起始地址
    

  140.                 OLED_WR_Byte(0x10,OLED_CMD);   //设置高列起始地址
    

  141.                 I2C_Start();
    

  142.                 Send_Byte(0x78);
    

  143.                 I2C_WaitAck();
    

  144.                 Send_Byte(0x40);
    

  145.                 I2C_WaitAck();
    

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

  147.                 {
    

  148.                         Send_Byte(OLED_GRAM[n][i]);
    

  149.                         I2C_WaitAck();
    

  150.                 }
    

  151.                 I2C_Stop();
    

  152.   }
    

  153. }
    

  154.  
    

  155. //清屏函数
    

  156. void OLED_Clear(void)
    

  157. {
    

  158.         u8 i,n;
    

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

  160.         {
    

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

  162.                         {
    

  163.                          OLED_GRAM[n][i]=0;//清除所有数据
    

  164.                         }
    

  165.   }
    

  166.         //OLED_Refresh();//更新显示
    

  167. }
    

  168.  
    

  169. //画点 
    

  170. //x:0~127
    

  171. //y:0~63
    

  172. //t:1 填充 0,清空        
    

  173. void OLED_DrawPoint(u8 x,u8 y,u8 t)
    

  174. {
    

  175.         u8 i,m,n;
    

  176.         i=y/8;
    

  177.         m=y%8;
    

  178.         n=1<<m;
    

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

  180.         else
    

  181.         {
    

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

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

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

  185.         }
    

  186. }
    

  187.  
    

  188. //画线
    

  189. //x1,y1:起点坐标
    

  190. //x2,y2:结束坐标
    

  191. void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2,u8 mode)
    

  192. {
    

  193.         u16 t; 
    

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

  195.         int incx,incy,uRow,uCol;
    

  196.         delta_x=x2-x1; //计算坐标增量 
    

  197.         delta_y=y2-y1;
    

  198.         uRow=x1;//画线起点坐标
    

  199.         uCol=y1;
    

  200.         if(delta_x>0)incx=1; //设置单步方向 
    

  201.         else if (delta_x==0)incx=0;//垂直线 
    

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

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

  204.         else if (delta_y==0)incy=0;//水平线 
    

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

  206.         if(delta_x>delta_y)distance=delta_x; //选取基本增量坐标轴 
    

  207.         else distance=delta_y;
    

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

  209.         {
    

  210.                 OLED_DrawPoint(uRow,uCol,mode);//画点
    

  211.                 xerr+=delta_x;
    

  212.                 yerr+=delta_y;
    

  213.                 if(xerr>distance)
    

  214.                 {
    

  215.                         xerr-=distance;
    

  216.                         uRow+=incx;
    

  217.                 }
    

  218.                 if(yerr>distance)
    

  219.                 {
    

  220.                         yerr-=distance;
    

  221.                         uCol+=incy;
    

  222.                 }
    

  223.         }
    

  224. }
    

  225. //x,y:圆心坐标
    

  226. //r:圆的半径
    

  227. void OLED_DrawCircle(u8 x,u8 y,u8 r)
    

  228. {
    

  229.         int a, b,num;
    

  230.     a = 0;
    

  231.     b = r;
    

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

  233.     {
    

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

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

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

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

  238.  
    

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

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

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

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

  243.         
    

  244.         a++;
    

  245.         num = (a * a + b * b) - r*r;//计算画的点离圆心的距离
    

  246.         if(num > 0)
    

  247.         {
    

  248.             b--;
    

  249.             a--;
    

  250.         }
    

  251.     }
    

  252. }
    

  253.  
    

  254.  
    

  255.  
    

  256. //在指定位置显示一个字符,包括部分字符
    

  257. //x:0~127
    

  258. //y:0~63
    

  259. //size1:选择字体 6x8/6x12/8x16/12x24
    

  260. //mode:0,反色显示;1,正常显示
    

  261. void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1,u8 mode)
    

  262. {
    

  263.         u8 i,m,temp,size2,chr1;
    

  264.         u8 x0=x,y0=y;
    

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

  266.         else size2=(size1/8+((size1%8)?1:0))*(size1/2);  //得到字体一个字符对应点阵集所占的字节数
    

  267.         chr1=chr-' ';  //计算偏移后的值
    

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

  269.         {
    

  270.                 if(size1==8)
    

  271.                           {temp=asc2_0806[chr1][i];} //调用0806字体
    

  272.                 else if(size1==12)
    

  273.         {temp=asc2_1206[chr1][i];} //调用1206字体
    

  274.                 else if(size1==16)
    

  275.         {temp=asc2_1608[chr1][i];} //调用1608字体
    

  276.                 else if(size1==24)
    

  277.         {temp=asc2_2412[chr1][i];} //调用2412字体
    

  278.                 else return;
    

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

  280.                 {
    

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

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

  283.                         temp>>=1;
    

  284.                         y++;
    

  285.                 }
    

  286.                 x++;
    

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

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

  289.                 y=y0;
    

  290.   }
    

  291. }
    

  292.  
    

  293.  
    

  294. //显示字符串
    

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

  296. //size1:字体大小 
    

  297. //*chr:字符串起始地址 
    

  298. //mode:0,反色显示;1,正常显示
    

  299. void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1,u8 mode)
    

  300. {
    

  301.         while((*chr>=' ')&&(*chr<='~'))//判断是不是非法字符!
    

  302.         {
    

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

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

  305.                 else x+=size1/2;
    

  306.                 chr++;
    

  307.   }
    

  308. }
    

  309.  
    

  310. //m^n
    

  311. u32 OLED_Pow(u8 m,u8 n)
    

  312. {
    

  313.         u32 result=1;
    

  314.         while(n--)
    

  315.         {
    

  316.           result*=m;
    

  317.         }
    

  318.         return result;
    

  319. }
    

  320.  
    

  321.  
    

  322. //显示数字
    

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

  324. //num :要显示的数字
    

  325. //len :数字的位数
    

  326. //size:字体大小
    

  327. //mode:0,反色显示;1,正常显示
    

  328. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1,u8 mode)
    

  329. {
    

  330.         u8 t,temp,m=0;
    

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

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

  333.         {
    

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

  335.                         if(temp==0)
    

  336.                         {
    

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

  338.       }
    

  339.                         else 
    

  340.                         {
    

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

  342.                         }
    

  343.   }
    

  344. }
    

  345.  
    

  346.  
    

  347. //显示汉字
    

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

  349. //num:汉字对应的序号
    

  350. //mode:0,反色显示;1,正常显示
    

  351. void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1,u8 mode)
    

  352. {
    

  353.         u8 m,temp;
    

  354.         u8 x0=x,y0=y;
    

  355.         u16 i,size3=(size1/8+((size1%8)?1:0))*size1;  //得到字体一个字符对应点阵集所占的字节数
    

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

  357.         {
    

  358.                 if(size1==16)
    

  359.                                 {temp=Hzk1[num][i];}//调用16*16字体
    

  360.                 else if(size1==24)
    

  361.                                 {temp=Hzk2[num][i];}//调用24*24字体
    

  362.                 else if(size1==32)       
    

  363.                                 {temp=Hzk3[num][i];}//调用32*32字体
    

  364.                 else if(size1==64)
    

  365.                                 {temp=Hzk4[num][i];}//调用64*64字体
    

  366.                 else return;
    

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

  368.                 {
    

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

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

  371.                         temp>>=1;
    

  372.                         y++;
    

  373.                 }
    

  374.                 x++;
    

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

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

  377.                 y=y0;
    

  378.         }
    

  379. }
    

  380.  
    

  381. //num 显示汉字的个数
    

  382. //space 每一遍显示的间隔
    

  383. //mode:0,反色显示;1,正常显示
    

  384. void OLED_ScrollDisplay(u8 num,u8 space,u8 mode)
    

  385. {
    

  386.         u8 i,n,t=0,m=0,r;
    

  387.         while(1)
    

  388.         {
    

  389.                 if(m==0)
    

  390.                 {
    

  391.             OLED_ShowChinese(128,24,t,16,mode); //写入一个汉字保存在OLED_GRAM[][]数组中
    

  392.                         t++;
    

  393.                 }
    

  394.                 if(t==num)
    

  395.                         {
    

  396.                                 for(r=0;r<16*space;r++)      //显示间隔
    

  397.                                  {
    

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

  399.                                                 {
    

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

  401.                                                         {
    

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

  403.                                                         }
    

  404.                                                 }
    

  405.            OLED_Refresh();
    

  406.                                  }
    

  407.         t=0;
    

  408.       }
    

  409.                 m++;
    

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

  411.                 for(i=1;i<144;i++)   //实现左移
    

  412.                 {
    

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

  414.                         {
    

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

  416.                         }
    

  417.                 }
    

  418.                 OLED_Refresh();
    

  419.         }
    

  420. }
    

  421.  
    

  422. //x,y：起点坐标
    

  423. //sizex,sizey,图片长宽
    

  424. //BMP[]：要写入的图片数组
    

  425. //mode:0,反色显示;1,正常显示
    

  426. void OLED_ShowPicture(u8 x,u8 y,u8 sizex,u8 sizey,u8 BMP[],u8 mode)
    

  427. {
    

  428.         u16 j=0;
    

  429.         u8 i,n,temp,m;
    

  430.         u8 x0=x,y0=y;
    

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

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

  433.         {
    

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

  435.                  {
    

  436.                                 temp=BMP[j];
    

  437.                                 j++;
    

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

  439.                                 {
    

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

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

  442.                                         temp>>=1;
    

  443.                                         y++;
    

  444.                                 }
    

  445.                                 x++;
    

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

  447.                                 {
    

  448.                                         x=x0;
    

  449.                                         y0=y0+8;
    

  450.                                 }
    

  451.                                 y=y0;
    

  452.      }
    

  453.          }
    

  454. }
    

  455.  
    

  456.  
    

  457. //OLED的初始化
    

  458. void OLED_Init(void)
    

  459. {
    

  460.         GPIO_InitTypeDef  GPIO_InitStructure;
    

  461.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);         //使能A端口时钟
    

  462.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10|GPIO_Pin_1;         
    

  463.          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;                 //开漏输出
    

  464.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//速度50MHz
    

  465.          GPIO_Init(GPIOB, &GPIO_InitStructure);          //初始化PA0,1
    

  466.          GPIO_SetBits(GPIOB,GPIO_Pin_10|GPIO_Pin_1);
    

  467.  
    

  468.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;         
    

  469.          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出              
    

  470.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//速度50MHz                      
    

  471.          GPIO_Init(GPIOB, &GPIO_InitStructure);          //初始化PA2                   
    

  472.          GPIO_SetBits(GPIOB,GPIO_Pin_7);
    

  473.         
    

  474.         OLED_RES_Clr();
    

  475.         delay_ms(200);
    

  476.         OLED_RES_Set();
    

  477.         
    

  478.         OLED_WR_Byte(0xAE,OLED_CMD);//--turn off oled panel
    

  479.         OLED_WR_Byte(0x00,OLED_CMD);//---set low column address
    

  480.         OLED_WR_Byte(0x10,OLED_CMD);//---set high column address
    

  481.         OLED_WR_Byte(0x40,OLED_CMD);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
    

  482.         OLED_WR_Byte(0x81,OLED_CMD);//--set contrast control register
    

  483.         OLED_WR_Byte(0xCF,OLED_CMD);// Set SEG Output Current Brightness
    

  484.         OLED_WR_Byte(0xA1,OLED_CMD);//--Set SEG/Column Mapping     0xa0左右反置 0xa1正常
    

  485.         OLED_WR_Byte(0xC8,OLED_CMD);//Set COM/Row Scan Direction   0xc0上下反置 0xc8正常
    

  486.         OLED_WR_Byte(0xA6,OLED_CMD);//--set normal display
    

  487.         OLED_WR_Byte(0xA8,OLED_CMD);//--set multiplex ratio(1 to 64)
    

  488.         OLED_WR_Byte(0x3f,OLED_CMD);//--1/64 duty
    

  489.         OLED_WR_Byte(0xD3,OLED_CMD);//-set display offset        Shift Mapping RAM Counter (0x00~0x3F)
    

  490.         OLED_WR_Byte(0x00,OLED_CMD);//-not offset
    

  491.         OLED_WR_Byte(0xd5,OLED_CMD);//--set display clock divide ratio/oscillator frequency
    

  492.         OLED_WR_Byte(0x80,OLED_CMD);//--set divide ratio, Set Clock as 100 Frames/Sec
    

  493.         OLED_WR_Byte(0xD9,OLED_CMD);//--set pre-charge period
    

  494.         OLED_WR_Byte(0xF1,OLED_CMD);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
    

  495.         OLED_WR_Byte(0xDA,OLED_CMD);//--set com pins hardware configuration
    

  496.         OLED_WR_Byte(0x12,OLED_CMD);
    

  497.         OLED_WR_Byte(0xDB,OLED_CMD);//--set vcomh
    

  498.         OLED_WR_Byte(0x30,OLED_CMD);//Set VCOM Deselect Level
    

  499.         OLED_WR_Byte(0x20,OLED_CMD);//-Set Page Addressing Mode (0x00/0x01/0x02)
    

  500.         OLED_WR_Byte(0x02,OLED_CMD);//
    

  501.         OLED_WR_Byte(0x8D,OLED_CMD);//--set Charge Pump enable/disable
    

  502.         OLED_WR_Byte(0x14,OLED_CMD);//--set(0x10) disable
    

  503.         OLED_Clear();
    

  504.         OLED_WR_Byte(0xAF,OLED_CMD);
    

  505. }
    

  506.  
    


  507.
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:40 | 显示全部楼层
key.c文件
复制
  1. #include "stm32f10x.h"
    

  2. #include "key.h"
    

  3. #include "sys.h" 
    

  4. #include "delay.h"
    

  5. #include "usart.h"
    

  6.  
    

  7.  
    

  8. //按键初始化函数
    

  9. void KEY_Init(void) //IO初始化
    

  10. { 
    

  11.          GPIO_InitTypeDef GPIO_InitStructure;
    

  12.  
    

  13.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB,ENABLE);
    

  14.  
    

  15.         GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_5;  
    

  16.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
    

  17.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //推挽输出
    

  18.          GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    

  19.         GPIO_SetBits(GPIOB,GPIO_Pin_5);  
    

  20.         
    

  21.         GPIO_InitStructure.GPIO_Pin  = KEY1|KEY2|KEY3|KEY4;   //行  a  4 5 6 7 
    

  22.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //PA0设置成输入，默认上拉  
    

  23.         GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.0
    

  24.         
    

  25.         
    

  26.         GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;  //lie  
    

  27.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                                                                                                         //a 4 5 6 7
    

  28.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //推挽输出
    

  29.         GPIO_Init(GPIOA, &GPIO_InitStructure);  
    

  30.         GPIO_ResetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);       //a 0 1 2 3
    

  31. }
    

  32.  
    

  33.  
    

  34.  
    

  35. u8 Key = 0;
    

  36. u8 flag=0;
    

  37. u16 abc[9] = {0,0,0,0,0,0,0,0,0};
    

  38.  
    

  39. u8 i = 0;
    

  40. u8 Flag = 0;
    

  41. int sum1 = 0;
    

  42.  
    

  43. int sun1_read()
    

  44. {
    

  45.    return sum1;
    

  46. }
    

  47.  
    

  48. u16 * abd_read();
    

  49.  
    

  50.  
    

  51. u16 *abc_read()
    

  52. {
    

  53.                 return &abc[0];
    

  54. }
    

  55.  
    

  56.  
    

  57. int Wei_Shu(u8 a)
    

  58. {
    

  59.         int sum = 1, i = 0;
    

  60.         for(;i<a;i++)
    

  61.         {
    

  62.         sum =        sum*10;
    

  63.         }
    

  64.         return sum;
    

  65. }
    

  66.  
    

  67.  
    

  68. u16 time(u16 abc[9],u8 j)
    

  69. {        
    

  70.         int time = 0 ,a = j ,shijian = 0;
    

  71.                 for(time = 0; time < j; time++ )
    

  72.         {
    

  73.                 shijian +=  abc[time]*Wei_Shu(a--);  
    

  74.         }
    

  75.         return shijian;                
    

  76. }
    

  77.  
    

  78. char ok = 0;
    

  79. char led_liang = 0;
    

  80. void Key_Input( u8 *key1)
    

  81. {        
    

  82.         if(ok==1){
    

  83.         
    

  84.         
    

  85.                 if(*key1 == 16 && Flag == 0)
    

  86.         {
    

  87.                 Flag = 1;
    

  88.         }
    

  89.         else if(Flag == 1)
    

  90.         {                
    

  91.                 
    

  92.          if(*key1 == 16 && Flag == 1)
    

  93.         {
    

  94.                 Flag = 0;
    

  95.                 
    

  96.                         sum1 = (short)(time(abc,i)/10);
    

  97.                         printf(" shijian =%d\r\n",sum1);
    

  98.                 
    

  99.                          if(0<sum1)
    

  100.                         {
    

  101.                                 sum1 = sum1*1000;
    

  102.                                 led_liang = 1;
    

  103.                         }
    

  104.                         //
    

  105.                 for(i=0;i<9;i++)
    

  106.                         abc[i] = 0;        
    

  107.                 i = 0;        
    

  108.          }        
    

  109.                         else if(*key1<10)
    

  110.                                 {
    

  111.                                         abc[i] = *key1;
    

  112.                                         i++;
    

  113.                                                 if(i>9)
    

  114.                                                 {
    

  115.                                                          i = 0;
    

  116.                                           }
    

  117.                 }
    

  118.         }
    

  119.         
    

  120.         else if(*key1 == 13){
    

  121.                 sum1 = 0;
    

  122.                                         //
    

  123.                 for(i=0;i<9;i++)
    

  124.                         abc[i] = 0;        
    

  125.                 i = 0;        
    

  126.         }
    

  127.         
    

  128.         
    

  129.         ok = 0;
    

  130. }
    

  131.         
    

  132.                 if(led_liang==1 && sum1>0){
    

  133.                                 GPIO_SetBits(GPIOB,GPIO_Pin_5);        
    

  134.                                 //delay_ms(1);                
    

  135.                                 sum1--;                        
    

  136.                         }
    

  137.                 
    

  138.                         if(sum1==0){
    

  139.                                 led_liang = 0;
    

  140.                                 GPIO_ResetBits(GPIOB,GPIO_Pin_5);        
    

  141.                         }
    

  142.                 
    

  143.  
    

  144.  
    

  145. }
    

  146.  
    

  147. void KEY_config(u8 *Key)
    

  148. {
    

  149.         char i=1,j=1;
    

  150.         *Key = 0;
    

  151.         for(;i<5;i++){
    

  152.                          GPIO_ResetBits(GPIOA,GPIO_Pin_0<<(i-1));     //先拉低
    

  153.                         if((KEY1_Input == RESET) || (KEY2_Input == RESET) || (KEY3_Input == RESET) || (KEY4_Input == RESET))
    

  154.                         {
    

  155.                                         delay_ms(10);
    

  156.                                         for(j=1;j<5;j++){
    

  157.                                                 if(GPIO_ReadInputDataBit(KEY_PROT,GPIO_Pin_4<<(j-1)) == RESET){
    

  158.                                                         flag = 1;
    

  159.                                                         *Key = (i-1)*4+j;
    

  160.                                                         while(!GPIO_ReadInputDataBit(KEY_PROT,GPIO_Pin_4<<(j-1))){};
    

  161.                                                         //Key_Input(Key);
    

  162.                                                                 ok = 1;
    

  163.                                                         break;                                                
    

  164.                                                 }
    

  165.                                                 else
    

  166.                                                         flag = 0;
    

  167.                                         }
    

  168.                   }
    

  169.                         GPIO_SetBits(GPIOA,GPIO_Pin_0<<(i-1)); //再次拉高
    

  170.          }
    

  171. }
    

  172.  
    


  173.
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:43 | 显示全部楼层
main.c函数
复制
  1. #include "led.h"
    

  2. #include "delay.h"
    

  3. #include "key.h"
    

  4. #include "sys.h"
    

  5. #include "usart.h"
    

  6. #include "exti.h"
    

  7. #include "beep.h"
    

  8. #include "timer.h"
    

  9. #include "stm32f10x_tim.h"
    

  10. #include "oled.h"
    

  11.  
    

  12.  
    

  13. u8 Key000=0;
    

  14.  
    

  15. //定时器3中断服务程序
    

  16. void TIM3_IRQHandler(void)   //TIM3中断
    

  17. {
    

  18.         if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  //检查TIM3更新中断发生与否
    

  19.                 {
    

  20.                 TIM_ClearITPendingBit(TIM3, TIM_IT_Update);  //清除TIMx更新中断标志 
    

  21.                         KEY_config(&Key000);
    

  22.                         Key_Input(&Key000);
    

  23.                 }
    

  24. }
    

  25.  
    

  26. char a[9]={0,0,0,0,0,0,0,0,0};
    

  27. char *abd_xiugai(u16 abc[9]){
    

  28.         char i = 0;
    

  29.   while(abc[i]!=0){
    

  30.                 a[i] = abc[i]  +  48;
    

  31.                 i++;
    

  32.                 if(i==7)
    

  33.                         break;
    

  34.                 }
    

  35.         return a;
    

  36. }
    

  37.          
    

  38. char b[5];
    

  39. char *sun1_read_xiu_acill(int a){
    

  40.         //1234000s
    

  41.         
    

  42.          a = a/1000;
    

  43.         
    

  44.          b[3] = (char)(a%10+48);
    

  45.          b[2] = (char)((a/10)%10)+48;
    

  46.          b[1] = (char)((a/100)%10)+48;
    

  47.          b[0] = (char)(a/1000)+48;
    

  48.          b[4] = 0;
    

  49.          return b;
    

  50. } 
    

  51.  
    

  52.  int main(void)
    

  53.  {                
    

  54.         u8 is_anxia = 0;
    

  55.         delay_init();                     //延时函数初始化         
    

  56.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    

  57.         uart_init(4800);         //串口初始化4800
    

  58.          KEY_Init();
    

  59.         //LED_Init();                                  //初始化与LED连接的硬件接口 
    

  60.         //LED0=0;                                        //先点亮红灯 
    

  61.         TIM3_Int_Init(89999,2);
    

  62.         OLED_Init();
    

  63.         OLED_ColorTurn(0);//0正常显示，1 反色显示
    

  64.   OLED_DisplayTurn(0);//0正常显示 1 屏幕翻转显示
    

  65.  
    

  66.         while(1)
    

  67.         {                         
    

  68.  
    

  69.                 OLED_Clear();
    

  70.                 
    

  71.                 if(*(abc_read()+0) == 0 && sun1_read()==0)
    

  72.                         OLED_ShowString(10,0,"P 16",16,1);
    

  73.                 else if(sun1_read()==0)
    

  74.                         OLED_ShowString(10,0,abd_xiugai(abc_read()),16,1);
    

  75.                 else if(sun1_read()!=0)
    

  76.                         OLED_ShowString(10,0,sun1_read_xiu_acill(sun1_read()),16,1);
    

  77.  
    

  78.                 
    

  79.                 OLED_Refresh(); 
    

  80.         }
    

  81.         }
    

  82.  
    

  83.  /*
    

  84.  void TIM3_IRQHandler(void)   //TIM3中断
    

  85. {
    

  86.         if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  //检查TIM3更新中断发生与否
    

  87.                 {
    

  88.                 TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清除TIMx更新中断标志 
    

  89.         
    

  90.                                 Key_Input(&key);
    

  91.                 }
    

  92. }*/
    


  93.
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:46 | 显示全部楼层
先来个总述

接线方式  矩阵键盘的8个引脚对应GPIOA 0---7

                led灯对应 GPIOB 5     可以替换为一个LS298N模块控制电机 或者其他的很多东西

                 oled屏幕对应接线 scl - GPIO B1

                                               sda-GPIOB7

                                                VCC和GND随意了
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:47 | 显示全部楼层
接下来是对此代码的详解

        首先是对于key.h 文件的解释我们对于矩阵键盘对应IO口的一个声明，之后我们可以将对应的IO口进行简化方便使用，也使我们的代码更有可读性。

对于oled.h也是同理，这就不在啰嗦了，应该都懂吧
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:48 | 显示全部楼层
对于key.c 文件是本文章的核心部分

        首先是对于矩阵键盘八个对应引脚的初始化这里我们选择扫描的方式来进行按键检测，但是之后我遇到了一个大问题 那就是延时的问题 会发现在我们使用oled后，时间会变得不可控。
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:50 | 显示全部楼层
在这里我们对于八个IO口选择 4个推挽输出 4个上拉输出的模式  在这里我将led灯对应的IO口初始化也放在这里了。对于io口的初始化就不在详细的说明 ，没什么好说的 只需要注意和.h文件的对应关系
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:51 | 显示全部楼层
之后我们来说说

void KEY_config(u8 *Key)
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:52 | 显示全部楼层
对于此函数需要一丁点的位操作知识 用到了一点<<    >>的操作
复制
  1.  
    

  2. void KEY_config(u8 *Key)
    

  3. {
    

  4.         char i=1,j=1;
    

  5.         *Key = 0;
    

  6.         for(;i<5;i++){
    

  7.                          GPIO_ResetBits(GPIOA,GPIO_Pin_0<<(i-1));     //先拉低
    

  8.                         if((KEY1_Input == RESET) || (KEY2_Input == RESET) || (KEY3_Input == RESET) || (KEY4_Input == RESET))
    

  9.                         {
    

  10.                                         delay_ms(10);
    

  11.                                         for(j=1;j<5;j++){
    

  12.                                                 if(GPIO_ReadInputDataBit(KEY_PROT,GPIO_Pin_4<<(j-1)) == RESET){
    

  13.                                                         flag = 1;
    

  14.                                                         *Key = (i-1)*4+j;
    

  15.                                                         while(!GPIO_ReadInputDataBit(KEY_PROT,GPIO_Pin_4<<(j-1))){};
    

  16.                                                         //Key_Input(Key);
    

  17.                                                                 ok = 1;
    

  18.                                                         break;                                                
    

  19.                                                 }
    

  20.                                                 else
    

  21.                                                         flag = 0;
    

  22.                                         }
    

  23.                   }
    

  24.                         GPIO_SetBits(GPIOA,GPIO_Pin_0<<(i-1)); //再次拉高
    

  25.          }
    

  26. }
    


  27.
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:53 | 显示全部楼层
769526303a65a95504.png
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:54 | 显示全部楼层
我们在初始化时将4路IO口设置为默认上拉  也就是一直输出高电平

所以我们只需要循环检测 电平的高低 如果有按键按下 那么图上边的一排1 必然有一路变为低电平

我们只需要在循环扫描一列4路哪一路为低电平  如果2路都为低电平则可以确认按键的位置 相当于在按键位置花了一个十字 确认位置。
回复 赏

举报

 楼主| 9dome猫 发表于 2022-8-22 23:55 | 显示全部楼层
好了原理已经说清了，借来下进入我们的代码部分

我们循环拉低四行的电平 那么比如我们再按下第一个按键时可以知道第一列的电平也会被拉低

这就对应了我们的前五行代码

之间插入一个按键消抖操作
回复 赏

举报

Uriah 发表于 2022-9-30 10:30 | 显示全部楼层

待向GPIO（通用I/O端口）的输入从0变为1时，程序可以一定的间隔来检查GPIO的状态
回复 赏

举报

Bblythe 发表于 2022-9-30 13:29 | 显示全部楼层

CPLD解密，DSP解密都习惯称为单片机解密
回复 赏

举报

saservice 发表于 2022-10-1 12:56 | 显示全部楼层
stm32驱动oled如何实现反色显示表示选中功能
回复 赏

举报

kkzz 发表于 2022-10-1 13:26 | 显示全部楼层
stm32怎样才能同时驱动OLED和LCD两个屏
回复 赏

举报

qiufengsd 发表于 2022-10-1 13:52 | 显示全部楼层
stm32硬件IIC不好用               
回复 赏

举报

jkl21 发表于 2022-10-1 14:25 | 显示全部楼层
stm32 怎么向oled输出数据
回复 赏

举报

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

本版积分规则

9dome猫

139

主题

1575

帖子

2

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