devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

ESP8266＋STM32获取网络时间、OLED显示时间&图片&视频。

作者：我家小花儿 | 2024-05-08 07:39:56

赞

踩

stm32获取网络时间

学习过程不易，发文共享以下学习过程~

先说说我的设计内容的组成：

目录

学习过程不易，发文共享以下学习过程~

1. STM32控制ESP8266获取网络时间

第一步：电脑控制ESP8266获取时间数据；

2. STM32基于获取到的时间使用定时器本地运行

3. 使用OLED显示时间数据，包括自定义的文字显示，图片显示，视频显示；

4. 完整的工程代码

1. STM32控制ESP8266获取网络时间

为了更好的理解原理，可以先从电脑通过串口控制ESP8266获取时间数据开始入手学习。

为此需要准备以下的软件和硬件

1.ESP8266-01S（其他ESP8266应该也可以）

2.一个烧录下载器

3.正点原子的串口助手

 

第一步：电脑控制ESP8266获取时间数据；

需要用ESP8266和电脑建立串口通讯，通过电脑给ESP8266发送AT指令。

插一句关于AT指令的介绍：

我的理解是 AT指令就是一句句的口令，你向ESP8266发出对应的指令，ESP8266就会根据你的指令做出相应的反应，当然AT指令是一系列提前编译好的官方指令，不是自己随意编写的！对于AT指令的学习，可以参考这篇文章~

玩转ESP8266-01——AT指令集  http://t.csdn.cn/1EZ0E

 Step1：将ESP8266和烧录下载器正确连接，再与电脑连接

2dfdfbb1567b4f3d8d0f66976320e0c4.jpeg

烧录下载器和电脑

a85daf91437744a38c8f58d4e2a0d5c7.jpeg

ESP8266和烧录下载器

 

  Step2：打开正点原子的串口助手，选择正确的端口号，波特率选择115200.（当然你要是电脑没有烧录下载器的驱动的话，电脑会识别不了这个设备，必须去安装CH340的驱动才行）

1b87385cb2d54c8083b1eddf1ec08ca6.png

初始界面

正确连接的话，上述界面由设备的端口号。 

Step3：提前新建好对应的AT指令，这里基于我的程序设计要求，新建如下指令即可。

  1. AT                           //查询模块是否正常工作           
  2. AT+RST                       //模块复位
  3. AT+RESTORE                   //恢复出厂设置
  4. AT+CWMODE=1                  //设置WiFi模块的模式
  5. AT+CIPMUX=0                  //设置模块为单路连接模式
  6. AT+CWJAP="WIFI名称","密码"    //连接网络
  7. AT+CIPSTART="TCP","192.168.666",80//连接TCP服务器,192.168.0.102是服务器IP，8080是服务器端口。
  8. AT+CIPSTART="TCP","quan.suning.com",80  //或者 AT+CIPSTART="TCP","175.6.49.231",80
  9. AT+CIPMODE=1	             //开启透传模式
  10. AT+CIPSEND		             //开始发送数据
  11. +++                          //退出透传模式

 完成上述的准备工作之后，就可以点击打开串口、发送新行。

一般串口刚连接上会发送一些杂乱数据（应该是表示ESP8266准备好了通讯的意思，因为发来的消息最后面有个ready）

Step4：按照顺序一次的点击新建好的10条AT指令，当然速度不适宜太快，需要等ESP8266发送对应的回答之后才可以继续点击，每一次点击的 效果如下。

234afc1e6a224d4ca1a70f6b25a4968c.png

第一条指令：

3103fd14ac35484c8b3fb3f9334ff732.png

第二条指令：

856f4c43245e4845b715afa65ce78270.png

第三条指令：

fc78e154d16743c28828b4a61ea046ed.png

第四条指令：

 

65f910f9da2b4a629a885800dbcde57d.png

第五条指令：

2fb3c0345fb64dcf8b825b47e7264ca0.png

第六条指令：

f5aad0845a22442ea98551b7825bca21.png

第八条指令：

99d0b64a810a4dd49314e9f90f2ac76c.png

第七条指令：

 

28b3c8df8dbd43cca5509e921e1aa7cc.png

第九条指令：

063fb794a3834416955db435fca89b03.png

第十条指令：

 

补充一下上面ESP8266返回来的数据说明：

 第一张图片：如果返回来OK表示器件正确的连接了。

 第二张图片：收到OK就表示复位成功，后面跟着的应该是一些ESP8266的自身信息。

 第三张图片：将ESP8266切换为STA模式，作为一个设备去连接WIFI，关于ESP8266的工作模式可以看这个链接http://t.csdn.cn/4x1oA。

 第四张图片：设置ESP8266为单路连接模式，返回OK表示开启成功。

 第五张图片：注意这是表示将要连接的WIFI的名称和密码发送给ESP8266，要注意大小写，最好是用手机开热点，这样方便查看是否成功连接上，返回OK即连接成功。

 第六张图片：如果返回来OK表示ESP8266开启透传模式，透传模式不懂的也可以看上面的链接。

 第七张图片：通过苏宁去获取时间，这是苏宁的服务器地址，返回OK连接成功。

 第八张图片：查询ESP8266是否准备发送就绪，出现一个>表示已就绪。

 第九张图片：这是一个返回时间的链接，在浏览器输入网址浏览器即返回时间数据。

 第十张图片：退出透传模式，要先关闭发送新行,然后多试几次，如果收到+++表示退出成功，这个时候再点击第一条指令，收到OK就验证了退出成功。

 

2. STM32基于获取到的时间使用定时器本地运行

了解了ESP8266获取时间的原理之后就可以开始编写STM32F103C8T6的工程了，

这里是使用一个ESP8266的库来开发ESP8266的，代码原文是这个~，感谢大佬的分享。

http://t.csdn.cn/L3M3nhttp://t.csdn.cn/L3M3n本来是想基于上述文章，写一个获取时间天气的课设的，在一番尝试之后，无果，临近检查，就只能复刻一下只获取时间数据了。

