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

STM32日历读取，设置和输出——实时时钟RTC_rtc输出

作者：Guff_9hys | 2024-08-01 07:01:25

赞

踩

rtc输出

目录

一、问题导出

二、 RTC简介

2.1、RTC介绍：

 2.2、RTC特征：

 2.3、RTC原理框图：

 2.4、RTC结构：

2.5、RTC具体流程：

2.6、RTC时钟选择：

 2.7、RTC复位过程：

 2.8、RTC中断：

三、搭建STM32开发环境（HAL库环境）

四、利用HAL库新建第一小问的工程 （串口显示工程）

五、完善 keil5工程

六、第一小问工程烧录运行 

七、利用库函数搭建第二小问工程（OLED显示工程）

1、关于如何搭建STM32库函数环境与库函数工程：

2、完善keil5工程--->编写工程代码：

 八、第二小问的电路连接

九、第二小问库函数工程烧录运行

十、总结

十一、参考资料

一、问题导出

       阅读资料了解 STM32F103的RTC（实时时钟）原理，使用带SPI或IIC接口的OLED屏显模块实现以下功能：

1) 读取STM32F103C8T6 内部的时钟(年月日时分秒)，日历(星期x），1秒周期，通过串口输出到PC上位机，；

2) 读取AHT20的温度和湿度，通过OLED，把年月份时分秒、日历和实时温度、湿度显示出来，2秒周期。

二、 RTC简介

2.1、RTC介绍：

       RTC (Real Time Clock)：实时时钟。RTC是个独立的定时器。RTC模块拥有一个连续计数的计数器，在相应的软件配置下，可以提供时钟日历的功能。修改计数器的值可以重新设置当前时间和日期 RTC还包含用于管理低功耗模式的自动唤醒单元。

       在断电情况下 RTC仍可以独立运行 只要芯片的备用电源一直供电,RTC上的时间会一直走。RTC实质是一个掉电后还继续运行的定时器,从定时器的角度来看,相对于通用定时器TIM外设,它的功能十分简单,只有计时功能(也可以触发中断)。但其高级指出也就在于掉电之后还可以正常运行。

       两个 32 位寄存器包含二进码十进数格式 (BCD) 的秒、分钟、小时（ 12 或 24 小时制）、星期几、日期、月份和年份。此外，还可提供二进制格式的亚秒值。系统可以自动将月份的天数补偿为 28、29（闰年）、30 和 31 天。

     上电复位后，所有RTC寄存器都会受到保护，以防止可能的非正常写访问。无论器件状态如何（运行模式、低功耗模式或处于复位状态），只要电源电压保持在工作范围内，RTC使不会停止工作。

 2.2、RTC特征：

  • 可编程的预分频系数：分频系数高为220。

  • 32位的可编程计数器，可用于较长时间段的测量。

  • 2个分离的时钟：用于APB1接口的PCLK1和RTC时钟(RTC时钟的频率必须小于PCLK1时钟 频率的四分之一以上)。

  • 可以选择以下三种RTC的时钟源：

    • HSE时钟除以128；
    • LSE振荡器时钟；
    • SI振荡器时钟

  • 2个独立的复位类型：

    • APB1接口由系统复位；
    • RTC核心(预分频器、闹钟、计数器和分频器)只能由后备域复位

  • 3个专门的可屏蔽中断：

    • 1.闹钟中断，用来产生一个软件可编程的闹钟中断
    • 2.秒中断，用来产生一个可编程的周期性中断信号(长可达1秒)。
    • 3.溢出中断，指示内部可编程计数器溢出并回转为0的状态。

  • RTC时钟源：
    三种不同的时钟源可被用来驱动系统时钟(SYSCLK)：

    • HSI振荡器时钟
    • HSE振荡器时钟
    • PLL时钟

  • 这些设备有以下2种二级时钟源：

    • 40kHz低速内部RC，可以用于驱动独立看门狗和通过程序选择驱动RTC。 RTC用于从停机/待机模式下自动唤醒系统。
    • 32.768kHz低速外部晶体也可用来通过程序选择驱动RTC(RTCCLK)。

 2.3、RTC原理框图：

RTC时钟的框图是比较简单的，这里我们把他分成 两个部分:

（1）APB1 接口： 用来和 APB1 总线相连。 此单元还包含一组 16 位寄存器，可通过 APB1 总线对其进行读写操作。APB1 接口由 APB1 总 线时钟驱动，用来与 APB1 总线连接。通过APB1接口可以访问RTC的相关寄存器（预分频值，计数器值，闹钟值）。

（2）RTC 核心接口：由一组可编程计数器组成，分成 两个主要模块 ：

——第一个模块是 RTC 的 预分频模块 ，它可编程产生 1 秒的 RTC 时间基准 TR_CLK。RTC 的预分频模块包含了一个 20 位的可编程分频器(RTC 预分频器)。如果在 RTC_CR 寄存器中设置了相应的允许位，则在每个 TR_CLK 周期中 RTC 产生一个中断(秒中断)。

——第二个模块是一个 32 位的可编程计数器 （RTC_CNT），可被初始化为当前的系统时间，一个 32 位的时钟计数器，按秒钟计算，可以记 录 4294967296 秒，约合 136 年左右，作为一般应用，这已经是足够了的。 

 2.4、RTC结构：

 RTC时钟主要由两个内部低速时钟和一个外部高速时钟构成。基本结构如下：

硬件电路原理图如下 ：  

       RTC（Real Time Clock）实时时钟是一种高精度、低功耗的定时器，它可以在各种环境下提供精确的时间和日期信息。即使在系统处于低功耗模式时，RTC也可以继续运行，确保时间的连续性。此外，它还支持时钟校准功能，可以校正时钟的偏差，保证时间的准确性。 除了基本的时间提供功能，RTC还具有报警功能，用户可以设置报警功能，当达到指定时间时触发中断，这在实际应用中非常有用。例如，可以在系统到达预定维护时间时触发警报，提醒用户进行维护操作。

       另外，RTC还支持外部电池备份，用户可以使用外部电池进行时间备份，即使在断电的情况下也能保持时间的准确。这一特性使得RTC在某些应用场景下特别适用，例如在应急照明系统、安全监控系统等需要持续、准确计时的情况下。

      RTC还具有自动唤醒功能，用户可以根据需要设置自动唤醒条件，当满足预设条件时自动唤醒系统。这一功能在许多嵌入式系统和物联网设备中非常有用，可以大大降低系统的功耗。

2.5、RTC具体流程：

      RTCCLK经过RTC_DIV预分频，RTC_PRL设置预分频系数，然后得到TR_CLK时钟信号，我们一般设置其周期为1s，RTC_CNT计数器计数，假如1970设置为时间起点为0s，通过当前时间的秒数计算得到当前的时间。RTC_ALR是设置闹钟时间，RTC_CNT计数到RTC_ALR就会产生计数中断。RTC_Second为秒中断，用于刷新时间；RTC_Overflow是溢出中断；RTC Alarm 控制开关机。

2.6、RTC时钟选择：

       使用HSE分频时钟或者LSI的时候,在主电源VDD掉电的情况下,这两个时钟来源都会受到影响,因此没法保证RTC正常工作.所以RTC一般都时钟低速外部时钟LSE,频率为实时时钟模块中常用的32.768KHz,因为32768 = 2^15,分频容易实现,所以被广泛应用到RTC模块.(在主电源VDD有效的情况下待机,RTC还可以配置闹钟事件使STM32退出待机模式)。

 2.7、RTC复位过程：

       除了RTC_PRL、RTC_ALR、RTC_CNT和RTC_DIV寄存器外，所有的系统寄存器都由系统复位或电源复位进行异步复位。RTC_PRL、RTC_ALR、RTC_CNT和RTC_DIV寄存器仅能通过备份域复位信号复位。系统复位后,禁止访问后备寄存器和RCT,防止对后卫区域(BKP)的意外写操作。

 2.8、RTC中断：

（1）秒中断：
       这里时钟自带一个秒中断，每当计数加一的时候就会触发一次秒中断，。注意，这里所说的秒中断并非一定是一秒的时间，它是由RTC时钟源和分频值决定的“秒”的时间，当然也是可以做到1秒钟中断一次。我们通过往秒中断里写更新时间的函数来达到时间同步的效果

（2）闹钟中断：
      闹钟中断就是设置一个预设定的值，计数每自加多少次触发一次闹钟中断

三、搭建STM32开发环境（HAL库环境）

 请参考我的这篇博客：STM32使用HAL库点亮流水灯-CSDN博客

四、利用HAL库新建第一小问的工程 （串口显示工程）

（1）打开STM32CubeMX，在主界面点击：ACCESS TO MCU SELECTOR:

（2）选择的单片机型号以及点击开始工程项目：  

（3）点击system core，进入SYS，在debug下选择serial wire： 

（4）配置RCC，（设置高速外部时钟，使能外部晶振LSE）：

（5）配置RTC（激活时钟源(Activate Clock Source)和日历(Activate Calendar)），进入RTC，设置时间为创建时间2023/11/15/ 17:14：

接着：

 （6）配置USART1，我们使用USART1进行数据传输：

 （7）进入CLK Configuration (时钟配置)中，进行时钟配置 ：

（8）进入Project Manager(工程管理)，进行工程设置点击生成工程与代码。注意：路径不能包含中文和空格，不然生成的工程文件无法在Keil中打开：

五、完善 keil5工程

1、头文件添加#include “stdio.h”：
在这里插入图片描述

2、在main.c文件中重写fputc函数，完成printf函数的重定向：

  1. //添加头文件#include "stdio.h"
  2. int fputc(int ch,FILE *f){
  3.  uint8_t temp[1]={ch};
  4.  HAL_UART_Transmit(&huart1,temp,1,2);
  5.  return ch;
  6. }

3、在main.c中定义时间和日期的结构体用来获取时间和日期：

  1. RTC_DateTypeDef GetData;  //获取日期结构体
  2.  
  3. RTC_TimeTypeDef GetTime;   //获取时间结构体

4、在main函数中while循环里面添加如下代码即可：

  1. /* Get the RTC current Time */
  2. 	    HAL_RTC_GetTime(&hrtc, &GetTime, RTC_FORMAT_BIN);
  3.       /* Get the RTC current Date */
  4.       HAL_RTC_GetDate(&hrtc, &GetData, RTC_FORMAT_BIN);
  5.  
  6.       /* Display date Format : yy/mm/dd */
  7.       printf("%02d/%02d/%02d\r\n",2000 + GetData.Year, GetData.Month, GetData.Date);
  8. 	  /* Display date Format : weekday */
  9. 		if(GetData.WeekDay==1){
  10. 			printf("星期一\r\n");
  11. 		}else if(GetData.WeekDay==2){
  12. 			printf("星期二\r\n");
  13. 		}else if(GetData.WeekDay==3){
  14. 			printf("星期三\r\n");
  15. 		}else if(GetData.WeekDay==4){
  16. 			printf("星期四\r\n");
  17. 		}else if(GetData.WeekDay==5){
  18. 			printf("星期五\r\n");
  19. 		}else if(GetData.WeekDay==6){
  20. 			printf("星期六\r\n");
  21. 		}else if(GetData.WeekDay==7){
  22. 			printf("星期日\r\n");
  23. 		}
  24.  
  25.       /* Display time Format : hh:mm:ss */
  26.       printf("%02d:%02d:%02d\r\n",GetTime.Hours, GetTime.Minutes, GetTime.Seconds);
  27.  
  28.       printf("\r\n");
  29.  
  30.       HAL_Delay(1000);

5、因为我们在代码里面重写了printf，所以在Target里面一定要勾选上Use MiscroLiB：

六、第一小问工程烧录运行 

1、USB转TTL与STM32的连线，以及电脑上配置CH340等等烧录环境，请参考我的这篇博客：

STM32使用HAL库中断控制串口通信-CSDN博客

2、编译与烧录，如何通过USB转TTL烧录进STM32中，也参考我的同一篇博客：

STM32使用HAL库中断控制串口通信-CSDN博客

3、工程运行结果展示：

七、利用库函数搭建第二小问工程（OLED显示工程）

1、关于如何搭建STM32库函数环境与库函数工程：

请参考我的这篇博客：

基于标准外设库的LED流水灯-CSDN博客

2、完善keil5工程--->编写工程代码：

（1）提醒：

        关于如何在keil里面通过库函数创建并且编写C文件与H文件，以及把它们都导入进库函数keil5工程中，还是参考我的这篇博客：基于标准外设库的LED流水灯-CSDN博客

（2）编写工程需要的文件代码：

