• STM32初学-外部RTC时钟芯片DS3231

            RTC(Real_Time Clock)即实时时钟，它是电子产品中不可或缺的东西。其最直接的作用就是时钟功能。细心的朋友可以发现，当我们的电脑或者手机没联网时，仍然可以正常显示日期与时钟，这就是RTC的功劳。

            RTC的运行无需网络连接，只需一个频率固定的振荡源和一个计数器，就能实现精准的计时。假如有一个振荡源，其每秒固定振荡1000次，那我们就可以用计数器对振荡进行计数，每振荡1000次，代表时间过去了1s，然后复位计数器并开始新的计数，同时，秒寄存器加1。如此循环，就能实现时钟的走时。

    21ad4e7542c24f098061485fea6c9146.png

            在单片机的某些使用场景下，RTC时钟是不可或缺的，例如使用了文件系统，就必须启用RTC时钟，用于更新文件的时间。

            STM32内置了RTC时钟模块，只要配置好参数，就能启用RTC。RTC的时钟振荡源可以来自内部也可以来自外部。内部时钟源由HCLK经过分频得到，外部时钟源则由石英晶振提供。

    973457b0641540aaa604c7e12f8583a6.png

             内部时钟源是由高频晶振分频得到，所以其精度计时不高，为了准确计时，一般采用外部时钟源。外部时钟源一般选用32.768KHz的石英晶振。这种参数的石英晶振一秒钟能振荡32768次，正好对应2^16。

    b98f599ebe9bc4ec1b60da566ec7fa39.jpeg

            然而，即使采用了外部晶振的RTC，其精度仍然是有限的。因为晶振外置，线路上的寄生电容电感、温度都会影响晶振频率，短时间可能看不出误差，但是时间一长，其误差就大了。

            如果想进一步减小RTC的误差，则需要使用RTC时钟芯片。时钟芯片的优势在于其内部带有温度补偿功能，能通过检测环境温度来对晶振进行误差补偿，减小计时误差。且时钟芯片的年、月、日等时间数据单独存储在内部的RAM中，对单片机来说，只要通过串口读取特定寄存器地址的数据就能得到时间参数，而无需再去计算。现在流行的时钟芯片很多，如DS1302、 DS1307。但是这些芯片仍需要外置晶振才能工作，所以仍存在误差。

            所以一种在内部集成晶振的时钟芯片应运而生。DS3231就是这样一种时钟芯片。其精度最高可以达到±2ppm。实测6个月在常温下连续运行，误差不超过1分钟。

    61f5e66528d448859fee62d6a3aed26b.png

         DS3231采用快速IIC通信进行数据传输，最高时钟频率400KHz。还带有闹钟，复位等功能。224a5ac113814714a5bbfbb80213de94.png

     DS3231有两种封装，引脚功能一样，16pin的封装只是多了八个空引脚。

    如下是其应用电路。9fb591b6e7464754a250edaffc08b806.png

            可以看到该芯片有两个电源输入，一个是VCC，另一个是Vbat。VCC我们可以与单片机共用3.3V电源，Vbat则接到一颗纽扣电池的正极。当单片机供电断开后，DS3231仍能靠纽扣电池供电维持计时功能，但是无法进行IIC通信，也就是不能读取时间数据，恢复VCC供电后，IIC通信随之被唤醒。

            INT是个漏极开路的输出，如果想输出高电平则需要外接上拉电阻，该引脚可连接到单片机IO口作为单片机的外部中断源。

            32kHz是一个固定输出32KHz频率方波的IO口，也可做为单片机的计时源。同为开漏输出。

            RST是芯片的复位脚，如果没有特别需要，可以直接悬空。该芯片无需复位也能直接初始化。

    软件部分                                                          

            这里我使用的是STM32F4，F1的芯片也是兼容的，只是需要把头文件改成F1的。IIC通信采用软件模拟。iic的软件模拟可参考文章（STM32单片机-IIC通信（软件模拟）），这里我就不详细讲IIC软件模拟的原理了。接下来我们看程序。

    1，我使用的是PB8和PB9分别做为IIC的SCL与SDA。如果想使用其他IO，稍微修改下就行。

    1. #include
    2.  
    3. /********************软件模拟IIC*********************/
    4. /*****************PB8=SCL，PB9=SDA*****************/
    5.  
    6.  
    7. #define	DS3231_ADDRESS_Write	0xD0
    8. #define	DS3231_ADDRESS_Read		0xD1
    9.  
    10.  
    11. /**************DS3231内部寄存器地址***************/
    12.  
    13. #define DS3231_SEC        0x00  // 秒
    14. #define DS3231_MIN        0x01  //分
    15. #define DS3231_HOUR       0x02	//时
    16. #define DS3231_WEEK       0x03	//周
    17. #define DS3231_DATE       0x04	//日
    18. #define DS3231_MONTH      0x05	//月
    19. #define DS3231_YEAR       0x06	//年
    20.  
    21. #define DS3231_AL1SEC     0x07
    22. #define DS3231_AL1MIN     0x08
    23. #define DS3231_AL1HOUR    0x09
    24. #define DS3231_AL1WDAY    0x0A
    25.  
    26. #define DS3231_AL2MIN     0x0B
    27. #define DS3231_AL2HOUR    0x0C
    28. #define DS3231_AL2WDAY    0x0D
    29.  
    30. #define DS3231_CONTROL          0x0E
    31. #define DS3231_STATUS           0x0F
    32. #define DS3231_AGING_OFFSET     0x0F
    33. #define DS3231_TMP_High         0x11
    34. #define DS3231_TMP_LOW          0x12
    35.  
    36. /******DS3231内部寄存器地址******/
    37. /**************END**************/
    38.  
    39.  
    40. #define Read_IIC_SDA GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_9)		//定义Read_IIC_SDA为PB11的输入值
    41.  
    42. #define IIC_SCL_H() GPIO_SetBits(GPIOB,GPIO_Pin_8)					//定义IIC_SCL_H()函数为将RES（PB10）置高电平	
    43. #define IIC_SCL_L() GPIO_ResetBits(GPIOB,GPIO_Pin_8)				//定义IIC_SCL_L()函数为将RES（PB10）置低电平	
    44.  
    45. #define IIC_SDA_H() GPIO_SetBits(GPIOB,GPIO_Pin_9)					//定义IIC_SDA_H()函数为将RES（PB11）置高电平	
    46. #define IIC_SDA_L() GPIO_ResetBits(GPIOB,GPIO_Pin_9)				//定义IIC_SDA_L()函数为将RES（PB11）置低电平	
    47.  
    48.  
    49.  //最后读取到的时间数据将赋值到下面这几个变量
    50. u8 RTC_Sec,RTC_Min,RTC_Hour,RTC_Week,RTC_Date,RTC_Month;   
    51. u16 RTC_Year;
    52.  
    53.  
    54. void IIC2_SoftInit(void)
    55. {
    56.     GPIO_InitTypeDef GPIO_InitStructure;
    57. 	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
    58.     GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8 | GPIO_Pin_9; 			//10--SCL   11--SDA；PB10 PB11
    59.     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    60.     GPIO_InitStructure.GPIO_Mode=GPIO_Mode_OUT;
    61. 	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;			//OD开漏
    62. 	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;			//上拉
    63.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    64. }
    65.  
    66. /******* 设置SDA为输出*******/
    67.  
    68. void SDA_OUT(void)
    69. {
    70.     GPIO_InitTypeDef GPIO_InitStructure;
    71.     GPIO_InitStructure.GPIO_Pin= GPIO_Pin_9;
    72.     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    73.     GPIO_InitStructure.GPIO_Mode=GPIO_Mode_OUT;	//推挽输出
    74. 	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;			//OD开漏
    75. 	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;			//上拉
    76.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    77. }
    78.  
    79. /******* 设置SDA为输入*******/
    80.  
    81. void SDA_IN(void)
    82. {
    83.     GPIO_InitTypeDef GPIO_InitStructure;
    84.     GPIO_InitStructure.GPIO_Pin= GPIO_Pin_9;
    85.     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    86.     GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN;		//上拉输入
    87. 	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;			//OD开漏
    88. 	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;			//上拉
    89. 	GPIO_Init(GPIOB, &GPIO_InitStructure);
    90. }
    91.  
    92.  
    93.  
    94.  void IIC_Start(void)			//起始信号
    95. {
    96.     SDA_OUT();			//把SDA作为输出，初始化为推挽输出
    97.     IIC_SDA_H();		//SDA输出高电平
    98.     IIC_SCL_H();		//SCL输出高电平
    99.     Delay_us(2);
    100.     IIC_SDA_L();		//SDA输出低点评
    101.     Delay_us(2);
    102.     IIC_SCL_L();		//SCL输出低电平
    103.     Delay_us(2);
    104. }
    105.  
    106. void IIC_Stop(void)		//停止信号
    107. {
    108.     IIC_SCL_H();		//SCL输出高电平
    109.     IIC_SDA_L();		//SDA输出低点评
    110.     Delay_us(2);
    111.     IIC_SDA_H();		//SDA输出高电平
    112.     Delay_us(2);
    113. }
    114.  
    115.  
    116. u8 IIC_Wait_Ask(void)		//等待应答信号
    117. {
    118.     u8 count;
    119.     IIC_SDA_H();
    120. 	Delay_us(2);
    121. 	SDA_IN();
    122. 	Delay_us(2);
    123.     IIC_SCL_H();
    124.     Delay_us(2);
    125.     while(Read_IIC_SDA)
    126.     {
    127.         count++;
    128.         if(count>250)
    129.         {
    130.             IIC_Stop();				//如果长时间无应答，则认为从站故障，终止数据传输，并返回1
    131.             return 1;
    132.         }   
    133.     }
    134.     IIC_SCL_L();
    135.     Delay_us(1);
    136.     return 0;
    137. }
    138.  
    139.  
    140.  
    141. void IIC_Ack(void)		//应答信号
    142. {
    143.     IIC_SCL_L();
    144.     SDA_OUT();
    145.     IIC_SDA_L();
    146.     Delay_us(2);
    147.     IIC_SCL_H();
    148.     Delay_us(2);
    149.     IIC_SCL_L();
    150. }
    151.  
    152. void IIC_NAck(void)		//主机不产生应答信号NACK
    153. {
    154.     IIC_SCL_L();
    155.     SDA_OUT();
    156.     IIC_SDA_H();
    157.     Delay_us(2);
    158.     IIC_SCL_H();
    159.     Delay_us(2);
    160.     IIC_SCL_L();
    161. }
    162.  
    163.  
    164.  
    165. void IIC_WriteByte(u8 data)			//写1Byte数据，每个数据都是以写1Byte作为基本单位
    166. {
    167.     u8 i;
    168.     SDA_OUT();						//SDA切换到数据输出模式
    169. 	Delay_us(2);
    170.     for(i=0;i<8;i++)				//循环传输1Byte数据，即8bit
    171.     {
    172.         IIC_SCL_L();				//SCL置低电平，为下个Bit数据做准备
    173. 		Delay_us(2);
    174.         if(data & 0x80)     		//MSB,如果date的第八位为1
    175.             IIC_SDA_H();			//则SDA置高
    176.         else
    177.             IIC_SDA_L();			//否则置低
    178. 		Delay_us(1);
    179.         IIC_SCL_H();				//SCL拉高，产生一个时钟信号，从机读取SDA状态
    180.         Delay_us(2);				//延时，丛机在这段时间读取SDA状态
    181.         IIC_SCL_L();				//延时后拉低SCL，为下个Bit数据做准备
    182.         data<<=1;					//date左移1位，下一bit变成第八位
    183.     }
    184. }
    185.  
    186. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
    187.  
    188.  
    189.  
    190. u8 IIC_Read_Byte(const unsigned char ack)
    191. {
    192. 	u8 i,receive=0;
    193. 	SDA_IN();			//SDA设置为输入
    194. 	Delay_us(2);
    195.     for(i=0;i<8;i++ )
    196. 	{
    197. 		IIC_SCL_L(); 
    198. 		Delay_us(2);
    199. 		IIC_SCL_H();
    200.         receive<<=1;
    201. 		Delay_us(2);
    202.         if(Read_IIC_SDA)
    203. 			receive++;   
    204. 		Delay_us(2); 
    205.     }					 
    206.     if (!ack)
    207.         IIC_NAck();		//发送nACK
    208.     else
    209.         IIC_Ack();		 //发送ACK   
    210.     return receive;
    211. }
    212.  
    213.  
    214. void IIC_DS3231_ByteWrite(u8 WriteAddr,u8 date)
    215. {
    216. 	IIC_Start();		//起始信号
    217. 	IIC_WriteByte(DS3231_ADDRESS_Write);		//DS3231设备地址，写
    218. 	IIC_Wait_Ask();				//等待应答
    219. 	IIC_WriteByte(WriteAddr);	//寄存器地址
    220. 	IIC_Wait_Ask();				//等待应答
    221. 	IIC_WriteByte(date);		//写入数据
    222. 	IIC_Wait_Ask();				//等待应答
    223. 	IIC_Stop();					//结束信号
    224. }
    225.  
    226. u8 IIC_DS3231_ByteRead(u8 ReadAddr)
    227. {
    228. 	u8 data = 0;
    229. 	IIC_Start();										//产生起始位
    230. 	IIC_WriteByte(DS3231_ADDRESS_Write); 				//发送从机地址（写模式D0）
    231. 	IIC_Wait_Ask();				//等待应答
    232. 	IIC_WriteByte(ReadAddr);							//发送寄存器地址
    233. 	IIC_Wait_Ask();				//等待应答
    234. 	IIC_Start();										//重复起始信号
    235. 	IIC_WriteByte(DS3231_ADDRESS_Read);		//发送从机地址（读模式）
    236. 	IIC_Wait_Ask();							//等待应答
    237. 	data = IIC_Read_Byte(0);				//读取数据，参数设为0 --- NACK
    238. 	IIC_Stop();
    239. 	return data;
    240. }
    241.  
    242. void IIC_DS3231_ReadAll(void)		//读取所有时间数据并转换
    243. {
    244. 	u8 Data_Sec,Data_Min,Data_Hour,Data_Week,Data_Date,Data_Month,Data_Year;
    245. 	u8 Low,High;
    246. 	
    247. 	Data_Sec= IIC_DS3231_ByteRead(DS3231_SEC);			//读取数据秒
    248. 	Data_Min = IIC_DS3231_ByteRead(DS3231_MIN);			//读取数据分
    249. 	Data_Hour = IIC_DS3231_ByteRead(DS3231_HOUR);		//读取数据时
    250. 	Data_Week = IIC_DS3231_ByteRead(DS3231_WEEK);		//读取数据周
    251. 	Data_Date = IIC_DS3231_ByteRead(DS3231_DATE);			//读取数据日
    252. 	Data_Month = IIC_DS3231_ByteRead(DS3231_MONTH);		//读取数据月
    253. 	Data_Year = IIC_DS3231_ByteRead(DS3231_YEAR);		//读取数据年
    254. 	
    255. 	Low=Data_Sec&0x0f;						//取低四位
    256. 	High=(( Data_Sec& 0xf0) >> 4);			//取高四位
    257. 	RTC_Sec=High*10+Low;					//转换秒（高四位*10+低四位）
    258. 	
    259. 	Low=Data_Min&0x0f;
    260. 	High=(( Data_Min& 0xf0) >> 4);
    261. 	RTC_Min=High*10+Low;					//转换分
    262. 	
    263. 	Low=Data_Hour&0x0f;
    264. 	High=(( Data_Hour& 0x30) >> 4);
    265. 	RTC_Hour=High*10+Low;					//转换时（高两位*10+低四位）
    266.  
    267. 	RTC_Week=Data_Week;						//转换周（不需要转换）
    268. 	
    269. 	Low=Data_Date&0x0f;
    270. 	High=(( Data_Date& 0xf0) >> 4);
    271. 	RTC_Date=High*10+Low;					//转换日
    272. 	
    273. 	Low=Data_Month&0x0f;
    274. 	High=(( Data_Month& 0x10) >> 4);
    275. 	RTC_Month=High*10+Low;					//转换月
    276. 	
    277. 	Low=Data_Year&0x0f;
    278. 	High=(( Data_Year& 0xf0) >> 4);
    279. 	RTC_Year=((Data_Month>>7)+20)*100+High*10+Low;	//转换年(世纪*100+高四位*10+低四位)		
    280. }
    281.  
    282. void IIC_DS3231_WriteAll(u16 Year,u8 Month,u8 Date,u8 Week,u8 Hour,u8 Min,u8 Sec)
    283. {	
    284. 	u8 Sec_Date,Min_Date,Hour_Date,Week_Date,Date_Date,Month_Date,Year_Date;
    285. 	u8 H_Bit,L_Bit;
    286. 	
    287. 	H_Bit=(Sec/10)<<4;			//取高四位
    288. 	L_Bit=Sec%10;				//取低四位
    289. 	Sec_Date=H_Bit|L_Bit;		//合并成八位
    290. 	
    291. 	H_Bit=(Min/10)<<4;
    292. 	L_Bit=Min%10;
    293. 	Min_Date=H_Bit|L_Bit;
    294. 	
    295. 	H_Bit=Hour/10;
    296. 	L_Bit=Hour%10;
    297. 	Hour_Date=(H_Bit<<4)|L_Bit;
    298. 		
    299. 	Week_Date=Week;
    300. 	
    301. 	H_Bit=Date/10;
    302. 	L_Bit=Date%10;
    303. 	Date_Date=(H_Bit<<4)|L_Bit;
    304. 	
    305. 	if(Year/100==20)
    306. 	{	
    307. 		H_Bit=Month/10;
    308. 		L_Bit=Month%10;
    309. 		Month_Date=(H_Bit<<4)|L_Bit;
    310. 		
    311. 		H_Bit=(Year-2000)/10;
    312. 		L_Bit=(Year-2000)%10;
    313. 		Year_Date=(H_Bit<<4)|L_Bit;
    314. 		
    315. 	}
    316. 	else
    317. 	{
    318. 		H_Bit=Month/10+8;		//05h第8位如果是1，则为22世纪
    319. 		L_Bit=Month%10;
    320. 		Month_Date=(H_Bit<<4)|L_Bit;
    321. 		
    322. 		H_Bit=(Year-2100)/10;
    323. 		L_Bit=(Year-2100)%10;
    324. 		Year_Date=(H_Bit<<4)|L_Bit;
    325. 	}
    326. 	IIC_DS3231_ByteWrite(DS3231_YEAR,Year_Date);	
    327. 	IIC_DS3231_ByteWrite(DS3231_MONTH,Month_Date);
    328. 	IIC_DS3231_ByteWrite(DS3231_DATE,Date_Date);
    329. 	IIC_DS3231_ByteWrite(DS3231_WEEK,Week_Date);
    330. 	IIC_DS3231_ByteWrite(DS3231_HOUR,Hour_Date);
    331. 	IIC_DS3231_ByteWrite(DS3231_MIN,Min_Date);
    332. 	IIC_DS3231_ByteWrite(DS3231_SEC,Sec_Date);
    333. 	
    334. }
    335.  
    336. void DS3231_Init(void)		//DS3231初始化
    337. {
    338. 	IIC_DS3231_ByteWrite(0x0E,0x40);		//使能1Hz方波，使能振荡器	
    339. 	IIC_DS3231_ByteWrite(0x0F,0x00);		//启动振荡器
    340. 	Delay_ms(100);    //延时等待完全起振
    341. }

     延时函数，IIC软件模拟需要用到延时函数，这里我采用的是滴答定时器进行延时，需要注意，F1 与F4的延时函数不能共用，因为主频不一样。

    1. /****************************************************************
    2.  * Function:    Delay_us
    3.  * Description: Microsecond delay.
    4.  * Input:       nus
    5.  * Output:
    6.  * Return:
    7. *****************************************************************/
    8. void Delay_us(u16 nus)
    9. { 
    10.   //Delay_Init();
    11. 	u32 temp;
    12.     SysTick->LOAD = SystemCoreClock / 8000000 * nus;  /* Time load (SysTick-> LOAD is 24bit) */
    13.     SysTick->VAL = 0x000000;                          /* Empty counter */
    14.     SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;         /* Start the countdown */
    15.  
    16.     do
    17.     {
    18. 		temp = SysTick->CTRL;
    19.     }
    20.     while(temp&0x01 && !(temp&(1<<16)));        /* Wait time is reached */
    21.  
    22.     SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;  /* Close Counter */
    23.     SysTick->VAL = 0x000000;                    /* Empty counter */
    24. }
    25.  
    26. /****************************************************************
    27.  * Function:    Delay_ms
    28.  * Description: Millisecond delay.
    29.  * Input:       nms
    30.  * Output:
    31.  * Return:
    32. *****************************************************************/
    33. void Delay_ms(u16 nms)
    34. {
    35. 	u32 temp;
    36. 	while(nms > 500)	//24位定时器最大计数值2^24=16777216,计时器时钟频率初始化为21MHz，最大计时时间为16777216/21000000=0.798s=798ms，所以需要多次复位
    37. 	{
    38. 		
    39. 		SysTick->LOAD = SystemCoreClock / 8000 * 500; /* Time load (SysTick-> LOAD is 24bit) */
    40. 		SysTick->VAL = 0x000000;                      /* Empty counter */
    41. 		SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;     /* Start the countdown */
    42.  
    43. 		do
    44. 		{
    45. 			temp = SysTick->CTRL;
    46. 		}
    47. 		while(temp&0x01 && !(temp&(1<<16)));        /* Wait time is reached */
    48.  
    49. 		SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;  /* Close Counter */
    50. 		SysTick->VAL = 0x000000;                    /* Empty counter */
    51.     
    52. 		nms -= 500;
    53. 	}
    54.   
    55. 	SysTick->LOAD = SystemCoreClock / 8000 * nms; /* Time load (SysTick-> LOAD is 24bit) */
    56. 	SysTick->VAL = 0x000000;                      /* Empty counter */
    57. 	SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;     /* Start the countdown */
    58.  
    59. 	do
    60. 	{
    61. 		temp = SysTick->CTRL;
    62. 	}
    63. 	while(temp&0x01 && !(temp&(1<<16)));        /* Wait time is reached */
    64.  
    65. 	SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;  /* Close Counter */
    66. 	SysTick->VAL = 0x000000;                    /* Empty counter */
    67. }

    嘀嗒定时器初始化：在启用延时函数前必须对定时器进行初始化，配置对应的参数。这里我用主频HCLK的八分频做为其定时频率，即21MHz。也就是一秒钟对应定时器的21000000。

    1. void Delay_Init(void)			//嘀嗒计时器初始化，用于Delay函数
    2. {
    3.     SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);		//计数器频率：168M/8=21MHZ
    4.     SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;  				/* Disability SysTick counter */
    5. }

    main函数：初始化延时函数，初始化DS3231 ，讲时间写入DS3231，讲时间读取出来

    1. #include    //F4头文件
    2.  
    3. void main(void)
    4. {
    5.     Delay_Init();                //嘀嗒定时器初始化，必须初始化，延时依靠嘀嗒计时器
    6.  
    7.     DS3231_Init();		//DS3231初始化，唤醒DS3231，并启动振荡器
    8.     IIC_DS3231_WriteAll(2023,10,1,1,12,00,00);   //设置时间函数,实例为2023年10月1日12：00：00
    9.     IIC_DS3231_ReadAll();        //读取DS3231所有时间数据
    10. }

    最终读取转换后的时钟数据分别为这些变量：u8 RTC_Sec,RTC_Min,RTC_Hour,RTC_Week,RTC_Date,RTC_Month;   
    u16 RTC_Year;

    可以通过串口打印，或者其他方式显示出当前时间。

    这里我将时间显示到LCD屏幕上。

    如果觉得本文有用，就点个赞吧~

  • 相关阅读:
    初级网络工程师之入门到入狱（一）
    提升cartographer局部全局SLAM实时性，降低cartographer在低性能板上的堵塞
    网站变灰白css
    Hive简介及安装配置
    Java 并发编程解析 | 如何正确理解Java领域中的锁机制，我们一般需要掌握哪些理论知识？
    Could not read from boot medium. System halted.
    C语言实现面向对象编程 | 干货
    恢复二叉搜索树[根据题意模拟-＞发现问题-＞分析问题-＞见招拆招]
    C 标准库 - ＜string.h＞
    ROS2——常用命令行（四）
  • 原文地址：https://blog.csdn.net/qq_55203246/article/details/129771464