获取时间天气的JSON解析函数我也写了，为此特定去学了以下JSON解析，参考一篇知乎的文章写的，链接找不到了，贴出我的解析函数，大家可以帮我参考一下。

这里我仿照上面大佬的文章，将变量用 函数的方法返回到主函数，奈何还是有问题，有时间再经研究吧。

  1. char id,city,guojia,zone,tianqi,code,temp,time;
  2. //心知天气
  3. void parse_seniverse_weather(void)
  4. {
  5.     cJSON *root;
  6.     cJSON *results;
  7.     cJSON *last_update;
  8.     cJSON *loc_json, *daily_json;
  9.     cJSON *forecast_json;
  10.     char *loc_tmp, *weather_tmp, *update_tmp;
  11.  
  12.     root = cJSON_Parse((const char*)Time_buff);  //root就取得了json的数据
  13.     if(root)  //如果取得
  14.     {
  15. //        printf("JSON格式正确:\n%s\n\n",cJSON_Print(root));    //输出json字符串
  16.         results = cJSON_GetObjectItem(root, "results");  //寻找关键字一 
  17.         results = cJSON_GetArrayItem(results,0);  //取出results数组里的第0个也就是第一个
  18.         if(results)  //如果取得
  19.         {
  20.             loc_json = cJSON_GetObjectItem(results, "location");   //得到location键对应的值，是一个对象
  21.  
  22.             loc_tmp = cJSON_GetObjectItem(loc_json, "id") -> valuestring;  //取得ID
  23.             id = *loc_tmp;  //注意这个地方可能出错，看读取出来的是什么
  24.             loc_tmp = cJSON_GetObjectItem(loc_json, "name") -> valuestring;  //取得城市
  25.             city = *loc_tmp;
  26. 			loc_tmp = cJSON_GetObjectItem(loc_json, "country") -> valuestring;  //取得国家
  27.             guojia = *loc_tmp;
  28.             loc_tmp = cJSON_GetObjectItem(loc_json, "timezone") -> valuestring;  //取得时区
  29.             zone = *loc_tmp;
  30.  
  31.             daily_json = cJSON_GetObjectItem(results, "now");//原本是读取三天的，修改为读取现在的now
  32.             if(daily_json)
  33.             {
  34.                     forecast_json = cJSON_GetArrayItem(daily_json, 0);
  35.                     weather_tmp = cJSON_GetObjectItem(forecast_json, "text") -> valuestring;  //取得天气情况
  36.                     tianqi = *weather_tmp;
  37.                     weather_tmp = cJSON_GetObjectItem(forecast_json, "code") -> valuestring;  //取得code情况
  38.                     code = *weather_tmp;
  39.                     weather_tmp = cJSON_GetObjectItem(forecast_json, "temperature") -> valuestring;  //取得温度情况
  40.                     temp = *weather_tmp;
  41.             }
  42.             else
  43. //                printf("daily json格式错误\r\n");
  44.             last_update = cJSON_GetObjectItem(results, "last_update");
  45.             update_tmp = last_update->valuestring;
  46.             if(last_update)
  47.             {
  48. 				time = *update_tmp;
  49.             }
  50.         }
  51.         else
  52.         {
  53.             //printf("results格式错误:%s\r\n", cJSON_GetErrorPtr());
  54.         }
  55.     }
  56.     else
  57.     {
  58.         //printf("JSON格式错误\r\n");
  59.     }
  60.     cJSON_Delete(root);//最后释放空间
  61.     cJSON_Delete(results);//最后释放空间
  62. }