（1：sys.h与sys.c文件代码编写：
sys.h:

  1. #ifndef __SYS_H
  2. #define __SYS_H	
  3. #include "stm32f10x.h"
  4. //	 
  5.  
  6.  
  7. //STM32F103o?D?°?ày3ì
  8. //?aoˉêy°?±?ày3ì
  9. /********** mcudev.taobao.com 3??·  ********/
  10.  
  11.  
  12.  
  13. // 	 
  14.  
  15. //0,2??§3?ucos
  16. //1,?§3?ucos
  17. #define SYSTEM_SUPPORT_UCOS		0		//?¨ò??μí3???t?Dê?·??§3?UCOS
  18. 																	    
  19. 	 
  20. //??′?2ù×÷,êμ??51àà??μ?GPIO????1|?ü
  21. //??ì?êμ??????,2???<<CM3è¨ít????>>μú????(87ò3~92ò3).
  22. //IO?ú2ù×÷oê?¨ò?
  23. #define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
  24. #define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
  25. #define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum)) 
  26. //IO?úμ??·ó3é?
  27. #define GPIOA_ODR_Addr    (GPIOA_BASE+12) //0x4001080C 
  28. #define GPIOB_ODR_Addr    (GPIOB_BASE+12) //0x40010C0C 
  29. #define GPIOC_ODR_Addr    (GPIOC_BASE+12) //0x4001100C 
  30. #define GPIOD_ODR_Addr    (GPIOD_BASE+12) //0x4001140C 
  31. #define GPIOE_ODR_Addr    (GPIOE_BASE+12) //0x4001180C 
  32. #define GPIOF_ODR_Addr    (GPIOF_BASE+12) //0x40011A0C    
  33. #define GPIOG_ODR_Addr    (GPIOG_BASE+12) //0x40011E0C    
  34.  
  35. #define GPIOA_IDR_Addr    (GPIOA_BASE+8) //0x40010808 
  36. #define GPIOB_IDR_Addr    (GPIOB_BASE+8) //0x40010C08 
  37. #define GPIOC_IDR_Addr    (GPIOC_BASE+8) //0x40011008 
  38. #define GPIOD_IDR_Addr    (GPIOD_BASE+8) //0x40011408 
  39. #define GPIOE_IDR_Addr    (GPIOE_BASE+8) //0x40011808 
  40. #define GPIOF_IDR_Addr    (GPIOF_BASE+8) //0x40011A08 
  41. #define GPIOG_IDR_Addr    (GPIOG_BASE+8) //0x40011E08 
  42.  
  43. //IO?ú2ù×÷,????μ￥ò?μ?IO?ú!
  44. //è·±￡nμ??μD?óú16!
  45. #define PAout(n)   BIT_ADDR(GPIOA_ODR_Addr,n)  //ê?3? 
  46. #define PAin(n)    BIT_ADDR(GPIOA_IDR_Addr,n)  //ê?è? 
  47.  
  48. #define PBout(n)   BIT_ADDR(GPIOB_ODR_Addr,n)  //ê?3? 
  49. #define PBin(n)    BIT_ADDR(GPIOB_IDR_Addr,n)  //ê?è? 
  50.  
  51. #define PCout(n)   BIT_ADDR(GPIOC_ODR_Addr,n)  //ê?3? 
  52. #define PCin(n)    BIT_ADDR(GPIOC_IDR_Addr,n)  //ê?è? 
  53.  
  54. #define PDout(n)   BIT_ADDR(GPIOD_ODR_Addr,n)  //ê?3? 
  55. #define PDin(n)    BIT_ADDR(GPIOD_IDR_Addr,n)  //ê?è? 
  56.  
  57. #define PEout(n)   BIT_ADDR(GPIOE_ODR_Addr,n)  //ê?3? 
  58. #define PEin(n)    BIT_ADDR(GPIOE_IDR_Addr,n)  //ê?è?
  59.  
  60. #define PFout(n)   BIT_ADDR(GPIOF_ODR_Addr,n)  //ê?3? 
  61. #define PFin(n)    BIT_ADDR(GPIOF_IDR_Addr,n)  //ê?è?
  62.  
  63. #define PGout(n)   BIT_ADDR(GPIOG_ODR_Addr,n)  //ê?3? 
  64. #define PGin(n)    BIT_ADDR(GPIOG_IDR_Addr,n)  //ê?è?
  65.  
  66.  
  67.  
  68. void NVIC_Configuration(void);
  69.  
  70.  
  71.  
  72. #endif
  73.

 sys.c:

  1. #include "sys.h"
  2.  
  3.  
  4. //STM32F103o?D?°?ày3ì
  5. //?aoˉêy°?±?ày3ì
  6. /********** mcudev.taobao.com 3??·  ********/
  7.  
  8. //	 
  9.  
  10. //STM32?a·￠°?
  11. //?μí3?D??·?×ééè???ˉ		   
  12.  
  13. //********************************************************************************  
  14. void NVIC_Configuration(void)
  15. {
  16.  
  17.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);	//éè??NVIC?D??·?×é2:2???à??ó??è??￡?2???ìó|ó??è??
  18.  
  19. }
  20.

(2:Timer.h与Timer.c文件编写:

Timer.h:

  1. #ifndef __TIMER_H
  2. #define __TIMER_H
  3.  
  4. void Timer_Init(void);
  5.  
  6. #endif

Timer.c:

  1. #include "stm32f10x.h"                  // Device header
  2.  
  3.  
  4. TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
  5. NVIC_InitTypeDef NVIC_InitStructure;
  6. void Timer_Init(void)
  7. {
  8. 	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  9. 	
  10. 	TIM_InternalClockConfig(TIM2);
  11. 	
  12.  
  13. 	TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
  14. 	TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
  15. 	TIM_TimeBaseInitStructure.TIM_Period = 10000 - 1;
  16. 	TIM_TimeBaseInitStructure.TIM_Prescaler = 3600 - 1;
  17. 	TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
  18. 	TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure);
  19. 	
  20. 	TIM_ClearFlag(TIM2, TIM_FLAG_Update);
  21. 	TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
  22. 	
  23. 	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  24. 	
  25. 	
  26. 	NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
  27. 	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  28. 	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
  29. 	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  30. 	NVIC_Init(&NVIC_InitStructure);
  31. 	
  32. 	TIM_Cmd(TIM2, ENABLE);
  33. }
  34.  
  35. /*
  36. void TIM2_IRQHandler(void)
  37. {
  38. 	if (TIM_GetITStatus(TIM2, TIM_IT_Update) == SET)
  39. 	{
  40. 		
  41. 		TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
  42. 	}
  43. }
  44. */

(3:MyRTC.h与MyRTC.c文件编写:

MyRTC.h:

  1. #ifndef __MYRTC_H
  2. #define __MYRTC_H
  3.  
  4. extern uint16_t MyRTC_Time[];
  5.  
  6. void MyRTC_Init(void);
  7. void MyRTC_SetTime(void);
  8. void MyRTC_ReadTime(void);
  9.  
  10. #endif

MyRTC.c:

  1. #include "stm32f10x.h"                  // Device header
  2. #include <time.h>
  3. #include "OLED.h"
  4. #include "delay.h"
  5.  
  6. uint16_t MyRTC_Time[] = {2023, 11, 21, 21, 51, 05};
  7.  
  8. void MyRTC_SetTime(void);
  9.  
  10.  
  11. char* weekday;
  12. uint16_t iWeek;
  13.  
  14. void CalculateWeekDay(uint16_t year, uint16_t month, uint16_t day) {
  15. 	if (month == 1 || month ==2) 
  16.     {
  17.         month +=12;
  18.         year--;
  19.     }
  20. 	iWeek = (day + 2 * month + 3 * (month + 1)/5 + year + year/4 - year/100 + year/400) % 7;
  21. 	switch (iWeek)
  22.     {
  23. 		case 0: weekday = "Monday"; break;
  24.      	case 1: weekday = "Teusday"; break;
  25.      	case 2: weekday = "Wednesday"; break;
  26.      	case 3: weekday = "Thursday"; break;
  27.      	case 4: weekday = "Friday"; break;
  28.      	case 5: weekday = "Saturday"; break;
  29.      	case 6: weekday = "Sunday"; break;
  30. 	}
  31. }
  32.  
  33.  
  34.  
  35. void MyRTC_Init(void)
  36. {
  37. 	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
  38. 	RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP, ENABLE);
  39. 	
  40. 	PWR_BackupAccessCmd(ENABLE);
  41. 	
  42. 	if (BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
  43. 	{
  44. 		RCC_LSEConfig(RCC_LSE_ON);
  45. 		while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) != SET);
  46. 		
  47. 		RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
  48. 		RCC_RTCCLKCmd(ENABLE);
  49. 		
  50. 		RTC_WaitForSynchro();
  51. 		RTC_WaitForLastTask();
  52. 		
  53. 		RTC_SetPrescaler(32768 - 1);
  54. 		RTC_WaitForLastTask();
  55. 		
  56. 		MyRTC_SetTime();
  57. 		
  58. 		BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
  59. 	}
  60. 	else
  61. 	{
  62. 		RTC_WaitForSynchro();
  63. 		RTC_WaitForLastTask();
  64. 	}
  65. }
  66.  
  67. //如果LSE无法起振导致程序卡死在初始化函数中
  68. //可将初始化函数替换为下述代码，使用LSI当作RTCCLK
  69. //LSI无法由备用电源供电，故主电源掉电时，RTC走时会暂停
  70. /* 
  71. void MyRTC_Init(void)
  72. {
  73. 	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
  74. 	RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP, ENABLE);
  75. 	
  76. 	PWR_BackupAccessCmd(ENABLE);
  77. 	
  78. 	if (BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
  79. 	{
  80. 		RCC_LSICmd(ENABLE);
  81. 		while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) != SET);
  82. 		
  83. 		RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
  84. 		RCC_RTCCLKCmd(ENABLE);
  85. 		
  86. 		RTC_WaitForSynchro();
  87. 		RTC_WaitForLastTask();
  88. 		
  89. 		RTC_SetPrescaler(40000 - 1);
  90. 		RTC_WaitForLastTask();
  91. 		
  92. 		MyRTC_SetTime();
  93. 		
  94. 		BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
  95. 	}
  96. 	else
  97. 	{
  98. 		RCC_LSICmd(ENABLE);
  99. 		while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) != SET);
  100. 		
  101. 		RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
  102. 		RCC_RTCCLKCmd(ENABLE);
  103. 		
  104. 		RTC_WaitForSynchro();
  105. 		RTC_WaitForLastTask();
  106. 	}
  107. }*/
  108.  
  109. void MyRTC_SetTime(void)
  110. {
  111. 	time_t time_cnt;
  112. 	struct tm time_date;
  113. 	
  114. 	time_date.tm_year = MyRTC_Time[0] - 1900;
  115. 	time_date.tm_mon = MyRTC_Time[1] - 1;
  116. 	time_date.tm_mday = MyRTC_Time[2];
  117. 	time_date.tm_hour = MyRTC_Time[3];
  118. 	time_date.tm_min = MyRTC_Time[4];
  119. 	time_date.tm_sec = MyRTC_Time[5];
  120. 	
  121. 	time_cnt = mktime(&time_date) - 8 * 60 * 60;
  122. 	
  123. 	RTC_SetCounter(time_cnt);
  124. 	RTC_WaitForLastTask();
  125. }
  126.  
  127. void MyRTC_ReadTime(void)
  128. {
  129. 	time_t time_cnt;
  130. 	struct tm time_date;
  131. 	
  132. 	time_cnt = RTC_GetCounter() + 8 * 60 * 60;//
  133. 	
  134. 	time_date = *localtime(&time_cnt);
  135. 	
  136. 	MyRTC_Time[0] = time_date.tm_year + 1900;
  137. 	MyRTC_Time[1] = time_date.tm_mon + 1;
  138. 	MyRTC_Time[2] = time_date.tm_mday;
  139. 	MyRTC_Time[3] = time_date.tm_hour;
  140. 	MyRTC_Time[4] = time_date.tm_min;
  141. 	MyRTC_Time[5] = time_date.tm_sec;
  142. 	
  143. 	CalculateWeekDay(MyRTC_Time[0], MyRTC_Time[1], MyRTC_Time[2]);
  144. 	
  145. 	//delay_ms(10);
  146. 	OLED_ShowNum(3, 1, MyRTC_Time[0], 4);
  147. 	OLED_ShowChar(3, 5, '-');
  148. 	OLED_ShowNum(3, 6, MyRTC_Time[1], 2);
  149. 	OLED_ShowChar(3, 8, '-');
  150. 	OLED_ShowNum(3, 9, MyRTC_Time[2], 2);
  151. 	
  152. 	OLED_ShowNum(4, 1, MyRTC_Time[3], 2);
  153. 	OLED_ShowChar(4, 3, ':');
  154. 	OLED_ShowNum(4, 4, MyRTC_Time[4], 2);
  155. 	OLED_ShowChar(4, 6, ':');
  156. 	OLED_ShowNum(4, 7, MyRTC_Time[5], 2);
  157. 	
  158. 	OLED_ShowString(4, 10, weekday);
  159.  
  160. }

 (4:OLED.h与OLED.c文件编写:

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(uint8_t Line, uint8_t Column, char Char);
  7. void OLED_ShowString(uint8_t Line, uint8_t Column, char *String);
  8. void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
  9. void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length);
  10. void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
  11. void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
  12.  
  13. #endif

OLED.c:

  1. #include "bsp_i2c.h"
  2. #include "delay.h"
  3. #include "OLED.h"
  4.  
  5. uint8_t   ack_status=0;
  6. uint8_t   readByte[6];
  7. uint8_t   AHT20_status=0;
  8.  
  9. uint32_t  H1=0;  //Humility
  10. uint32_t  T1=0;  //Temperature
  11.  
  12. uint8_t  AHT20_OutData[4];
  13. uint8_t  AHT20sendOutData[10] = {0xFA, 0x06, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF};
  14.  
  15. void IIC_Init(void)
  16. {					     
  17. 	GPIO_InitTypeDef GPIO_InitStructure;
  18. 	RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	
  19. 	   
  20. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
  21. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //í?íìê?3?
  22. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  23. 	GPIO_Init(GPIOB, &GPIO_InitStructure);
  24.  
  25. 	IIC_SCL=1;
  26. 	IIC_SDA=1;
  27.  
  28. }
  29. //2úéúIIC?eê?D?o?
  30. void IIC_Start(void)
  31. {
  32. 	SDA_OUT();     //sda??ê?3?
  33. 	IIC_SDA=1;	  	  
  34. 	IIC_SCL=1;
  35. 	delay_us(4);
  36.  	IIC_SDA=0;//START:when CLK is high,DATA change form high to low 
  37. 	delay_us(4);
  38. 	IIC_SCL=0;//?ˉ×?I2C×ü??￡?×?±?·￠?í?ò?óê?êy?Y 
  39. }	  
  40. //2úéúIICí￡?1D?o?
  41. void IIC_Stop(void)
  42. {
  43. 	SDA_OUT();//sda??ê?3?
  44. 	IIC_SCL=0;
  45. 	IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
  46.  	delay_us(4);
  47. 	IIC_SCL=1; 
  48. 	IIC_SDA=1;//·￠?íI2C×ü???áê?D?o?
  49. 	delay_us(4);							   	
  50. }
  51. //μè′yó|′eD?o?μ?à′
  52. //·μ???μ￡o1￡??óê?ó|′e꧰ü
  53. //        0￡??óê?ó|′e3é1|
  54. u8 IIC_Wait_Ack(void)
  55. {
  56. 	u8 ucErrTime=0;
  57. 	SDA_IN();      //SDAéè???aê?è?  
  58. 	IIC_SDA=1;delay_us(1);	   
  59. 	IIC_SCL=1;delay_us(1);	 
  60. 	while(READ_SDA)
  61. 	{
  62. 		ucErrTime++;
  63. 		if(ucErrTime>250)
  64. 		{
  65. 			IIC_Stop();
  66. 			return 1;
  67. 		}
  68. 	}
  69. 	IIC_SCL=0;//ê±?óê?3?0 	   
  70. 	return 0;  
  71. } 
  72. //2úéúACKó|′e
  73. void IIC_Ack(void)
  74. {
  75. 	IIC_SCL=0;
  76. 	SDA_OUT();
  77. 	IIC_SDA=0;
  78. 	delay_us(2);
  79. 	IIC_SCL=1;
  80. 	delay_us(2);
  81. 	IIC_SCL=0;
  82. }
  83. //2?2úéúACKó|′e		    
  84. void IIC_NAck(void)
  85. {
  86. 	IIC_SCL=0;
  87. 	SDA_OUT();
  88. 	IIC_SDA=1;
  89. 	delay_us(2);
  90. 	IIC_SCL=1;
  91. 	delay_us(2);
  92. 	IIC_SCL=0;
  93. }					 				     
  94. //IIC·￠?íò???×??ú
  95. //·μ??′ó?úóD?Tó|′e
  96. //1￡?óDó|′e
  97. //0￡??Tó|′e			  
  98. void IIC_Send_Byte(u8 txd)
  99. {                        
  100.     u8 t;   
  101. 		SDA_OUT(); 	    
  102.     IIC_SCL=0;//à-μíê±?ó?aê?êy?Y′?ê?
  103.     for(t=0;t<8;t++)
  104.     {              
  105.         IIC_SDA=(txd&0x80)>>7;
  106.         txd<<=1; 	  
  107. 		delay_us(2);   //??TEA5767?aèy???óê±??ê?±?D?μ?
  108. 		IIC_SCL=1;
  109. 		delay_us(2); 
  110. 		IIC_SCL=0;	
  111. 		delay_us(2);
  112.     }	 
  113. } 	    
  114. //?á1??×??ú￡?ack=1ê±￡?·￠?íACK￡?ack=0￡?·￠?ínACK   
  115. u8 IIC_Read_Byte(unsigned char ack)
  116. {
  117. 	unsigned char i,receive=0;
  118. 	SDA_IN();//SDAéè???aê?è?
  119.   for(i=0;i<8;i++ )
  120. 	{
  121.     IIC_SCL=0; 
  122.     delay_us(2);
  123. 		IIC_SCL=1;
  124.     receive<<=1;
  125.     if(READ_SDA)receive++;   
  126. 		delay_us(1); 
  127.   }					 
  128. 	if (!ack)
  129. 			IIC_NAck();//·￠?ínACK
  130. 	else
  131. 			IIC_Ack(); //·￠?íACK   
  132. 	return receive;
  133. }
  134.  
  135. void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr)
  136. {
  137. 	IIC_Start();  
  138. 	
  139. 	if(device_addr==0xA0) //eepromμ??·′óóú1×??ú
  140. 		IIC_Send_Byte(0xA0 + ((addr/256)<<1));//·￠?í??μ??·
  141. 	else
  142. 		IIC_Send_Byte(device_addr);	    //·￠?÷?tμ??·
  143. 	IIC_Wait_Ack(); 
  144. 	IIC_Send_Byte(addr&0xFF);   //·￠?íμíμ??·
  145. 	IIC_Wait_Ack(); 
  146. 	IIC_Send_Byte(data);     //·￠?í×??ú							   
  147. 	IIC_Wait_Ack();  		    	   
  148.   IIC_Stop();//2úéúò???í￡?1ì??t 
  149. 	if(device_addr==0xA0) //
  150. 		delay_ms(10);
  151. 	else
  152. 		delay_us(2);
  153. }
  154.  
  155. uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead)  //?á??′??÷?ò?áêy?Y
  156. {	
  157. 		uint16_t data;
  158. 		IIC_Start();  
  159. 		if(device_addr==0xA0)
  160. 			IIC_Send_Byte(0xA0 + ((addr/256)<<1));
  161. 		else
  162. 			IIC_Send_Byte(device_addr);	
  163. 		IIC_Wait_Ack();
  164. 		IIC_Send_Byte(addr&0xFF);   //·￠?íμíμ??·
  165. 		IIC_Wait_Ack(); 
  166.  
  167. 		IIC_Start();  	
  168. 		IIC_Send_Byte(device_addr+1);	    //·￠?÷?tμ??·
  169. 		IIC_Wait_Ack();
  170. 		if(ByteNumToRead == 1)//LM75???èêy?Y?a11bit
  171. 		{
  172. 			data=IIC_Read_Byte(0);
  173. 		}
  174. 		else
  175. 			{
  176. 				data=IIC_Read_Byte(1);
  177. 				data=(data<<8)+IIC_Read_Byte(0);
  178. 			}
  179. 		IIC_Stop();//2úéúò???í￡?1ì??t	    
  180. 		return data;
  181. }
  182.  
  183.  
  184. /**********
  185. *é???2?·??aIO?ú?￡?éI2C????
  186. *
  187. *′ó?aò????aê??aAHT20μ?????I2C
  188. *oˉêy??óDIICoíI2Cμ???±e￡???×￠òa￡?￡?￡?￡?￡?
  189. *
  190. *2020/2/23×?oóDT??è??ú
  191. *
  192. ***********/
  193. void  read_AHT20_once(void)
  194. {
  195. 	//delay_ms(10);
  196.  
  197. 	reset_AHT20();
  198. 	delay_ms(5);
  199.  
  200. 	init_AHT20();
  201. 	delay_ms(5);
  202.  
  203. 	startMeasure_AHT20();
  204. 	delay_ms(50);
  205.  
  206. 	read_AHT20();
  207. 	//delay_ms(5);
  208. }
  209.  
  210.  
  211. void  reset_AHT20(void)
  212. {
  213.  
  214. 	I2C_Start();
  215.  
  216. 	I2C_WriteByte(0x70);
  217. 	ack_status = Receive_ACK();
  218. 	if(ack_status) printf("1");
  219. 	else printf("1-n-");
  220. 	I2C_WriteByte(0xBA);
  221. 	ack_status = Receive_ACK();
  222. 		if(ack_status) printf("2");
  223. 	else printf("2-n-");
  224. 	I2C_Stop();
  225.  
  226. 	/*
  227. 	AHT20_OutData[0] = 0;
  228. 	AHT20_OutData[1] = 0;
  229. 	AHT20_OutData[2] = 0;
  230. 	AHT20_OutData[3] = 0;
  231. 	*/
  232. }
  233.  
  234.  
  235.  
  236. void  init_AHT20(void)
  237. {
  238. 	I2C_Start();
  239.  
  240. 	I2C_WriteByte(0x70);
  241. 	ack_status = Receive_ACK();
  242. 	if(ack_status) printf("3");
  243. 	else printf("3-n-");	
  244. 	I2C_WriteByte(0xE1);
  245. 	ack_status = Receive_ACK();
  246. 	if(ack_status) printf("4");
  247. 	else printf("4-n-");
  248. 	I2C_WriteByte(0x08);
  249. 	ack_status = Receive_ACK();
  250. 	if(ack_status) printf("5");
  251. 	else printf("5-n-");
  252. 	I2C_WriteByte(0x00);
  253. 	ack_status = Receive_ACK();
  254. 	if(ack_status) printf("6");
  255. 	else printf("6-n-");
  256. 	I2C_Stop();
  257. }
  258.  
  259.  
  260.  
  261. void  startMeasure_AHT20(void)
  262. {
  263. 	//------------
  264. 	I2C_Start();
  265.  
  266. 	I2C_WriteByte(0x70);
  267. 	ack_status = Receive_ACK();
  268. 	if(ack_status) printf("7");
  269. 	else printf("7-n-");
  270. 	I2C_WriteByte(0xAC);
  271. 	ack_status = Receive_ACK();
  272. 	if(ack_status) printf("8");
  273. 	else printf("8-n-");
  274. 	I2C_WriteByte(0x33);
  275. 	ack_status = Receive_ACK();
  276. 	if(ack_status) printf("9");
  277. 	else printf("9-n-");
  278. 	I2C_WriteByte(0x00);
  279. 	ack_status = Receive_ACK();
  280. 	if(ack_status) printf("10");
  281. 	else printf("10-n-");
  282. 	I2C_Stop();
  283. }
  284.  
  285.  
  286.  
  287. void read_AHT20(void)
  288. {
  289. 	uint8_t   i;
  290.  
  291. 	for(i=0; i<6; i++)
  292. 	{
  293. 		readByte[i]=0;
  294. 	}
  295.  
  296. 	//-------------
  297. 	I2C_Start();
  298.  
  299. 	I2C_WriteByte(0x71);
  300. 	ack_status = Receive_ACK();
  301. 	readByte[0]= I2C_ReadByte();
  302. 	Send_ACK();
  303.  
  304. 	readByte[1]= I2C_ReadByte();
  305. 	Send_ACK();
  306.  
  307. 	readByte[2]= I2C_ReadByte();
  308. 	Send_ACK();
  309.  
  310. 	readByte[3]= I2C_ReadByte();
  311. 	Send_ACK();
  312.  
  313. 	readByte[4]= I2C_ReadByte();
  314. 	Send_ACK();
  315.  
  316. 	readByte[5]= I2C_ReadByte();
  317. 	SendNot_Ack();
  318. 	//Send_ACK();
  319.  
  320. 	I2C_Stop();
  321.  
  322. 	//--------------
  323. 	if( (readByte[0] & 0x68) == 0x08 )
  324. 	{
  325. 		H1 = readByte[1];
  326. 		H1 = (H1<<8) | readByte[2];
  327. 		H1 = (H1<<8) | readByte[3];
  328. 		H1 = H1>>4;
  330. 		H1 = (H1*1000)/1024/1024;
  331.  
  332. 		T1 = readByte[3];
  333. 		T1 = T1 & 0x0000000F;
  334. 		T1 = (T1<<8) | readByte[4];
  335. 		T1 = (T1<<8) | readByte[5];
  336.  
  337. 		T1 = (T1*2000)/1024/1024 - 500;
  338.  
  339. 		AHT20_OutData[0] = (H1>>8) & 0x000000FF;
  340. 		AHT20_OutData[1] = H1 & 0x000000FF;
  341.  
  342. 		AHT20_OutData[2] = (T1>>8) & 0x000000FF;
  343. 		AHT20_OutData[3] = T1 & 0x000000FF;
  344. 	}
  345. 	else
  346. 	{
  347. 		AHT20_OutData[0] = 0xFF;
  348. 		AHT20_OutData[1] = 0xFF;
  349.  
  350. 		AHT20_OutData[2] = 0xFF;
  351. 		AHT20_OutData[3] = 0xFF;
  352. 		printf("lyy");
  353.  
  354. 	}
  355. //	printf("\r\n");
  356. //	printf("温度:%d%d.%d",T1/100,(T1/10)%10,T1%10);
  357. //	printf("湿度:%d%d.%d",H1/100,(H1/10)%10,H1%10);
  358. //	printf("\r\n");
  359. 	
  360. 	OLED_ShowString(1, 1, "Temperature:");
  361. 	OLED_ShowNum(1, 13, T1/100, 1);
  362. 	OLED_ShowNum(1, 14, (T1/10)%10, 1);
  363. 	OLED_ShowChar(1, 15, '.');
  364. 	OLED_ShowNum(1, 16, T1%10, 1);
  365. 	
  366. 	OLED_ShowString(2, 1, "Humidity:");
  367. 	OLED_ShowNum(2, 10, H1/100, 1);
  368. 	OLED_ShowNum(2, 11, (H1/10)%10, 1);
  369. 	OLED_ShowChar(2, 12, '.');
  370. 	OLED_ShowNum(2, 13, H1%10, 1);
  371. }
  372.  
  373.  
  374.  
  375.  
  376. uint8_t  Receive_ACK(void)
  377. {
  378. 	uint8_t result=0;
  379. 	uint8_t cnt=0;
  380.  
  381. 	IIC_SCL = 0;
  382. 	SDA_IN(); 
  383. 	delay_us(4);
  384.  
  385. 	IIC_SCL = 1;
  386. 	delay_us(4);
  387.  
  388. 	while(READ_SDA && (cnt<100))
  389. 	{
  390. 		cnt++;
  391. 	}
  392.  
  393. 	IIC_SCL = 0;
  394. 	delay_us(4);
  395.  
  396. 	if(cnt<100)
  397. 	{
  398. 		result=1;
  399. 	}
  400. 	return result;
  401. }
  402.  
  403.  
  404.  
  405. void  Send_ACK(void)
  406. {
  407. 	SDA_OUT();
  408. 	IIC_SCL = 0;
  409. 	delay_us(4);
  410.  
  411. 	IIC_SDA = 0;
  412. 	delay_us(4);
  413.  
  414. 	IIC_SCL = 1;
  415. 	delay_us(4);
  416. 	IIC_SCL = 0;
  417. 	delay_us(4);
  418.  
  419. 	SDA_IN();
  420. }
  421.  
  422.  
  423.  
  424. void  SendNot_Ack(void)
  425. {
  426. 	SDA_OUT();
  427. 	IIC_SCL = 0;
  428. 	delay_us(4);
  429.  
  430. 	IIC_SDA = 1;
  431. 	delay_us(4);
  432.  
  433. 	IIC_SCL = 1;
  434. 	delay_us(4);
  435.  
  436. 	IIC_SCL = 0;
  437. 	delay_us(4);
  438.  
  439. 	IIC_SDA = 0;
  440. 	delay_us(4);
  441. }
  442.  
  443.  
  444. void I2C_WriteByte(uint8_t  input)
  445. {
  446. 	uint8_t  i;
  447. 	SDA_OUT();
  448. 	for(i=0; i<8; i++)
  449. 	{
  450. 		IIC_SCL = 0;
  451. 		delay_ms(5);
  452.  
  453. 		if(input & 0x80)
  454. 		{
  455. 			IIC_SDA = 1;
  456. 			//delaymm(10);
  457. 		}
  458. 		else
  459. 		{
  460. 			IIC_SDA = 0;
  461. 			//delaymm(10);
  462. 		}
  463.  
  464. 		IIC_SCL = 1;
  465. 		delay_ms(5);
  466.  
  467. 		input = (input<<1);
  468. 	}
  469.  
  470. 	IIC_SCL = 0;
  471. 	delay_us(4);
  472.  
  473. 	SDA_IN();
  474. 	delay_us(4);
  475. }	
  476.  
  477.  
  478. uint8_t I2C_ReadByte(void)
  479. {
  480. 	uint8_t  resultByte=0;
  481. 	uint8_t  i=0, a=0;
  482.  
  483. 	IIC_SCL = 0;
  484. 	SDA_IN();
  485. 	delay_ms(4);
  486.  
  487. 	for(i=0; i<8; i++)
  488. 	{
  489. 		IIC_SCL = 1;
  490. 		delay_ms(3);
  491.  
  492. 		a=0;
  493. 		if(READ_SDA)
  494. 		{
  495. 			a=1;
  496. 		}
  497. 		else
  498. 		{
  499. 			a=0;
  500. 		}
  501.  
  502. 		//resultByte = resultByte | a;
  503. 		resultByte = (resultByte << 1) | a;
  504.  
  505. 		IIC_SCL = 0;
  506. 		delay_ms(3);
  507. 	}
  508.  
  509. 	SDA_IN();
  510. 	delay_ms(10);
  511.  
  512. 	return   resultByte;
  513. }
  514.  
  515.  
  516. void  set_AHT20sendOutData(void)
  517. {
  518. 	/* --------------------------
  519. 	 * 0xFA 0x06 0x0A temperature(2 Bytes) humility(2Bytes) short Address(2 Bytes)
  520. 	 * And Check (1 byte)
  521. 	 * -------------------------*/
  522. 	AHT20sendOutData[3] = AHT20_OutData[0];
  523. 	AHT20sendOutData[4] = AHT20_OutData[1];
  524. 	AHT20sendOutData[5] = AHT20_OutData[2];
  525. 	AHT20sendOutData[6] = AHT20_OutData[3];
  526.  
  527. //	AHT20sendOutData[7] = (drf1609.shortAddress >> 8) & 0x00FF;
  528. //	AHT20sendOutData[8] = drf1609.shortAddress  & 0x00FF;
  529.  
  530. //	AHT20sendOutData[9] = getXY(AHT20sendOutData,10);
  531. }
  532.  
  533.  
  534. void  I2C_Start(void)
  535. {
  536. 	SDA_OUT();
  537. 	IIC_SCL = 1;
  538. 	delay_ms(4);
  539.  
  540. 	IIC_SDA = 1;
  541. 	delay_ms(4);
  542. 	IIC_SDA = 0;
  543. 	delay_ms(4);
  544.  
  545. 	IIC_SCL = 0;
  546. 	delay_ms(4);
  547. }
  548.  
  549.  
  550.  
  551. void  I2C_Stop(void)
  552. {
  553. 	SDA_OUT();
  554. 	IIC_SDA = 0;
  555. 	delay_ms(4);
  556.  
  557. 	IIC_SCL = 1;
  558. 	delay_ms(4);
  559.  
  560. 	IIC_SDA = 1;
  561. 	delay_ms(4);
  562. }
  563.