重点来了，我的课设的代码，其实和大佬的分享差不多。

  1. #include "stm32f10x.h"
  2. #include "sys.h"
  3. #include "string.h"
  4. #include "stdlib.h"
  5. #include "esp8266.h"
  6.  
  7. #include "usart2.h"
  8.  
  9. #include "delay.h"
  10. #include "init.h"
  11.  
  12. /*用于保存小时，分钟，秒数的变量*/
  13. int hour_return;//小时
  14. int min_return; //分钟
  15. int sec_return; //秒数
  16.  
  17. //WIFI和密码·
  18. #define ESP8266_WIFI_INFO		"AT+CWJAP=\"iQOO\",\"qyh12345678\"\r\n"
  19.  
  20. //苏宁后台获取时间的API
  21. #define Time_TCP		"AT+CIPSTART=\"TCP\",\"quan.suning.com\",80\r\n"
  22. //苏宁后台获取时间GET报文
  23. #define Time_GET		"GET http://quan.suning.com/getSysTime.do\r\n"
  24.  
  25.  
  26. //ESP8266数据存放
  27. unsigned char esp8266_buf[300] = {0};
  28. unsigned short esp8266_cnt = 0, esp8266_cntPre = 0;
  29. //存放时间数据
  30. unsigned char Time_buff[100];   //位数是随机确定的
  31.  
  32.  
  33.  
  34. /**************************************************************************/
  35. //函数作用：ESP8266_Init初始化函数
  36. //函数名称：ESP8266_Init(void);
  37. //内部参数：
  38. //修改日期：2022年4月18日  下午16：18
  39. /**************************************************************************/
  40. void ESP8266_Init(void)
  41. {
  42.     ESP8266_Clear();//清除缓冲
  43.  
  44.     /*让WIFI退出透传模式 要发两次*/
  45.     while(ESP8266_SendCmd("+++", ""));//这是一个死循环，目的结束透传模式
  46.  
  47.     /*让WIFI清除Flah*/
  48.     //printf("0.恢复出厂设置成功\r\n");
  49.  
  50.     while(ESP8266_SendCmd("AT+RESTORE\r\n", "OK"));//恢复出厂设置
  51.  
  52.     //初始AT应答，看wifi接线是否成功
  53.     //printf("1.AT应答成功\r\n");
  54.  
  55.     while(ESP8266_SendCmd("AT\r\n", "OK"));
  56.  
  57.     //
  58.     //加一步ESP8266复位操作
  59.     //printf("2.RST复位成功\r\n");
  60.     ESP8266_SendCmd("AT+RST\r\n", "");
  61.     delay_ms(500);
  62.     ESP8266_SendCmd("AT+CIPCLOSE\r\n", "");//断开与服务器的连接
  63.     delay_ms(500);
  64.     /
  65.  
  66.     //printf("3.CWMODE设置工作模式，保存到Flash\r\n");
  67.  
  68.     while(ESP8266_SendCmd("AT+CWMODE=1\r\n", "OK"));//没有CUR就是保存到Flash，AT+CWMODE_CUR设置模块工作模式为station，不保存到Flash
  69.  
  70.     //printf("4.AT+CIPMUX单连接模式设置成功\r\n");
  71.  
  72.     while(ESP8266_SendCmd("AT+CIPMUX=0\r\n", "OK"));//AT+CIPMUX=0 设置为单连接模式
  73.  
  74.     //printf("5.寻找对应的WIFI名称和密码\r\n");
  75.  
  76.     while(ESP8266_SendCmd(ESP8266_WIFI_INFO, "WIFI GOT IP"));
  77.  
  78.     //printf("6.ESP8266_Init连接WIFI成功\r\n");
  79. }
  80.  
  81.  
  82.  
  83. /**************************************************************************/
  84. //函数作用：获取苏宁后台时间
  85. //函数名称：Get_current_time();
  86. //内部参数：
  87. /**************************************************************************/
  88. void Get_current_time(void)
  89. {
  90.     ESP8266_Init();	     //连接Wifi的ESP8266初始化
  91.     ESP8266_Clear();
  92.  
  93.     while(ESP8266_SendCmd(Time_TCP, "CONNECT"));
  94.  
  95.     //printf("6.访问苏宁服务器成功 OK\r\n");
  96.  
  97.     while(ESP8266_SendCmd("AT+CIPMODE=1\r\n", "OK"));//开启透传模式
  98.  
  99.     //printf("7.开启透传模式成功 OK\r\n");
  100.  
  101.     /*sizeof(Time_GET)，必须用sizeof函数，用strlen没有用*/
  102.     ESP8266_SendData((u8 *)Time_GET, sizeof(Time_GET)); //发送AT+CIPSEND  以及 Time_GET
  103.  
  104.     ESP8266_GetIPD_GET(200, Time_buff); //将串口数据取出来
  105.     ESP8266_Clear();//清除缓存数据
  106.  
  107.     while(ESP8266_SendCmd("+++", ""));      /*退出透传模式，发送两次*/
  108.  
  109.     //printf("9.退出透传模式成功 OK\r\n");
  110.  
  111. }
  112.  
  113.  
  114. /*******************************************解析时间*************************************/
  115. //代码来源于CSDN博客地址：https://blog.csdn.net/xgy516/article/details/119968124
  116. /****************************************************************************************
  117. 年的首地址移动11位；
  118. 月份首地址移动15位；
  119. 日期首地址移动17位；
  120. 小时首地址移动19位；
  121. 分钟首地址移动21位；
  122. 秒钟首地址移动23位；
  123. */
  124. #define  YEAR_ADD_DRES 11
  125. #define  MOON_ADD_DRES 15
  126. #define  DAYS_ADD_DRES 17
  127.  
  128. #define  HOURS_ADD_DRES 19
  129. #define  MINUTES_ADD_DRES 21
  130. #define  SECONDS_ADD_DRES 23
  131.  
  132. int DAYS, MOONS, YEARS, TIMES;
  133. ///**************************************************************************/
  134. 函数作用：解析苏宁时间函数
  135. 函数名称：cJSON_Time_Parse();
  136. 内部参数：
  137. 修改日期：2022年4月18日  下午22：11
  138. ///**************************************************************************/
  139. void cJSON_Time_Parse(void)
  140. {
  141.     char *data_pt;
  142.     char *day_string;
  143.     char *moon_string;
  144.     char *year_string;
  145.     char *hour_string;
  146.     char *minute_string;
  147.     char *second_string;
  148.  
  149.  
  150.     data_pt = strstr((const char *)Time_buff, (const char *)"sysTime1");  //寻找到时间结果的地址
  151.  
  152. //    printf("%s\r\n",Time_buff);
  153.     if(data_pt != NULL)
  154.     {
  155.         day_string = data_pt + DAYS_ADD_DRES;          //日期地址
  156.         moon_string = data_pt + MOON_ADD_DRES;         //月份地址
  157.         year_string = data_pt + YEAR_ADD_DRES;        //年份地址
  158.         hour_string = data_pt + HOURS_ADD_DRES;       //小时地址
  159.         minute_string = data_pt + MINUTES_ADD_DRES;   //分钟地址
  160.         second_string = data_pt + SECONDS_ADD_DRES;   //秒中地址
  161.  
  162.         //将时间信息传递给全局变量
  163.         DAYS = Get_Day(day_string);
  164.         MOONS = Get_Moonth(moon_string);
  165.         YEARS = Get_Year(year_string);
  166.         TIMES = Get_Times(hour_string, minute_string, second_string);
  167. 		
  168. 		hour_return = TIMES/3600;//小时
  169. 		min_return = (TIMES%3600)/60; //分钟
  170.         sec_return = (TIMES%3600)%60+2; //秒数
  171. 		//printf("时间获取并处理成功\r\n");
  172.  
  173.     }
  174.     else
  175.     {
  176.         //printf("时间获取失败\r\n");
  177.     }
  178. }
  179.  
  180. //得到年函数（以年开始的字符串长度过长，因此使用不一样的方法）
  181. //输入值是年位置的地址
  182. //返回值是 整型的10进制四位数
  183. int Get_Year(char *y)
  184. {
  185.  
  186.     int year_return;
  187.     char *year_temp;
  188.     char year[5] = {0};
  189.     char i;
  190. //年的获取须要提取一次字符串，不然没法读取
  191.     year_temp = y;
  192.  
  193.     for(i = 0; i < 4; i++)
  194.     {
  195.         year[i] = *year_temp;
  196.         year_temp ++;
  197.     }
  198.  
  199.     year_return =  atoi(&year[0]);
  200.     return year_return;
  201. }
  202.  
  203. //得到月份函数
  204. //输入值是月份位置的地址
  205. //返回值是 整型的10进制两位数
  206. int Get_Moonth(char *m)
  207. {
  208.     int moonth_return;
  209.     moonth_return = atoi(m) / 100000000; //取月份
  210.     return moonth_return;
  211. }
  212.  
  213. //得到日期函数
  214. //输入值是日期位置的地址
  215. //返回值是 整型的10进制两位数
  216. int Get_Day(char *d)
  217. {
  218.  
  219.  
  220.     int day_return;
  221.     day_return = atoi(d) / 1000000; //取日期
  222.  
  223.     return day_return;
  224. }
  225.  
  226. //得到时间
  227. //输入值是时间的位置的地址
  228. //返回值是 整型的10进制的时间总秒数
  229. int Get_Times(char *h, char *m, char *s)
  230. {
  231.     int time_return;
  232.     int hour_return;
  233.     int min_return;
  234.     int sec_return;
  235.  
  236.     hour_return = atoi(h) / 10000; //取小时
  237.     min_return = atoi(m) / 100; //取分钟
  238.     sec_return = atoi(s);   //取秒数
  239.  
  240.     time_return = hour_return * 3600 + min_return * 60 + sec_return; //转换成总秒数
  241.  
  242.     return time_return;
  243. }
  244.  
  245. /*****************************************************************解析苏宁时间END********************************************************************************/
  246. /*************************************************************************************************************************************************/
  247.  
  248. /**************************************************************************/
  249. //函数作用：串口二中断函数
  250. //函数名称：USART2_IRQHandler();
  251. //内部参数：
  252. //修改日期：2022年4月18日  下午4：18
  253. /**************************************************************************/
  254. void USART2_IRQHandler(void)
  255. {
  256.     if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) //接收中断
  257.     {
  258.  
  259.         if(esp8266_cnt >= sizeof(esp8266_buf))	esp8266_cnt = 0; //防止串口被刷爆
  260.  
  261.         esp8266_buf[esp8266_cnt++] = USART2->DR;
  262.  
  263. //		USART_SendData(USART1,USART2->DR);      //让接收到的数据打印在串口一上
  264.  
  265.         USART_ClearFlag(USART2, USART_FLAG_RXNE);
  266.     }
  267. }
  268. /**下面的代码来源于：
  269. 	************************************************************
  270. 	************************************************************
  271. 	************************************************************
  272. 	*	文件名： 	esp8266.c
  273. 	*
  274. 	*	作者： 		张继瑞
  275. 	*
  276. 	*	日期： 		2017-05-08
  277. 	*
  278. 	*	版本： 		V1.0
  279. 	*
  280. 	*	说明： 		ESP8266的简单驱动
  281. 	*
  282. 	*	修改记录：
  283. 	************************************************************
  284. 	************************************************************
  285. 	************************************************************
  286. **/
  287. //==========================================================
  288. //	函数名称：	ESP8266_Clear
  289. //
  290. //	函数功能：	清空缓存
  291. //
  292. //	入口参数：	无
  293. //
  294. //	返回参数：	无
  295. //
  296. //	说明：
  297. //==========================================================
  298. void ESP8266_Clear(void)
  299. {
  300.  
  301.     memset(esp8266_buf, 0, sizeof(esp8266_buf));
  302.     esp8266_cnt = 0;
  303.  
  304. }
  305. //==========================================================
  306. //	函数名称：	ESP8266_SendData
  307. //
  308. //	函数功能：	发送数据
  309. //
  310. //	入口参数：	data：数据
  311. //				len：长度
  312. //
  313. //	返回参数：	无
  314. //
  315. //	说明：
  316. //==========================================================
  317. void ESP8266_SendData(unsigned char *data, unsigned short len)
  318. {
  319.     char cmdBuf[32];
  320.  
  321.     ESP8266_Clear();								//清空接收缓存
  322.     sprintf(cmdBuf, "AT+CIPSEND\r\n");		//发送命令
  323.  
  324.     if(!ESP8266_SendCmd(cmdBuf, ">"))				//收到‘>’时可以发送数据
  325.     {
  326.         //printf("8.开始处于透传发送状态!\r\n");
  327.         /*发送请求数据*/
  328.         Usart_SendString(USART2, data, len);		//发送设备连接请求数据
  329.     }
  330. }
  331.  
  332. //==========================================================
  333. //	函数名称：	ESP8266_GetIPD
  334. //
  335. //	函数功能：	copy天气数据到buff数组里面
  336. //
  337. //	返回参数：	平台返回的原始数据
  338. //
  339. //	说明：		copy天气数据到buff
  340. //==========================================================
  341.  
  342. unsigned char *ESP8266_GetIPD_GET(unsigned short timeOut, u8 *buff) //这里我用了一个全局变量将esp8266buf储存到这个全局变量里面
  343. {
  344.     do
  345.     {
  346.         delay_ms(5);
  347.     }
  348.     while(timeOut--);
  349.  
  350.     strcpy((char*)buff, (char*)esp8266_buf);
  351.     return buff;
  352. }
  353.  
  354.  
  355.  
  356. //==========================================================
  357. //	函数名称：	ESP8266_WaitRecive
  358. //
  359. //	函数功能：	等待接收完成
  360. //
  361. //	入口参数：	无
  362. //
  363. //	返回参数：	REV_OK-接收完成		REV_WAIT-接收超时未完成
  364. //
  365. //	说明：		循环调用检测是否接收完成
  366. //==========================================================
  367. _Bool ESP8266_WaitRecive(void)
  368. {
  369.  
  370.     if(esp8266_cnt == 0) 							//如果接收计数为0 则说明没有处于接收数据中，所以直接跳出，结束函数
  371.         return REV_WAIT;
  372.  
  373.     if(esp8266_cnt == esp8266_cntPre)				//如果上一次的值和这次相同，则说明接收完毕
  374.     {
  375.         esp8266_cnt = 0;							//清0接收计数
  376.  
  377.         return REV_OK;								//返回接收完成标志
  378.     }
  379.  
  380.     esp8266_cntPre = esp8266_cnt;					//置为相同
  381.  
  382.     return REV_WAIT;								//返回接收未完成标志
  383.  
  384. }
  385.  
  386.  
  387. //==========================================================
  388. //	函数名称：	ESP8266_SendCmd
  389. //
  390. //	函数功能：	发送命令
  391. //
  392. //	入口参数：	cmd：命令
  393. //				res：需要检查的返回指令
  394. //
  395. //	返回参数：	0-成功	1-失败
  396. //
  397. //	说明：
  398. //==========================================================
  399. _Bool ESP8266_SendCmd(char *cmd, char *res)
  400. {
  401.  
  402.     unsigned char timeOut = 250;
  403.  
  404.     Usart_SendString(USART2, (unsigned char *)cmd, strlen((const char *)cmd));
  405.  
  406.     while(timeOut--)
  407.     {
  408.         if(ESP8266_WaitRecive() == REV_OK)							//如果收到数据
  409.         {
  410.             if(strstr((const char *)esp8266_buf, res) != NULL)		//如果检索到关键词
  411.             {
  412.                 ESP8266_Clear();									//清空缓存
  413.  
  414.                 return 0;
  415.             }
  416.         }
  417.  
  418.         delay_ms(10);
  419.     }
  420.     return 1;
  421. }
  422.  
  423.  
  424.  
  425.  
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.  
  434.  
  435.