(5:OLED_Font.h文件编写:

  1. #ifndef __OLED_FONT_H
  2. #define __OLED_FONT_H
  3.  
  4. /*OLED字模库，宽8像素，高16像素*/
  5. const uint8_t OLED_F8x16[][16]=
  6. {
  7. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  8. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//  0
  9. 	
  10. 	0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,
  11. 	0x00,0x00,0x00,0x33,0x30,0x00,0x00,0x00,//! 1
  12. 	
  13. 	0x00,0x10,0x0C,0x06,0x10,0x0C,0x06,0x00,
  14. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//" 2
  15. 	
  16. 	0x40,0xC0,0x78,0x40,0xC0,0x78,0x40,0x00,
  17. 	0x04,0x3F,0x04,0x04,0x3F,0x04,0x04,0x00,//# 3
  18. 	
  19. 	0x00,0x70,0x88,0xFC,0x08,0x30,0x00,0x00,
  20. 	0x00,0x18,0x20,0xFF,0x21,0x1E,0x00,0x00,//$ 4
  21. 	
  22. 	0xF0,0x08,0xF0,0x00,0xE0,0x18,0x00,0x00,
  23. 	0x00,0x21,0x1C,0x03,0x1E,0x21,0x1E,0x00,//% 5
  24. 	
  25. 	0x00,0xF0,0x08,0x88,0x70,0x00,0x00,0x00,
  26. 	0x1E,0x21,0x23,0x24,0x19,0x27,0x21,0x10,//& 6
  27. 	
  28. 	0x10,0x16,0x0E,0x00,0x00,0x00,0x00,0x00,
  29. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//' 7
  30. 	
  31. 	0x00,0x00,0x00,0xE0,0x18,0x04,0x02,0x00,
  32. 	0x00,0x00,0x00,0x07,0x18,0x20,0x40,0x00,//( 8
  33. 	
  34. 	0x00,0x02,0x04,0x18,0xE0,0x00,0x00,0x00,
  35. 	0x00,0x40,0x20,0x18,0x07,0x00,0x00,0x00,//) 9
  36. 	
  37. 	0x40,0x40,0x80,0xF0,0x80,0x40,0x40,0x00,
  38. 	0x02,0x02,0x01,0x0F,0x01,0x02,0x02,0x00,//* 10
  39. 	
  40. 	0x00,0x00,0x00,0xF0,0x00,0x00,0x00,0x00,
  41. 	0x01,0x01,0x01,0x1F,0x01,0x01,0x01,0x00,//+ 11
  42. 	
  43. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  44. 	0x80,0xB0,0x70,0x00,0x00,0x00,0x00,0x00,//, 12
  45. 	
  46. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  47. 	0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,//- 13
  48. 	
  49. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  50. 	0x00,0x30,0x30,0x00,0x00,0x00,0x00,0x00,//. 14
  51. 	
  52. 	0x00,0x00,0x00,0x00,0x80,0x60,0x18,0x04,
  53. 	0x00,0x60,0x18,0x06,0x01,0x00,0x00,0x00,/// 15
  54. 	
  55. 	0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,
  56. 	0x00,0x0F,0x10,0x20,0x20,0x10,0x0F,0x00,//0 16
  57. 	
  58. 	0x00,0x10,0x10,0xF8,0x00,0x00,0x00,0x00,
  59. 	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//1 17
  60. 	
  61. 	0x00,0x70,0x08,0x08,0x08,0x88,0x70,0x00,
  62. 	0x00,0x30,0x28,0x24,0x22,0x21,0x30,0x00,//2 18
  63. 	
  64. 	0x00,0x30,0x08,0x88,0x88,0x48,0x30,0x00,
  65. 	0x00,0x18,0x20,0x20,0x20,0x11,0x0E,0x00,//3 19
  66. 	
  67. 	0x00,0x00,0xC0,0x20,0x10,0xF8,0x00,0x00,
  68. 	0x00,0x07,0x04,0x24,0x24,0x3F,0x24,0x00,//4 20
  69. 	
  70. 	0x00,0xF8,0x08,0x88,0x88,0x08,0x08,0x00,
  71. 	0x00,0x19,0x21,0x20,0x20,0x11,0x0E,0x00,//5 21
  72. 	
  73. 	0x00,0xE0,0x10,0x88,0x88,0x18,0x00,0x00,
  74. 	0x00,0x0F,0x11,0x20,0x20,0x11,0x0E,0x00,//6 22
  75. 	
  76. 	0x00,0x38,0x08,0x08,0xC8,0x38,0x08,0x00,
  77. 	0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x00,//7 23
  78. 	
  79. 	0x00,0x70,0x88,0x08,0x08,0x88,0x70,0x00,
  80. 	0x00,0x1C,0x22,0x21,0x21,0x22,0x1C,0x00,//8 24
  81. 	
  82. 	0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,
  83. 	0x00,0x00,0x31,0x22,0x22,0x11,0x0F,0x00,//9 25
  84. 	
  85. 	0x00,0x00,0x00,0xC0,0xC0,0x00,0x00,0x00,
  86. 	0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00,//: 26
  87. 	
  88. 	0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,
  89. 	0x00,0x00,0x80,0x60,0x00,0x00,0x00,0x00,//; 27
  90. 	
  91. 	0x00,0x00,0x80,0x40,0x20,0x10,0x08,0x00,
  92. 	0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x00,//< 28
  93. 	
  94. 	0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00,
  95. 	0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x00,//= 29
  96. 	
  97. 	0x00,0x08,0x10,0x20,0x40,0x80,0x00,0x00,
  98. 	0x00,0x20,0x10,0x08,0x04,0x02,0x01,0x00,//> 30
  99. 	
  100. 	0x00,0x70,0x48,0x08,0x08,0x08,0xF0,0x00,
  101. 	0x00,0x00,0x00,0x30,0x36,0x01,0x00,0x00,//? 31
  102. 	
  103. 	0xC0,0x30,0xC8,0x28,0xE8,0x10,0xE0,0x00,
  104. 	0x07,0x18,0x27,0x24,0x23,0x14,0x0B,0x00,//@ 32
  105. 	
  106. 	0x00,0x00,0xC0,0x38,0xE0,0x00,0x00,0x00,
  107. 	0x20,0x3C,0x23,0x02,0x02,0x27,0x38,0x20,//A 33
  108. 	
  109. 	0x08,0xF8,0x88,0x88,0x88,0x70,0x00,0x00,
  110. 	0x20,0x3F,0x20,0x20,0x20,0x11,0x0E,0x00,//B 34
  111. 	
  112. 	0xC0,0x30,0x08,0x08,0x08,0x08,0x38,0x00,
  113. 	0x07,0x18,0x20,0x20,0x20,0x10,0x08,0x00,//C 35
  114. 	
  115. 	0x08,0xF8,0x08,0x08,0x08,0x10,0xE0,0x00,
  116. 	0x20,0x3F,0x20,0x20,0x20,0x10,0x0F,0x00,//D 36
  117. 	
  118. 	0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,
  119. 	0x20,0x3F,0x20,0x20,0x23,0x20,0x18,0x00,//E 37
  120. 	
  121. 	0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,
  122. 	0x20,0x3F,0x20,0x00,0x03,0x00,0x00,0x00,//F 38
  123. 	
  124. 	0xC0,0x30,0x08,0x08,0x08,0x38,0x00,0x00,
  125. 	0x07,0x18,0x20,0x20,0x22,0x1E,0x02,0x00,//G 39
  126. 	
  127. 	0x08,0xF8,0x08,0x00,0x00,0x08,0xF8,0x08,
  128. 	0x20,0x3F,0x21,0x01,0x01,0x21,0x3F,0x20,//H 40
  129. 	
  130. 	0x00,0x08,0x08,0xF8,0x08,0x08,0x00,0x00,
  131. 	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//I 41
  132. 	
  133. 	0x00,0x00,0x08,0x08,0xF8,0x08,0x08,0x00,
  134. 	0xC0,0x80,0x80,0x80,0x7F,0x00,0x00,0x00,//J 42
  135. 	
  136. 	0x08,0xF8,0x88,0xC0,0x28,0x18,0x08,0x00,
  137. 	0x20,0x3F,0x20,0x01,0x26,0x38,0x20,0x00,//K 43
  138. 	
  139. 	0x08,0xF8,0x08,0x00,0x00,0x00,0x00,0x00,
  140. 	0x20,0x3F,0x20,0x20,0x20,0x20,0x30,0x00,//L 44
  141. 	
  142. 	0x08,0xF8,0xF8,0x00,0xF8,0xF8,0x08,0x00,
  143. 	0x20,0x3F,0x00,0x3F,0x00,0x3F,0x20,0x00,//M 45
  144. 	
  145. 	0x08,0xF8,0x30,0xC0,0x00,0x08,0xF8,0x08,
  146. 	0x20,0x3F,0x20,0x00,0x07,0x18,0x3F,0x00,//N 46
  147. 	
  148. 	0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,
  149. 	0x0F,0x10,0x20,0x20,0x20,0x10,0x0F,0x00,//O 47
  150. 	
  151. 	0x08,0xF8,0x08,0x08,0x08,0x08,0xF0,0x00,
  152. 	0x20,0x3F,0x21,0x01,0x01,0x01,0x00,0x00,//P 48
  153. 	
  154. 	0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,
  155. 	0x0F,0x18,0x24,0x24,0x38,0x50,0x4F,0x00,//Q 49
  156. 	
  157. 	0x08,0xF8,0x88,0x88,0x88,0x88,0x70,0x00,
  158. 	0x20,0x3F,0x20,0x00,0x03,0x0C,0x30,0x20,//R 50
  159. 	
  160. 	0x00,0x70,0x88,0x08,0x08,0x08,0x38,0x00,
  161. 	0x00,0x38,0x20,0x21,0x21,0x22,0x1C,0x00,//S 51
  162. 	
  163. 	0x18,0x08,0x08,0xF8,0x08,0x08,0x18,0x00,
  164. 	0x00,0x00,0x20,0x3F,0x20,0x00,0x00,0x00,//T 52
  165. 	
  166. 	0x08,0xF8,0x08,0x00,0x00,0x08,0xF8,0x08,
  167. 	0x00,0x1F,0x20,0x20,0x20,0x20,0x1F,0x00,//U 53
  168. 	
  169. 	0x08,0x78,0x88,0x00,0x00,0xC8,0x38,0x08,
  170. 	0x00,0x00,0x07,0x38,0x0E,0x01,0x00,0x00,//V 54
  171. 	
  172. 	0xF8,0x08,0x00,0xF8,0x00,0x08,0xF8,0x00,
  173. 	0x03,0x3C,0x07,0x00,0x07,0x3C,0x03,0x00,//W 55
  174. 	
  175. 	0x08,0x18,0x68,0x80,0x80,0x68,0x18,0x08,
  176. 	0x20,0x30,0x2C,0x03,0x03,0x2C,0x30,0x20,//X 56
  177. 	
  178. 	0x08,0x38,0xC8,0x00,0xC8,0x38,0x08,0x00,
  179. 	0x00,0x00,0x20,0x3F,0x20,0x00,0x00,0x00,//Y 57
  180. 	
  181. 	0x10,0x08,0x08,0x08,0xC8,0x38,0x08,0x00,
  182. 	0x20,0x38,0x26,0x21,0x20,0x20,0x18,0x00,//Z 58
  183. 	
  184. 	0x00,0x00,0x00,0xFE,0x02,0x02,0x02,0x00,
  185. 	0x00,0x00,0x00,0x7F,0x40,0x40,0x40,0x00,//[ 59
  186. 	
  187. 	0x00,0x0C,0x30,0xC0,0x00,0x00,0x00,0x00,
  188. 	0x00,0x00,0x00,0x01,0x06,0x38,0xC0,0x00,//\ 60
  189. 	
  190. 	0x00,0x02,0x02,0x02,0xFE,0x00,0x00,0x00,
  191. 	0x00,0x40,0x40,0x40,0x7F,0x00,0x00,0x00,//] 61
  192. 	
  193. 	0x00,0x00,0x04,0x02,0x02,0x02,0x04,0x00,
  194. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//^ 62
  195. 	
  196. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  197. 	0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,//_ 63
  198. 	
  199. 	0x00,0x02,0x02,0x04,0x00,0x00,0x00,0x00,
  200. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//` 64
  201. 	
  202. 	0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
  203. 	0x00,0x19,0x24,0x22,0x22,0x22,0x3F,0x20,//a 65
  204. 	
  205. 	0x08,0xF8,0x00,0x80,0x80,0x00,0x00,0x00,
  206. 	0x00,0x3F,0x11,0x20,0x20,0x11,0x0E,0x00,//b 66
  207. 	
  208. 	0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00,
  209. 	0x00,0x0E,0x11,0x20,0x20,0x20,0x11,0x00,//c 67
  210. 	
  211. 	0x00,0x00,0x00,0x80,0x80,0x88,0xF8,0x00,
  212. 	0x00,0x0E,0x11,0x20,0x20,0x10,0x3F,0x20,//d 68
  213. 	
  214. 	0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
  215. 	0x00,0x1F,0x22,0x22,0x22,0x22,0x13,0x00,//e 69
  216. 	
  217. 	0x00,0x80,0x80,0xF0,0x88,0x88,0x88,0x18,
  218. 	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//f 70
  219. 	
  220. 	0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x00,
  221. 	0x00,0x6B,0x94,0x94,0x94,0x93,0x60,0x00,//g 71
  222. 	
  223. 	0x08,0xF8,0x00,0x80,0x80,0x80,0x00,0x00,
  224. 	0x20,0x3F,0x21,0x00,0x00,0x20,0x3F,0x20,//h 72
  225. 	
  226. 	0x00,0x80,0x98,0x98,0x00,0x00,0x00,0x00,
  227. 	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//i 73
  228. 	
  229. 	0x00,0x00,0x00,0x80,0x98,0x98,0x00,0x00,
  230. 	0x00,0xC0,0x80,0x80,0x80,0x7F,0x00,0x00,//j 74
  231. 	
  232. 	0x08,0xF8,0x00,0x00,0x80,0x80,0x80,0x00,
  233. 	0x20,0x3F,0x24,0x02,0x2D,0x30,0x20,0x00,//k 75
  234. 	
  235. 	0x00,0x08,0x08,0xF8,0x00,0x00,0x00,0x00,
  236. 	0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//l 76
  237. 	
  238. 	0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x00,
  239. 	0x20,0x3F,0x20,0x00,0x3F,0x20,0x00,0x3F,//m 77
  240. 	
  241. 	0x80,0x80,0x00,0x80,0x80,0x80,0x00,0x00,
  242. 	0x20,0x3F,0x21,0x00,0x00,0x20,0x3F,0x20,//n 78
  243. 	
  244. 	0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
  245. 	0x00,0x1F,0x20,0x20,0x20,0x20,0x1F,0x00,//o 79
  246. 	
  247. 	0x80,0x80,0x00,0x80,0x80,0x00,0x00,0x00,
  248. 	0x80,0xFF,0xA1,0x20,0x20,0x11,0x0E,0x00,//p 80
  249. 	
  250. 	0x00,0x00,0x00,0x80,0x80,0x80,0x80,0x00,
  251. 	0x00,0x0E,0x11,0x20,0x20,0xA0,0xFF,0x80,//q 81
  252. 	
  253. 	0x80,0x80,0x80,0x00,0x80,0x80,0x80,0x00,
  254. 	0x20,0x20,0x3F,0x21,0x20,0x00,0x01,0x00,//r 82
  255. 	
  256. 	0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x00,
  257. 	0x00,0x33,0x24,0x24,0x24,0x24,0x19,0x00,//s 83
  258. 	
  259. 	0x00,0x80,0x80,0xE0,0x80,0x80,0x00,0x00,
  260. 	0x00,0x00,0x00,0x1F,0x20,0x20,0x00,0x00,//t 84
  261. 	
  262. 	0x80,0x80,0x00,0x00,0x00,0x80,0x80,0x00,
  263. 	0x00,0x1F,0x20,0x20,0x20,0x10,0x3F,0x20,//u 85
  264. 	
  265. 	0x80,0x80,0x80,0x00,0x00,0x80,0x80,0x80,
  266. 	0x00,0x01,0x0E,0x30,0x08,0x06,0x01,0x00,//v 86
  267. 	
  268. 	0x80,0x80,0x00,0x80,0x00,0x80,0x80,0x80,
  269. 	0x0F,0x30,0x0C,0x03,0x0C,0x30,0x0F,0x00,//w 87
  270. 	
  271. 	0x00,0x80,0x80,0x00,0x80,0x80,0x80,0x00,
  272. 	0x00,0x20,0x31,0x2E,0x0E,0x31,0x20,0x00,//x 88
  273. 	
  274. 	0x80,0x80,0x80,0x00,0x00,0x80,0x80,0x80,
  275. 	0x80,0x81,0x8E,0x70,0x18,0x06,0x01,0x00,//y 89
  276. 	
  277. 	0x00,0x80,0x80,0x80,0x80,0x80,0x80,0x00,
  278. 	0x00,0x21,0x30,0x2C,0x22,0x21,0x30,0x00,//z 90
  279. 	
  280. 	0x00,0x00,0x00,0x00,0x80,0x7C,0x02,0x02,
  281. 	0x00,0x00,0x00,0x00,0x00,0x3F,0x40,0x40,//{ 91
  282. 	
  283. 	0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,
  284. 	0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,//| 92
  285. 	
  286. 	0x00,0x02,0x02,0x7C,0x80,0x00,0x00,0x00,
  287. 	0x00,0x40,0x40,0x3F,0x00,0x00,0x00,0x00,//} 93
  288. 	
  289. 	0x00,0x06,0x01,0x01,0x02,0x02,0x04,0x04,
  290. 	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//~ 94
  291. };
  292.  
  293. #endif

(6:delay.h与delay.c文件编写:

delay.h:

  1. #ifndef __DELAY_H
  2. #define __DELAY_H 			   
  3. #include "sys.h"
  4. //	 
  5.  
  6. //STM32F103o?D?°?ày3ì
  7. //?aoˉêy°?±?ày3ì
  8. /********** mcudev.taobao.com 3??·  ********/
  9.  
  10.  
  11. //ê1ó?SysTickμ???í¨??êy?￡ê????ó3ù??DD1üàí
  12. //°üà¨delay_us,delay_ms
  13.  
  14. // 	 
  15. void delay_init(void);
  16. void delay_ms(u16 nms);
  17. void delay_us(u32 nus);
  18.  
  19. #endif

delay.c:

  1. #include "delay.h"
  2. #include "sys.h"
  3.  
  4. //STM32F103o?D?°?ày3ì
  5. //?aoˉêy°?±?ày3ì
  6. /********** mcudev.taobao.com 3??·  ********/
  7.  
  8.  
  9. // 	 
  10. //è?1?ê1ó?ucos,?ò°üà¨????μ?í·???t?′?é.
  11. #if SYSTEM_SUPPORT_UCOS
  12. #include "includes.h"					//ucos ê1ó?	  
  13. #endif
  14. //	 
  15.  
  16. //STM32?a·￠°?
  17. //ê1ó?SysTickμ???í¨??êy?￡ê????ó3ù??DD1üàí
  18. //°üà¨delay_us,delay_ms
  19.  
  20. // 	 
  21. static u8  fac_us=0;//us?óê±±?3?êy
  22. static u16 fac_ms=0;//ms?óê±±?3?êy
  23. #ifdef OS_CRITICAL_METHOD 	//è?1?OS_CRITICAL_METHOD?¨ò?á?,?μ?÷ê1ó?ucosIIá?.
  24. //systick?D??·t??oˉêy,ê1ó?ucosê±ó?μ?
  25. void SysTick_Handler(void)
  26. {				   
  27. 	OSIntEnter();		//??è??D??
  28.     OSTimeTick();       //μ÷ó?ucosμ?ê±?ó·t??3ìDò               
  29.     OSIntExit();        //′￥·￠è????D??èí?D??
  30. }
  31. #endif
  32.  
  33. //3?ê??ˉ?ó3ùoˉêy
  34. //μ±ê1ó?ucosμ?ê±oò,′?oˉêy?á3?ê??ˉucosμ?ê±?ó?ú??
  35. //SYSTICKμ?ê±?ó1ì?¨?aHCLKê±?óμ?1/8
  36. //SYSCLK:?μí3ê±?ó
  37. void delay_init()	 
  38. {
  39.  
  40. #ifdef OS_CRITICAL_METHOD 	//è?1?OS_CRITICAL_METHOD?¨ò?á?,?μ?÷ê1ó?ucosIIá?.
  41. 	u32 reload;
  42. #endif
  43. 	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);	//????ía2?ê±?ó  HCLK/8
  44. 	fac_us=SystemCoreClock/8000000;	//?a?μí3ê±?óμ?1/8  
  45. 	 
  46. #ifdef OS_CRITICAL_METHOD 	//è?1?OS_CRITICAL_METHOD?¨ò?á?,?μ?÷ê1ó?ucosIIá?.
  47. 	reload=SystemCoreClock/8000000;		//?????óμ???êy′?êy μ￥???aK	   
  48. 	reload*=1000000/OS_TICKS_PER_SEC;//?ù?YOS_TICKS_PER_SECéè?¨ò?3?ê±??
  49. 							//reload?a24????′??÷,×?′ó?μ:16777216,?ú72M??,??o?1.86s×óóò	
  50. 	fac_ms=1000/OS_TICKS_PER_SEC;//′ú±íucos?éò??óê±μ?×?éùμ￥??	   
  51. 	SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;   	//?a??SYSTICK?D??
  52. 	SysTick->LOAD=reload; 	//??1/OS_TICKS_PER_SEC???D??ò?′?	
  53. 	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;   	//?a??SYSTICK    
  54. #else
  55. 	fac_ms=(u16)fac_us*1000;//·?ucos??,′ú±í????msDèòaμ?systickê±?óêy   
  56. #endif
  57. }								    
  58.  
  59. #ifdef OS_CRITICAL_METHOD	//ê1ó?á?ucos
  60. //?óê±nus
  61. //nus?aòa?óê±μ?usêy.		    								   
  62. void delay_us(u32 nus)
  63. {		
  64. 	u32 ticks;
  65. 	u32 told,tnow,tcnt=0;
  66. 	u32 reload=SysTick->LOAD;	//LOADμ??μ	    	 
  67. 	ticks=nus*fac_us; 			//Dèòaμ??ú??êy	  		 
  68. 	tcnt=0;
  69. 	told=SysTick->VAL;        	//????è?ê±μ???êy?÷?μ
  70. 	while(1)
  71. 	{
  72. 		tnow=SysTick->VAL;	
  73. 		if(tnow!=told)
  74. 		{	    
  75. 			if(tnow<told)tcnt+=told-tnow;//?aà?×￠òaò???SYSTICKê?ò???μY??μ???êy?÷?í?éò?á?.
  76. 			else tcnt+=reload-tnow+told;	    
  77. 			told=tnow;
  78. 			if(tcnt>=ticks)break;//ê±??3?1y/μèóúòa?ó3ùμ?ê±??,?òí?3?.
  79. 		}  
  80. 	}; 									    
  81. }
  82. //?óê±nms
  83. //nms:òa?óê±μ?msêy
  84. void delay_ms(u16 nms)
  85. {	
  86. 	if(OSRunning==TRUE)//è?1?osò??-?ú?üá?	    
  87. 	{		  
  88. 		if(nms>=fac_ms)//?óê±μ?ê±??′óóúucosμ?×?éùê±???ü?ú 
  89. 		{
  90.    			OSTimeDly(nms/fac_ms);//ucos?óê±
  91. 		}
  92. 		nms%=fac_ms;				//ucosò??-?T·¨ìá1??a?′D?μ??óê±á?,2éó???í¨·?ê??óê±    
  93. 	}
  94. 	delay_us((u32)(nms*1000));	//??í¨·?ê??óê±,′?ê±ucos?T·¨???ˉμ÷?è.
  95. }
  96. #else//2?ó?ucosê±
  97. //?óê±nus
  98. //nus?aòa?óê±μ?usêy.		    								   
  99. void delay_us(u32 nus)
  100. {		
  101. 	u32 temp;	    	 
  102. 	SysTick->LOAD=nus*fac_us; //ê±???ó??	  		 
  103. 	SysTick->VAL=0x00;        //??????êy?÷
  104. 	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;          //?aê?μ1êy	 
  105. 	do
  106. 	{
  107. 		temp=SysTick->CTRL;
  108. 	}
  109. 	while(temp&0x01&&!(temp&(1<<16)));//μè′yê±??μ?′?   
  110. 	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;       //1?±???êy?÷
  111. 	SysTick->VAL =0X00;       //??????êy?÷	 
  112. }
  113. //?óê±nms
  114. //×￠òanmsμ?·??§
  115. //SysTick->LOAD?a24????′??÷,?ùò?,×?′ó?óê±?a:
  116. //nms<=0xffffff*8*1000/SYSCLK
  117. //SYSCLKμ￥???aHz,nmsμ￥???ams
  118. //??72Mì??t??,nms<=1864 
  119. void delay_ms(u16 nms)
  120. {	 		  	  
  121. 	u32 temp;		   
  122. 	SysTick->LOAD=(u32)nms*fac_ms;//ê±???ó??(SysTick->LOAD?a24bit)
  123. 	SysTick->VAL =0x00;           //??????êy?÷
  124. 	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;          //?aê?μ1êy  
  125. 	do
  126. 	{
  127. 		temp=SysTick->CTRL;
  128. 	}
  129. 	while(temp&0x01&&!(temp&(1<<16)));//μè′yê±??μ?′?   
  130. 	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;       //1?±???êy?÷
  131. 	SysTick->VAL =0X00;       //??????êy?÷	  	    
  132. } 
  133. #endif

(7:usart.h与usart.c文件编写:

usart.h:

  1. #ifndef __USART_H
  2. #define __USART_H
  3. #include "stdio.h"	
  4. #include "sys.h" 
  5.  
  6. //STM32F103o?D?°?ày3ì
  7. //?aoˉêy°?±?ày3ì
  8. /********** mcudev.taobao.com 3??·  ********/
  9.  
  10. //	 
  11. //STM32?a·￠°?
  12. //′??ú13?ê??ˉ		   
  13.  
  14. #define USART_REC_LEN  			200  	//?¨ò?×?′ó?óê?×??úêy 200
  15. #define EN_USART1_RX 			1		    //ê1?ü￡¨1￡?/???1￡¨0￡?′??ú1?óê?
  16. 	  	
  17. extern u8  USART_RX_BUF[USART_REC_LEN]; //?óê??o3?,×?′óUSART_REC_LEN??×??ú.??×??ú?a??DD·? 
  18. extern u16 USART_RX_STA;         		//?óê?×′ì?±ê??	
  19. //è?1???′??ú?D???óê?￡???2?òa×￠êíò???oê?¨ò?
  20. void uart_init(u32 bound);
  21. #endif
  22.

usart.c:

  1. #include "sys.h"
  2. #include "usart.h"
  3.  
  4.  
  5. //STM32F103o?D?°?ày3ì
  6. //?aoˉêy°?±?ày3ì
  7. /********** mcudev.taobao.com 3??·  ********/
  8.  
  9.  
  10. // 	 
  11. //è?1?ê1ó?ucos,?ò°üà¨????μ?í·???t?′?é.
  12. #if SYSTEM_SUPPORT_UCOS
  13. #include "includes.h"					//ucos ê1ó?	  
  14. #endif
  15. //	 
  16. //STM32?a·￠°?
  17. //′??ú13?ê??ˉ		   
  18.  
  19. // 	  
  20.  
  21.  
  22. //
  23. //?óè?ò???′ú??,?§3?printfoˉêy,??2?Dèòa????use MicroLIB	  
  24. #if 1
  25. #pragma import(__use_no_semihosting)             
  26. //±ê×??aDèòaμ??§3?oˉêy                 
  27. struct __FILE 
  28. { 
  29. 	int handle; 
  30.  
  31. }; 
  32.  
  33. FILE __stdout;       
  34. //?¨ò?_sys_exit()ò?±ü?aê1ó?°??÷?ú?￡ê?    
  35. void _sys_exit(int x) 
  36. { 
  37. 	x = x; 
  38. } 
  39. //???¨ò?fputcoˉêy 
  40. int fputc(int ch, FILE *f)
  41. {      
  42. 	while((USART1->SR&0X40)==0);//?-?··￠?í,?±μ?·￠?ííê±?   
  43.     USART1->DR = (u8) ch;      
  44. 	return ch;
  45. }
  46. #endif 
  47.  
  48. /*ê1ó?microLibμ?·?·¨*/
  49.  /* 
  50. int fputc(int ch, FILE *f)
  51. {
  52. 	USART_SendData(USART1, (uint8_t) ch);
  53.  
  54. 	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) {}	
  55.    
  56.     return ch;
  57. }
  58. int GetKey (void)  { 
  59.  
  60.     while (!(USART1->SR & USART_FLAG_RXNE));
  61.  
  62.     return ((int)(USART1->DR & 0x1FF));
  63. }
  64. */
  65.  
  66. #if EN_USART1_RX   //è?1?ê1?üá??óê?
  67. //′??ú1?D??·t??3ìDò
  68. //×￠òa,?áè?USARTx->SR?ü±ü?a?a??????μ?′í?ó   	
  69. u8 USART_RX_BUF[USART_REC_LEN];     //?óê??o3?,×?′óUSART_REC_LEN??×??ú.
  70. //?óê?×′ì?
  71. //bit15￡?	?óê?íê3é±ê??
  72. //bit14￡?	?óê?μ?0x0d
  73. //bit13~0￡?	?óê?μ?μ?óDD§×??úêy??
  74. u16 USART_RX_STA=0;       //?óê?×′ì?±ê??	  
  75.   
  76. void uart_init(u32 bound){
  77.     //GPIO???úéè??
  78.   GPIO_InitTypeDef GPIO_InitStructure;
  79. 	USART_InitTypeDef USART_InitStructure;
  80. 	NVIC_InitTypeDef NVIC_InitStructure;
  81. 	 
  82. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);	//ê1?üUSART1￡?GPIOAê±?ó
  83.      //USART1_TX   PA.9
  84.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
  85.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  86.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//?′ó?í?íìê?3?
  87.     GPIO_Init(GPIOA, &GPIO_InitStructure);
  88.    
  89.     //USART1_RX	  PA.10
  90.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  91.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//????ê?è?
  92.     GPIO_Init(GPIOA, &GPIO_InitStructure);  
  93.  
  94.    //Usart1 NVIC ????
  95.  
  96.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  97. 	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//?à??ó??è??3
  98. 	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//×óó??è??3
  99. 	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQí¨μàê1?ü
  100. 	NVIC_Init(&NVIC_InitStructure);	//?ù?Y???¨μ?2?êy3?ê??ˉVIC??′??÷
  101.   
  102.    //USART 3?ê??ˉéè??
  103.  
  104. 	USART_InitStructure.USART_BaudRate = bound;//ò?°?éè???a9600;
  105. 	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//×?3¤?a8??êy?Y??ê?
  106. 	USART_InitStructure.USART_StopBits = USART_StopBits_1;//ò???í￡?1??
  107. 	USART_InitStructure.USART_Parity = USART_Parity_No;//?T????D￡?é??
  108. 	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//?Tó2?têy?Yá÷????
  109. 	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//ê?·￠?￡ê?
  110.  
  111.     USART_Init(USART1, &USART_InitStructure); //3?ê??ˉ′??ú
  112.     USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//?a???D??
  113.     USART_Cmd(USART1, ENABLE);                    //ê1?ü′??ú 
  114.  
  115. }
  116.  
  117.  
  118.  
  119. void USART1_IRQHandler(void)                	//′??ú1?D??·t??3ìDò
  120. 	{
  121. 	u8 Res;
  122. #ifdef OS_TICKS_PER_SEC	 	//è?1?ê±?ó?ú??êy?¨ò?á?,?μ?÷òaê1ó?ucosIIá?.
  123. 	OSIntEnter();    
  124. #endif
  125. 	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //?óê??D??(?óê?μ?μ?êy?Y±?D?ê?0x0d 0x0a?á?2)
  126. 		{
  127. 		Res =USART_ReceiveData(USART1);//(USART1->DR);	//?áè??óê?μ?μ?êy?Y
  128. 		
  129. 		if((USART_RX_STA&0x8000)==0)//?óê??′íê3é
  130. 			{
  131. 			if(USART_RX_STA&0x4000)//?óê?μ?á?0x0d
  132. 				{
  133. 				if(Res!=0x0a)USART_RX_STA=0;//?óê?′í?ó,??D??aê?
  134. 				else USART_RX_STA|=0x8000;	//?óê?íê3éá? 
  135. 				}
  136. 			else //?1??ê?μ?0X0D
  137. 				{	
  138. 				if(Res==0x0d)USART_RX_STA|=0x4000;
  139. 				else
  140. 					{
  141. 					USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
  142. 					USART_RX_STA++;
  143. 					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//?óê?êy?Y′í?ó,??D??aê??óê?	  
  144. 					}		 
  145. 				}
  146. 			}   		 
  147.      } 
  148. #ifdef OS_TICKS_PER_SEC	 	//è?1?ê±?ó?ú??êy?¨ò?á?,?μ?÷òaê1ó?ucosIIá?.
  149. 	OSIntExit();  											 
  150. #endif
  151. } 
  152. #endif	
  153.

(8:bsp_i2c.h与bsp_i2c.c文件编写:

bsp_i2c.h:

  1. #ifndef __BSP_I2C_H
  2. #define __BSP_I2C_H
  3.  
  4. #include "sys.h"
  5. #include "delay.h"
  6. #include "usart.h"
  7. //ê1ó?IIC1 1ò??M24C02,OLED,LM75AD,HT1382    PB6,PB7
  8.  
  9. #define SDA_IN()  {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}
  10. #define SDA_OUT() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}
  11.  
  12. //IO2ù×÷oˉêy	 
  13. #define IIC_SCL    PBout(6) //SCL
  14. #define IIC_SDA    PBout(7) //SDA	 
  15. #define READ_SDA   PBin(7)  //ê?è?SDA 
  16.  
  17.  
  18. //IIC?ùóD2ù×÷oˉêy
  19. void IIC_Init(void);                //3?ê??ˉIICμ?IO?ú				 
  20. void IIC_Start(void);				//·￠?íIIC?aê?D?o?
  21. void IIC_Stop(void);	  			//·￠?íIICí￡?1D?o?
  22. void IIC_Send_Byte(u8 txd);			//IIC·￠?íò???×??ú
  23. u8 IIC_Read_Byte(unsigned char ack);//IIC?áè?ò???×??ú
  24. u8 IIC_Wait_Ack(void); 				//IICμè′yACKD?o?
  25. void IIC_Ack(void);					//IIC·￠?íACKD?o?
  26. void IIC_NAck(void);				//IIC2?·￠?íACKD?o?
  27.  
  28. void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr);
  29. uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead);//??′??÷μ??·￡??÷?tμ??·￡?òa?áμ?×??úêy  
  30.  
  31.  
  32. void  read_AHT20_once(void);
  33. void  reset_AHT20(void);
  34. void  init_AHT20(void);	
  35. void  startMeasure_AHT20(void);
  36. void  read_AHT20(void);
  37. uint8_t  Receive_ACK(void);
  38. void  Send_ACK(void);
  39. void  SendNot_Ack(void);
  40. void I2C_WriteByte(uint8_t  input);
  41. uint8_t I2C_ReadByte(void);	
  42. void  set_AHT20sendOutData(void);
  43. void  I2C_Start(void);
  44. void  I2C_Stop(void);
  45. #endif
  46.

bsp_i2c.c:

  1. #include "bsp_i2c.h"
  2. #include "delay.h"
  3. #include "OLED.h"
  4.  
  5. uint8_t   ack_status=0;
  6. uint8_t   readByte[6];
  7. uint8_t   AHT20_status=0;
  8.  
  9. uint32_t  H1=0;  //Humility
  10. uint32_t  T1=0;  //Temperature
  11.  
  12. uint8_t  AHT20_OutData[4];
  13. uint8_t  AHT20sendOutData[10] = {0xFA, 0x06, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF};
  14.  
  15. void IIC_Init(void)
  16. {					     
  17. 	GPIO_InitTypeDef GPIO_InitStructure;
  18. 	RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	
  19. 	   
  20. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
  21. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //í?íìê?3?
  22. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  23. 	GPIO_Init(GPIOB, &GPIO_InitStructure);
  24.  
  25. 	IIC_SCL=1;
  26. 	IIC_SDA=1;
  27.  
  28. }
  29. //2úéúIIC?eê?D?o?
  30. void IIC_Start(void)
  31. {
  32. 	SDA_OUT();     //sda??ê?3?
  33. 	IIC_SDA=1;	  	  
  34. 	IIC_SCL=1;
  35. 	delay_us(4);
  36.  	IIC_SDA=0;//START:when CLK is high,DATA change form high to low 
  37. 	delay_us(4);
  38. 	IIC_SCL=0;//?ˉ×?I2C×ü??￡?×?±?·￠?í?ò?óê?êy?Y 
  39. }	  
  40. //2úéúIICí￡?1D?o?
  41. void IIC_Stop(void)
  42. {
  43. 	SDA_OUT();//sda??ê?3?
  44. 	IIC_SCL=0;
  45. 	IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
  46.  	delay_us(4);
  47. 	IIC_SCL=1; 
  48. 	IIC_SDA=1;//·￠?íI2C×ü???áê?D?o?
  49. 	delay_us(4);							   	
  50. }
  51. //μè′yó|′eD?o?μ?à′
  52. //·μ???μ￡o1￡??óê?ó|′e꧰ü
  53. //        0￡??óê?ó|′e3é1|
  54. u8 IIC_Wait_Ack(void)
  55. {
  56. 	u8 ucErrTime=0;
  57. 	SDA_IN();      //SDAéè???aê?è?  
  58. 	IIC_SDA=1;delay_us(1);	   
  59. 	IIC_SCL=1;delay_us(1);	 
  60. 	while(READ_SDA)
  61. 	{
  62. 		ucErrTime++;
  63. 		if(ucErrTime>250)
  64. 		{
  65. 			IIC_Stop();
  66. 			return 1;
  67. 		}
  68. 	}
  69. 	IIC_SCL=0;//ê±?óê?3?0 	   
  70. 	return 0;  
  71. } 
  72. //2úéúACKó|′e
  73. void IIC_Ack(void)
  74. {
  75. 	IIC_SCL=0;
  76. 	SDA_OUT();
  77. 	IIC_SDA=0;
  78. 	delay_us(2);
  79. 	IIC_SCL=1;
  80. 	delay_us(2);
  81. 	IIC_SCL=0;
  82. }
  83. //2?2úéúACKó|′e		    
  84. void IIC_NAck(void)
  85. {
  86. 	IIC_SCL=0;
  87. 	SDA_OUT();
  88. 	IIC_SDA=1;
  89. 	delay_us(2);
  90. 	IIC_SCL=1;
  91. 	delay_us(2);
  92. 	IIC_SCL=0;
  93. }					 				     
  94. //IIC·￠?íò???×??ú
  95. //·μ??′ó?úóD?Tó|′e
  96. //1￡?óDó|′e
  97. //0￡??Tó|′e			  
  98. void IIC_Send_Byte(u8 txd)
  99. {                        
  100.     u8 t;   
  101. 		SDA_OUT(); 	    
  102.     IIC_SCL=0;//à-μíê±?ó?aê?êy?Y′?ê?
  103.     for(t=0;t<8;t++)
  104.     {              
  105.         IIC_SDA=(txd&0x80)>>7;
  106.         txd<<=1; 	  
  107. 		delay_us(2);   //??TEA5767?aèy???óê±??ê?±?D?μ?
  108. 		IIC_SCL=1;
  109. 		delay_us(2); 
  110. 		IIC_SCL=0;	
  111. 		delay_us(2);
  112.     }	 
  113. } 	    
  114. //?á1??×??ú￡?ack=1ê±￡?·￠?íACK￡?ack=0￡?·￠?ínACK   
  115. u8 IIC_Read_Byte(unsigned char ack)
  116. {
  117. 	unsigned char i,receive=0;
  118. 	SDA_IN();//SDAéè???aê?è?
  119.   for(i=0;i<8;i++ )
  120. 	{
  121.     IIC_SCL=0; 
  122.     delay_us(2);
  123. 		IIC_SCL=1;
  124.     receive<<=1;
  125.     if(READ_SDA)receive++;   
  126. 		delay_us(1); 
  127.   }					 
  128. 	if (!ack)
  129. 			IIC_NAck();//·￠?ínACK
  130. 	else
  131. 			IIC_Ack(); //·￠?íACK   
  132. 	return receive;
  133. }
  134.  
  135. void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr)
  136. {
  137. 	IIC_Start();  
  138. 	
  139. 	if(device_addr==0xA0) //eepromμ??·′óóú1×??ú
  140. 		IIC_Send_Byte(0xA0 + ((addr/256)<<1));//·￠?í??μ??·
  141. 	else
  142. 		IIC_Send_Byte(device_addr);	    //·￠?÷?tμ??·
  143. 	IIC_Wait_Ack(); 
  144. 	IIC_Send_Byte(addr&0xFF);   //·￠?íμíμ??·
  145. 	IIC_Wait_Ack(); 
  146. 	IIC_Send_Byte(data);     //·￠?í×??ú							   
  147. 	IIC_Wait_Ack();  		    	   
  148.   IIC_Stop();//2úéúò???í￡?1ì??t 
  149. 	if(device_addr==0xA0) //
  150. 		delay_ms(10);
  151. 	else
  152. 		delay_us(2);
  153. }
  154.  
  155. uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead)  //?á??′??÷?ò?áêy?Y
  156. {	
  157. 		uint16_t data;
  158. 		IIC_Start();  
  159. 		if(device_addr==0xA0)
  160. 			IIC_Send_Byte(0xA0 + ((addr/256)<<1));
  161. 		else
  162. 			IIC_Send_Byte(device_addr);	
  163. 		IIC_Wait_Ack();
  164. 		IIC_Send_Byte(addr&0xFF);   //·￠?íμíμ??·
  165. 		IIC_Wait_Ack(); 
  166.  
  167. 		IIC_Start();  	
  168. 		IIC_Send_Byte(device_addr+1);	    //·￠?÷?tμ??·
  169. 		IIC_Wait_Ack();
  170. 		if(ByteNumToRead == 1)//LM75???èêy?Y?a11bit
  171. 		{
  172. 			data=IIC_Read_Byte(0);
  173. 		}
  174. 		else
  175. 			{
  176. 				data=IIC_Read_Byte(1);
  177. 				data=(data<<8)+IIC_Read_Byte(0);
  178. 			}
  179. 		IIC_Stop();//2úéúò???í￡?1ì??t	    
  180. 		return data;
  181. }
  182.  
  183.  
  184. /**********
  185. *é???2?·??aIO?ú?￡?éI2C????
  186. *
  187. *′ó?aò????aê??aAHT20μ?????I2C
  188. *oˉêy??óDIICoíI2Cμ???±e￡???×￠òa￡?￡?￡?￡?￡?
  189. *
  190. *2020/2/23×?oóDT??è??ú
  191. *
  192. ***********/
  193. void  read_AHT20_once(void)
  194. {
  195. 	//delay_ms(10);
  196.  
  197. 	reset_AHT20();
  198. 	delay_ms(5);
  199.  
  200. 	init_AHT20();
  201. 	delay_ms(5);
  202.  
  203. 	startMeasure_AHT20();
  204. 	delay_ms(50);
  205.  
  206. 	read_AHT20();
  207. 	//delay_ms(5);
  208. }
  209.  
  210.  
  211. void  reset_AHT20(void)
  212. {
  213.  
  214. 	I2C_Start();
  215.  
  216. 	I2C_WriteByte(0x70);
  217. 	ack_status = Receive_ACK();
  218. 	if(ack_status) printf("1");
  219. 	else printf("1-n-");
  220. 	I2C_WriteByte(0xBA);
  221. 	ack_status = Receive_ACK();
  222. 		if(ack_status) printf("2");
  223. 	else printf("2-n-");
  224. 	I2C_Stop();
  225.  
  226. 	/*
  227. 	AHT20_OutData[0] = 0;
  228. 	AHT20_OutData[1] = 0;
  229. 	AHT20_OutData[2] = 0;
  230. 	AHT20_OutData[3] = 0;
  231. 	*/
  232. }
  233.  
  234.  
  235.  
  236. void  init_AHT20(void)
  237. {
  238. 	I2C_Start();
  239.  
  240. 	I2C_WriteByte(0x70);
  241. 	ack_status = Receive_ACK();
  242. 	if(ack_status) printf("3");
  243. 	else printf("3-n-");	
  244. 	I2C_WriteByte(0xE1);
  245. 	ack_status = Receive_ACK();
  246. 	if(ack_status) printf("4");
  247. 	else printf("4-n-");
  248. 	I2C_WriteByte(0x08);
  249. 	ack_status = Receive_ACK();
  250. 	if(ack_status) printf("5");
  251. 	else printf("5-n-");
  252. 	I2C_WriteByte(0x00);
  253. 	ack_status = Receive_ACK();
  254. 	if(ack_status) printf("6");
  255. 	else printf("6-n-");
  256. 	I2C_Stop();
  257. }
  258.  
  259.  
  260.  
  261. void  startMeasure_AHT20(void)
  262. {
  263. 	//------------
  264. 	I2C_Start();
  265.  
  266. 	I2C_WriteByte(0x70);
  267. 	ack_status = Receive_ACK();
  268. 	if(ack_status) printf("7");
  269. 	else printf("7-n-");
  270. 	I2C_WriteByte(0xAC);
  271. 	ack_status = Receive_ACK();
  272. 	if(ack_status) printf("8");
  273. 	else printf("8-n-");
  274. 	I2C_WriteByte(0x33);
  275. 	ack_status = Receive_ACK();
  276. 	if(ack_status) printf("9");
  277. 	else printf("9-n-");
  278. 	I2C_WriteByte(0x00);
  279. 	ack_status = Receive_ACK();
  280. 	if(ack_status) printf("10");
  281. 	else printf("10-n-");
  282. 	I2C_Stop();
  283. }
  284.  
  285.  
  286.  
  287. void read_AHT20(void)
  288. {
  289. 	uint8_t   i;
  290.  
  291. 	for(i=0; i<6; i++)
  292. 	{
  293. 		readByte[i]=0;
  294. 	}
  295.  
  296. 	//-------------
  297. 	I2C_Start();
  298.  
  299. 	I2C_WriteByte(0x71);
  300. 	ack_status = Receive_ACK();
  301. 	readByte[0]= I2C_ReadByte();
  302. 	Send_ACK();
  303.  
  304. 	readByte[1]= I2C_ReadByte();
  305. 	Send_ACK();
  306.  
  307. 	readByte[2]= I2C_ReadByte();
  308. 	Send_ACK();
  309.  
  310. 	readByte[3]= I2C_ReadByte();
  311. 	Send_ACK();
  312.  
  313. 	readByte[4]= I2C_ReadByte();
  314. 	Send_ACK();
  315.  
  316. 	readByte[5]= I2C_ReadByte();
  317. 	SendNot_Ack();
  318. 	//Send_ACK();
  319.  
  320. 	I2C_Stop();
  321.  
  322. 	//--------------
  323. 	if( (readByte[0] & 0x68) == 0x08 )
  324. 	{
  325. 		H1 = readByte[1];
  326. 		H1 = (H1<<8) | readByte[2];
  327. 		H1 = (H1<<8) | readByte[3];
  328. 		H1 = H1>>4;
  330. 		H1 = (H1*1000)/1024/1024;
  331.  
  332. 		T1 = readByte[3];
  333. 		T1 = T1 & 0x0000000F;
  334. 		T1 = (T1<<8) | readByte[4];
  335. 		T1 = (T1<<8) | readByte[5];
  336.  
  337. 		T1 = (T1*2000)/1024/1024 - 500;
  338.  
  339. 		AHT20_OutData[0] = (H1>>8) & 0x000000FF;
  340. 		AHT20_OutData[1] = H1 & 0x000000FF;
  341.  
  342. 		AHT20_OutData[2] = (T1>>8) & 0x000000FF;
  343. 		AHT20_OutData[3] = T1 & 0x000000FF;
  344. 	}
  345. 	else
  346. 	{
  347. 		AHT20_OutData[0] = 0xFF;
  348. 		AHT20_OutData[1] = 0xFF;
  349.  
  350. 		AHT20_OutData[2] = 0xFF;
  351. 		AHT20_OutData[3] = 0xFF;
  352. 		printf("lyy");
  353.  
  354. 	}
  355. //	printf("\r\n");
  356. //	printf("温度:%d%d.%d",T1/100,(T1/10)%10,T1%10);
  357. //	printf("湿度:%d%d.%d",H1/100,(H1/10)%10,H1%10);
  358. //	printf("\r\n");
  359. 	
  360. 	OLED_ShowString(1, 1, "Temperature:");
  361. 	OLED_ShowNum(1, 13, T1/100, 1);
  362. 	OLED_ShowNum(1, 14, (T1/10)%10, 1);
  363. 	OLED_ShowChar(1, 15, '.');
  364. 	OLED_ShowNum(1, 16, T1%10, 1);
  365. 	
  366. 	OLED_ShowString(2, 1, "Humidity:");
  367. 	OLED_ShowNum(2, 10, H1/100, 1);
  368. 	OLED_ShowNum(2, 11, (H1/10)%10, 1);
  369. 	OLED_ShowChar(2, 12, '.');
  370. 	OLED_ShowNum(2, 13, H1%10, 1);
  371. }
  372.  
  373.  
  374.  
  375.  
  376. uint8_t  Receive_ACK(void)
  377. {
  378. 	uint8_t result=0;
  379. 	uint8_t cnt=0;
  380.  
  381. 	IIC_SCL = 0;
  382. 	SDA_IN(); 
  383. 	delay_us(4);
  384.  
  385. 	IIC_SCL = 1;
  386. 	delay_us(4);
  387.  
  388. 	while(READ_SDA && (cnt<100))
  389. 	{
  390. 		cnt++;
  391. 	}
  392.  
  393. 	IIC_SCL = 0;
  394. 	delay_us(4);
  395.  
  396. 	if(cnt<100)
  397. 	{
  398. 		result=1;
  399. 	}
  400. 	return result;
  401. }
  402.  
  403.  
  404.  
  405. void  Send_ACK(void)
  406. {
  407. 	SDA_OUT();
  408. 	IIC_SCL = 0;
  409. 	delay_us(4);
  410.  
  411. 	IIC_SDA = 0;
  412. 	delay_us(4);
  413.  
  414. 	IIC_SCL = 1;
  415. 	delay_us(4);
  416. 	IIC_SCL = 0;
  417. 	delay_us(4);
  418.  
  419. 	SDA_IN();
  420. }
  421.  
  422.  
  423.  
  424. void  SendNot_Ack(void)
  425. {
  426. 	SDA_OUT();
  427. 	IIC_SCL = 0;
  428. 	delay_us(4);
  429.  
  430. 	IIC_SDA = 1;
  431. 	delay_us(4);
  432.  
  433. 	IIC_SCL = 1;
  434. 	delay_us(4);
  435.  
  436. 	IIC_SCL = 0;
  437. 	delay_us(4);
  438.  
  439. 	IIC_SDA = 0;
  440. 	delay_us(4);
  441. }
  442.  
  443.  
  444. void I2C_WriteByte(uint8_t  input)
  445. {
  446. 	uint8_t  i;
  447. 	SDA_OUT();
  448. 	for(i=0; i<8; i++)
  449. 	{
  450. 		IIC_SCL = 0;
  451. 		delay_ms(5);
  452.  
  453. 		if(input & 0x80)
  454. 		{
  455. 			IIC_SDA = 1;
  456. 			//delaymm(10);
  457. 		}
  458. 		else
  459. 		{
  460. 			IIC_SDA = 0;
  461. 			//delaymm(10);
  462. 		}
  463.  
  464. 		IIC_SCL = 1;
  465. 		delay_ms(5);
  466.  
  467. 		input = (input<<1);
  468. 	}
  469.  
  470. 	IIC_SCL = 0;
  471. 	delay_us(4);
  472.  
  473. 	SDA_IN();
  474. 	delay_us(4);
  475. }	
  476.  
  477.  
  478. uint8_t I2C_ReadByte(void)
  479. {
  480. 	uint8_t  resultByte=0;
  481. 	uint8_t  i=0, a=0;
  482.  
  483. 	IIC_SCL = 0;
  484. 	SDA_IN();
  485. 	delay_ms(4);
  486.  
  487. 	for(i=0; i<8; i++)
  488. 	{
  489. 		IIC_SCL = 1;
  490. 		delay_ms(3);
  491.  
  492. 		a=0;
  493. 		if(READ_SDA)
  494. 		{
  495. 			a=1;
  496. 		}
  497. 		else
  498. 		{
  499. 			a=0;
  500. 		}
  501.  
  502. 		//resultByte = resultByte | a;
  503. 		resultByte = (resultByte << 1) | a;
  504.  
  505. 		IIC_SCL = 0;
  506. 		delay_ms(3);
  507. 	}
  508.  
  509. 	SDA_IN();
  510. 	delay_ms(10);
  511.  
  512. 	return   resultByte;
  513. }
  514.  
  515.  
  516. void  set_AHT20sendOutData(void)
  517. {
  518. 	/* --------------------------
  519. 	 * 0xFA 0x06 0x0A temperature(2 Bytes) humility(2Bytes) short Address(2 Bytes)
  520. 	 * And Check (1 byte)
  521. 	 * -------------------------*/
  522. 	AHT20sendOutData[3] = AHT20_OutData[0];
  523. 	AHT20sendOutData[4] = AHT20_OutData[1];
  524. 	AHT20sendOutData[5] = AHT20_OutData[2];
  525. 	AHT20sendOutData[6] = AHT20_OutData[3];
  526.  
  527. //	AHT20sendOutData[7] = (drf1609.shortAddress >> 8) & 0x00FF;
  528. //	AHT20sendOutData[8] = drf1609.shortAddress  & 0x00FF;
  529.  
  530. //	AHT20sendOutData[9] = getXY(AHT20sendOutData,10);
  531. }
  532.  
  533.  
  534. void  I2C_Start(void)
  535. {
  536. 	SDA_OUT();
  537. 	IIC_SCL = 1;
  538. 	delay_ms(4);
  539.  
  540. 	IIC_SDA = 1;
  541. 	delay_ms(4);
  542. 	IIC_SDA = 0;
  543. 	delay_ms(4);
  544.  
  545. 	IIC_SCL = 0;
  546. 	delay_ms(4);
  547. }
  548.  
  549.  
  550.  
  551. void  I2C_Stop(void)
  552. {
  553. 	SDA_OUT();
  554. 	IIC_SDA = 0;
  555. 	delay_ms(4);
  556.  
  557. 	IIC_SCL = 1;
  558. 	delay_ms(4);
  559.  
  560. 	IIC_SDA = 1;
  561. 	delay_ms(4);
  562. }
  563.