另一个重头戏来了。

OLED显示！！

3. 使用OLED显示时间数据，包括自定义的文字显示，图片显示，视频显示；

OLED显示我参考了很多资料，修修改改还是完成的七七八八。

OLED显示有自定义的编写字库的软件，编写图片字库的软件，

取字模的软件用的是：

a974b2bd25f445f98b92ef7e4eaa09f6.png

取字模

e0fec89b5c524718881e8181ff323792.png

分离抽帧

 

完蛋！刚刚取找文件，发现我把文件删了，如果有人着急的话，我可以付费帮忙解决一下，很好用的，可以一键将所有图片按照名称分成一个个的记事本文件，只用复制粘贴即可。

看看实物效果先：

ikun

 

我的OLED.C文件

  1. #include "stm32f10x.h"
  2. #include "OLED_Font.h"
  3.  
  4.  
  5. /*引脚配置*/
  6. #define OLED_W_SCL(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_8, (BitAction)(x))
  7. #define OLED_W_SDA(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_9, (BitAction)(x))
  8.  
  9. /*引脚初始化*/
  10. void OLED_I2C_Init(void)
  11. {
  12.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
  13. 	
  14. 	GPIO_InitTypeDef GPIO_InitStructure;
  15.  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
  16. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  17. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  18.  	GPIO_Init(GPIOB, &GPIO_InitStructure);
  19. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  20.  	GPIO_Init(GPIOB, &GPIO_InitStructure);
  21. 	
  22. 	OLED_W_SCL(1);
  23. 	OLED_W_SDA(1);
  24. }
  25.  
  26. /**
  27.   * @brief  I2C开始
  28.   * @param  无
  29.   * @retval 无
  30.   */
  31. void OLED_I2C_Start(void)
  32. {
  33. 	OLED_W_SDA(1);
  34. 	OLED_W_SCL(1);
  35. 	OLED_W_SDA(0);
  36. 	OLED_W_SCL(0);
  37. }
  38.  
  39. /**
  40.   * @brief  I2C停止
  41.   * @param  无
  42.   * @retval 无
  43.   */
  44. void OLED_I2C_Stop(void)
  45. {
  46. 	OLED_W_SDA(0);
  47. 	OLED_W_SCL(1);
  48. 	OLED_W_SDA(1);
  49. }
  50.  
  51. /**
  52.   * @brief  I2C发送一个字节
  53.   * @param  Byte 要发送的一个字节
  54.   * @retval 无
  55.   */
  56. void OLED_I2C_SendByte(unsigned char  Byte)
  57. {
  58. 	unsigned char  i;
  59. 	for (i = 0; i < 8; i++)
  60. 	{
  61. 		OLED_W_SDA(Byte & (0x80 >> i));
  62. 		OLED_W_SCL(1);
  63. 		OLED_W_SCL(0);
  64. 	}
  65. 	OLED_W_SCL(1);	//额外的一个时钟，不处理应答信号
  66. 	OLED_W_SCL(0);
  67. }
  68.  
  69. /**
  70.   * @brief  OLED写命令
  71.   * @param  Command 要写入的命令
  72.   * @retval 无
  73.   */
  74. void OLED_WriteCommand(unsigned char  Command)
  75. {
  76. 	OLED_I2C_Start();
  77. 	OLED_I2C_SendByte(0x78);		//从机地址
  78. 	OLED_I2C_SendByte(0x00);		//写命令
  79. 	OLED_I2C_SendByte(Command); 
  80. 	OLED_I2C_Stop();
  81. }
  82.  
  83. /**
  84.   * @brief  OLED写数据
  85.   * @param  Data 要写入的数据
  86.   * @retval 无
  87.   */
  88. void OLED_WriteData(unsigned char  Data)
  89. {
  90. 	OLED_I2C_Start();
  91. 	OLED_I2C_SendByte(0x78);		//从机地址
  92. 	OLED_I2C_SendByte(0x40);		//写数据
  93. 	OLED_I2C_SendByte(Data);
  94. 	OLED_I2C_Stop();
  95. }
  96.  
  97. /**
  98.   * @brief  OLED设置光标位置
  99.   * @param  Y 以左上角为原点，向下方向的坐标，范围：0~7
  100.   * @param  X 以左上角为原点，向右方向的坐标，范围：0~127
  101.   * @retval 无
  102.   */
  103. void OLED_SetCursor(unsigned char  Y, unsigned char  X)
  104. {
  105. 	OLED_WriteCommand(0xB0 | Y);					//设置Y位置
  106. 	OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4));	//设置X位置低4位
  107. 	OLED_WriteCommand(0x00 | (X & 0x0F));			//设置X位置高4位
  108. }
  109.  
  110. /**
  111.   * @brief  OLED清屏
  112.   * @param  无
  113.   * @retval 无
  114.   */
  115. void OLED_Clear(void)
  116. {  
  117. 	unsigned char  i, j;
  118. 	for (j = 0; j < 8; j++)
  119. 	{
  120. 		OLED_SetCursor(j, 0);
  121. 		for(i = 0; i < 128; i++)
  122. 		{
  123. 			OLED_WriteData(0x00);
  124. 		}
  125. 	}
  126. }
  127.  
  128. /**
  129.   * @brief  OLED显示一个字符
  130.   * @param  Line 行位置，范围：1~4
  131.   * @param  Column 列位置，范围：1~16
  132.   * @param  Char 要显示的一个字符，范围：ASCII可见字符
  133.   * @retval 无
  134.   */
  135. void OLED_ShowChar(unsigned char  Line, unsigned char  Column, char Char)
  136. {      	
  137. 	unsigned char  i;
  138. 	OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8);		//设置光标位置在上半部分
  139. 	for (i = 0; i < 8; i++)
  140. 	{
  141. 		OLED_WriteData(OLED_F8x16[Char - ' '][i]);			//显示上半部分内容
  142. 	}
  143. 	OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8);	//设置光标位置在下半部分
  144. 	for (i = 0; i < 8; i++)
  145. 	{
  146. 		OLED_WriteData(OLED_F8x16[Char - ' '][i + 8]);		//显示下半部分内容
  147. 	}
  148. }
  149.  
  150. /**
  151.   * @brief  OLED显示字符串
  152.   * @param  Line 起始行位置，范围：1~4
  153.   * @param  Column 起始列位置，范围：1~16
  154.   * @param  String 要显示的字符串，范围：ASCII可见字符
  155.   * @retval 无
  156.   */
  157. void OLED_ShowString(unsigned char  Line, unsigned char  Column, char *String)
  158. {
  159. 	unsigned char  i;
  160. 	for (i = 0; String[i] != '\0'; i++)
  161. 	{
  162. 		OLED_ShowChar(Line, Column + i, String[i]);
  163. 	}
  164. }
  165.  
  166. /**
  167.   * @brief  OLED次方函数
  168.   * @retval 返回值等于X的Y次方
  169.   */
  170. unsigned int  OLED_Pow(unsigned int  X, unsigned int  Y)
  171. {
  172. 	unsigned int  Result = 1;
  173. 	while (Y--)
  174. 	{
  175. 		Result *= X;
  176. 	}
  177. 	return Result;
  178. }
  179.  
  180. /**
  181.   * @brief  OLED显示数字（十进制，正数）
  182.   * @param  Line 起始行位置，范围：1~4
  183.   * @param  Column 起始列位置，范围：1~16
  184.   * @param  Number 要显示的数字，范围：0~4294967295
  185.   * @param  Length 要显示数字的长度，范围：1~10
  186.   * @retval 无
  187.   */
  188. void OLED_ShowNum(unsigned char  Line, unsigned char  Column, unsigned int  Number, unsigned char  Length)
  189. {
  190. 	unsigned char  i;
  191. 	for (i = 0; i < Length; i++)							
  192. 	{
  193. 		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(10, Length - i - 1) % 10 + '0');
  194. 	}
  195. }
  196.  
  197. /**
  198.   * @brief  OLED显示数字（十进制，带符号数）
  199.   * @param  Line 起始行位置，范围：1~4
  200.   * @param  Column 起始列位置，范围：1~16
  201.   * @param  Number 要显示的数字，范围：-2147483648~2147483647
  202.   * @param  Length 要显示数字的长度，范围：1~10
  203.   * @retval 无
  204.   */
  205. void OLED_ShowSignedNum(unsigned char  Line, unsigned char  Column, signed int  Number, unsigned char  Length)
  206. {
  207. 	unsigned char  i;
  208. 	unsigned int  Number1;
  209. 	if (Number >= 0)
  210. 	{
  211. 		OLED_ShowChar(Line, Column, '+');
  212. 		Number1 = Number;
  213. 	}
  214. 	else
  215. 	{
  216. 		OLED_ShowChar(Line, Column, '-');
  217. 		Number1 = -Number;
  218. 	}
  219. 	for (i = 0; i < Length; i++)							
  220. 	{
  221. 		OLED_ShowChar(Line, Column + i + 1, Number1 / OLED_Pow(10, Length - i - 1) % 10 + '0');
  222. 	}
  223. }
  224.  
  225. /**
  226.   * @brief  OLED显示数字（十六进制，正数）
  227.   * @param  Line 起始行位置，范围：1~4
  228.   * @param  Column 起始列位置，范围：1~16
  229.   * @param  Number 要显示的数字，范围：0~0xFFFFFFFF
  230.   * @param  Length 要显示数字的长度，范围：1~8
  231.   * @retval 无
  232.   */
  233. void OLED_ShowHexNum(unsigned char  Line, unsigned char  Column, unsigned int  Number, unsigned char  Length)
  234. {
  235. 	unsigned char  i, SingleNumber;
  236. 	for (i = 0; i < Length; i++)							
  237. 	{
  238. 		SingleNumber = Number / OLED_Pow(16, Length - i - 1) % 16;
  239. 		if (SingleNumber < 10)
  240. 		{
  241. 			OLED_ShowChar(Line, Column + i, SingleNumber + '0');
  242. 		}
  243. 		else
  244. 		{
  245. 			OLED_ShowChar(Line, Column + i, SingleNumber - 10 + 'A');
  246. 		}
  247. 	}
  248. }
  249.  
  250. /**
  251.   * @brief  OLED显示数字（二进制，正数）
  252.   * @param  Line 起始行位置，范围：1~4
  253.   * @param  Column 起始列位置，范围：1~16
  254.   * @param  Number 要显示的数字，范围：0~1111 1111 1111 1111
  255.   * @param  Length 要显示数字的长度，范围：1~16
  256.   * @retval 无
  257.   */
  258. void OLED_ShowBinNum(unsigned char  Line, unsigned char  Column, unsigned int  Number, unsigned char  Length)
  259. {
  260. 	unsigned char  i;
  261. 	for (i = 0; i < Length; i++)							
  262. 	{
  263. 		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(2, Length - i - 1) % 2 + '0');
  264. 	}
  265. }
  266.  
  267. /**
  268.   * @brief  OLED初始化
  269.   * @param  无
  270.   * @retval 无
  271.   */
  272. void OLED_Init(void)
  273. {
  274. 	unsigned int  i, j;
  275. 	
  276. 	for (i = 0; i < 1000; i++)			//上电延时
  277. 	{
  278. 		for (j = 0; j < 1000; j++);
  279. 	}
  280. 	
  281. 	OLED_I2C_Init();			//端口初始化
  282. 	
  283. 	OLED_WriteCommand(0xAE);	//关闭显示
  284. 	
  285. 	OLED_WriteCommand(0xD5);	//设置显示时钟分频比/振荡器频率
  286. 	OLED_WriteCommand(0x80);
  287. 	
  288. 	OLED_WriteCommand(0xA8);	//设置多路复用率
  289. 	OLED_WriteCommand(0x3F);
  290. 	
  291. 	OLED_WriteCommand(0xD3);	//设置显示偏移
  292. 	OLED_WriteCommand(0x00);
  293. 	
  294. 	OLED_WriteCommand(0x40);	//设置显示开始行
  295. 	
  296. 	OLED_WriteCommand(0xA1);	//设置左右方向，0xA1正常 0xA0左右反置
  297. 	
  298. 	OLED_WriteCommand(0xC8);	//设置上下方向，0xC8正常 0xC0上下反置
  299.  
  300. 	OLED_WriteCommand(0xDA);	//设置COM引脚硬件配置
  301. 	OLED_WriteCommand(0x12);
  302. 	
  303. 	OLED_WriteCommand(0x81);	//设置对比度控制
  304. 	OLED_WriteCommand(0xCF);
  305.  
  306. 	OLED_WriteCommand(0xD9);	//设置预充电周期
  307. 	OLED_WriteCommand(0xF1);
  308.  
  309. 	OLED_WriteCommand(0xDB);	//设置VCOMH取消选择级别
  310. 	OLED_WriteCommand(0x30);
  311.  
  312. 	OLED_WriteCommand(0xA4);	//设置整个显示打开/关闭
  313.  
  314. 	OLED_WriteCommand(0xA6);	//设置正常/倒转显示
  315.  
  316. 	OLED_WriteCommand(0x8D);	//设置充电泵
  317. 	OLED_WriteCommand(0x14);
  318.  
  319. 	OLED_WriteCommand(0xAF);	//开启显示
  320. 		
  321. 	OLED_Clear();				//OLED清屏
  322. }
  323.  
  324.  
  325. //			 OLED_ShowCN(1+i*16,0,i);
  326. //显示汉字 （x：横坐标  y：纵坐标  N：字数  S:字号）
  327. void OLED_ShowCN(unsigned char x,unsigned char y,unsigned char N)
  328. {
  329.     unsigned char wm=0;
  330. 	unsigned int addr;
  331. 	addr= 32*N;
  332. 	OLED_SetCursor(y,x);  //设置起始光标,起始光标的位置时先y后x，
  333.     for(wm=0;wm<16;wm++)
  334. 	{
  335. 		OLED_WriteData( font[addr]);
  336.         addr +=1;	
  337. 	}
  338. 	OLED_SetCursor(y+1,x);
  339.    for(wm=0;wm<16;wm++)
  340. 	{
  341. 		OLED_WriteData( font[addr]);
  342.         addr +=1;	
  343. 	}
  344. }
  345.  
  346.  
  347. // Parameters     : x0,y0 -- 起始点坐标(x0:0~127, y0:0~7); x1,y1 -- 起点对角线(结束点)的坐标(x1:1~128,y1:1~8)
  348. // Description    : 显示BMP位图
  349. void OLED_DrawBMP(unsigned char x0,unsigned char y0,unsigned char x1,unsigned char y1,unsigned char S)
  350. {
  351. 	unsigned int j=0;
  352. 	unsigned char x,y;
  353.  
  354.   if(y1%8==0)
  355. 		y = y1/8;
  356.   else
  357. 		y = y1/8 + 1;
  358. 	for(y=y0;y<y1;y++)
  359. 	{
  360. 		OLED_SetCursor(y,x0);
  361.     for(x=x0;x<x1;x++)
  362. 		{
  363. 			switch(S)
  364. 			{
  365. 				case 1:OLED_WriteData(gImage_init101[j++]);break;
  366. 				case 2:OLED_WriteData(gImage_init102[j++]);break;
  367. 				case 3:OLED_WriteData(gImage_init103[j++]);break;
  368. 				case 4:OLED_WriteData(gImage_init104[j++]);break;
  369. 				case 5:OLED_WriteData(gImage_init105[j++]);break;
  370. 				case 6:OLED_WriteData(gImage_init106[j++]);break;
  371. 				case 7:OLED_WriteData(gImage_init107[j++]);break;
  372. 				case 8:OLED_WriteData(gImage_init108[j++]);break;
  373. 				case 9:OLED_WriteData(gImage_init109[j++]);break;
  374. 				case 10:OLED_WriteData(gImage_init110[j++]);break;
  375. 				case 11:OLED_WriteData(gImage_init111[j++]);break;
  376. 				case 12:OLED_WriteData(gImage_init112[j++]);break;
  377. 				case 13:OLED_WriteData(gImage_init113[j++]);break;
  378. 				case 14:OLED_WriteData(gImage_init114[j++]);break;
  379. 				case 15:OLED_WriteData(gImage_init115[j++]);break;
  380. 				case 16:OLED_WriteData(gImage_init116[j++]);break;
  381. 				case 17:OLED_WriteData(gImage_init117[j++]);break;
  382. 				case 18:OLED_WriteData(gImage_init118[j++]);break;
  383. 				case 19:OLED_WriteData(gImage_init119[j++]);break;
  384. 				case 20:OLED_WriteData(gImage_init120[j++]);break;
  385. 				case 21:OLED_WriteData(gImage_init121[j++]);break;
  386. 				case 22:OLED_WriteData(gImage_init122[j++]);break;
  387. 				case 23:OLED_WriteData(gImage_init123[j++]);break;
  388. 				case 24:OLED_WriteData(gImage_init124[j++]);break;
  389. 				case 25:OLED_WriteData(gImage_init125[j++]);break;
  390. 			}
  391. 			
  392. 		}
  393. 	}
  394. }
  395.  
  396.  
  397. void OLED_DrawBMP1(unsigned char x0,unsigned char y0,unsigned char x1,unsigned char y1,unsigned char S)
  398. {
  399. 	unsigned int j=0;
  400. 	unsigned char x,y;
  401.  
  402.   if(y1%8==0)
  403. 		y = y1/8;
  404.   else
  405. 		y = y1/8 + 1;
  406. 	for(y=y0;y<y1;y++)
  407. 	{
  408. 		OLED_SetCursor(y,x0);
  409.     for(x=x0;x<x1;x++)
  410. 		{
  411. 			switch(S)
  412. 			{
  413. 				case 1:OLED_WriteData(gImage_IMG00000[j++]);break;
  414. 				case 2:OLED_WriteData(gImage_IMG00001[j++]);break;
  415. 				case 3:OLED_WriteData(gImage_IMG00002[j++]);break;
  416. 				case 4:OLED_WriteData(gImage_IMG00003[j++]);break;
  417. 				case 5:OLED_WriteData(gImage_IMG00004[j++]);break;
  418. 				case 6:OLED_WriteData(gImage_IMG00005[j++]);break;
  419. 				case 7:OLED_WriteData(gImage_IMG00006[j++]);break;
  420. 				case 8:OLED_WriteData(gImage_IMG00007[j++]);break;
  421. 				case 9:OLED_WriteData(gImage_IMG00008[j++]);break;
  422. 				case 10:OLED_WriteData(gImage_IMG00009[j++]);break;
  423. 				case 11:OLED_WriteData(gImage_IMG00010[j++]);break;
  424. 				case 12:OLED_WriteData(gImage_IMG00011[j++]);break;
  425. 				case 13:OLED_WriteData(gImage_IMG00012[j++]);break;
  426. 				case 14:OLED_WriteData(gImage_IMG00013[j++]);break;
  427. 				case 15:OLED_WriteData(gImage_IMG00014[j++]);break;
  428. 				case 16:OLED_WriteData(gImage_IMG00015[j++]);break;
  429. 				case 17:OLED_WriteData(gImage_IMG00016[j++]);break;
  430. 				case 18:OLED_WriteData(gImage_IMG00017[j++]);break;
  431. 				case 19:OLED_WriteData(gImage_IMG00018[j++]);break;
  432. 				case 20:OLED_WriteData(gImage_IMG00019[j++]);break;
  433. 				case 21:OLED_WriteData(gImage_IMG00020[j++]);break;
  434. 				case 22:OLED_WriteData(gImage_IMG00021[j++]);break;
  435. 				case 23:OLED_WriteData(gImage_IMG00022[j++]);break;
  436. 				case 24:OLED_WriteData(gImage_IMG00023[j++]);break;
  437. 				case 25:OLED_WriteData(gImage_IMG00024[j++]);break;
  438. 				case 26:OLED_WriteData(gImage_IMG00025[j++]);break;
  439. 				case 27:OLED_WriteData(gImage_IMG00026[j++]);break;
  440. 				case 28:OLED_WriteData(gImage_IMG00027[j++]);break;
  441. 				case 29:OLED_WriteData(gImage_IMG00028[j++]);break;
  442. 				case 30:OLED_WriteData(gImage_IMG00029[j++]);break;
  443. 				case 31:OLED_WriteData(gImage_IMG00030[j++]);break;
  444. 				case 32:OLED_WriteData(gImage_IMG00031[j++]);break;
  445. 				case 33:OLED_WriteData(gImage_IMG00032[j++]);break;
  446. 				case 34:OLED_WriteData(gImage_IMG00033[j++]);break;
  447. 				case 35:OLED_WriteData(gImage_IMG00034[j++]);break;
  448. 				case 36:OLED_WriteData(gImage_IMG00035[j++]);break;
  449. 			}
  450. 			
  451. 		}
  452. 	}
  453. }
  454.  
  455.

OLED.H文件、

  1. #ifndef __OLED_H
  2. #define __OLED_H
  3.  
  4. void OLED_Init(void);
  5. void OLED_Clear(void);
  6. void OLED_ShowChar(unsigned char  Line, unsigned char  Column, char Char);
  7. void OLED_ShowString(unsigned char  Line, unsigned char  Column, char *String);
  8. void OLED_ShowNum(unsigned char  Line, unsigned char  Column, unsigned int  Number, unsigned char  Length);
  9. void OLED_ShowSignedNum(unsigned char  Line, unsigned char  Column, signed int  Number, unsigned char  Length);
  10. void OLED_ShowHexNum(unsigned char  Line, unsigned char  Column, unsigned int  Number, unsigned char  Length);
  11. void OLED_ShowBinNum(unsigned char  Line, unsigned char  Column, unsigned int  Number, unsigned char  Length);
  12. void OLED_ShowCN(unsigned char x,unsigned char y,unsigned char N);
  13. void OLED_DrawBMP(unsigned char x0,unsigned char y0,unsigned char x1,unsigned char y1,unsigned char S);
  14. void OLED_DrawBMP1(unsigned char x0,unsigned char y0,unsigned char x1,unsigned char y1,unsigned char S);
  15.  
  16. #endif

 

字库文件太长了，不方便分享需要的话可以评论区私信我。

4. 完整的工程代码

这是本次的完整的工程代码文件，有需要的自取；

链接：https://pan.baidu.com/s/1jGXHAkab3jjR_Rd2WsBPcg?pwd=h8d5 
提取码：h8d5

第一次发文如果有不当的地方，欢迎指正。

码字不易，点个赞吧 =.=

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/553513
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号