(9:编写主文件main.c文件代码:

  1. #include "delay.h"
  2. #include "usart.h"
  3. #include "bsp_i2c.h"
  4. #include "OLED.h"
  5. #include "MyRTC.h"
  6. #include "Timer.h"
  7.  
  8. int main(void)
  9. {	
  10. 	delay_init();  
  11. 	uart_init(9600);
  12. 	OLED_Init();
  13. 	MyRTC_Init();
  14. 	IIC_Init();
  15. 	Timer_Init();
  16. 	
  17. 	MyRTC_SetTime();
  18. 	while(1)
  19. 	{
  20. 		
  21. 		
  22. 		//delay_ms(1000);
  23. 	}
  24. }
  25. void TIM2_IRQHandler(void)
  26. {
  27. 	if (TIM_GetITStatus(TIM2, TIM_IT_Update) == SET)
  28. 	{
  29. 		
  30. 		read_AHT20_once();
  31. 		MyRTC_ReadTime();
  32. 		TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
  33. 	}
  34. }

到此，工程文件建立完毕！库函数工程搭建与完善成功！！！工程搭建与完善完成情况截图如下所示：

​​​​​​​

 八、第二小问的电路连接

 1、ST-Link的电脑环境配置以及与STM32的电路连接：

请参考我的这篇博客：stm32通过寄存器方式利用GPIO端口点亮LED_-HSheng的博客-CSDN博客

这里附上ST-Link与STM32的电路连接图：

 2、基于IIC协议的4排针引脚的OLED与STM32的电路连接如下：

GND——GND；

VCC——3.3V；

SCL——PB8；

SDA——PB9；

3、温湿度采集模块AHT20与STM32的连接如下图所示： 

这里附上AHT20的引脚简介图：

4、连接好的板子电路实物图展示：

九、第二小问库函数工程烧录运行

1、编译与烧录，如何通过ST-Link烧录进STM32中，参考我的这篇博客：

stm32通过寄存器方式利用GPIO端口点亮LED_-HSheng的博客-CSDN博客

2、 工程运行结果展示：

十、总结

       在完成STM32作业的过程中，通过深入研究STM32F103的RTC原理，我成功实现了读取内部时钟信息和与PC上位机的串口通信。结合带有SPI或IIC接口的OLED屏幕模块，我实现了将时钟信息及AHT20传感器的温湿度数据显示在OLED上，完成了实验要求。这次经历使我更深入了解了嵌入式系统开发，提升了对RTC和传感器的应用能力。

      同时本实验让我深刻体验了理论知识与实际应用的结合。通过与RTC和OLED屏幕的互联，我更加自信地处理了嵌入式系统中的硬件交互问题。这次项目培养了我的解决问题的能力，同时也加深了对实时时钟和传感器应用的理解，为未来的嵌入式开发奠定了坚实的基础。   

十一、参考资料

 1、【精选】STM32日历读取，设置和输出_st32日期流程图_一只特立独行的猪 ️的博客-CSDN博客

2、STM32日历读取，设置和输出_stm32 日历_机智的橙子的博客-CSDN博客

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

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

  

闽ICP备14008679号