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

S-35390A计时芯片介绍及开发方案

作者：从前慢现在也慢 | 2024-02-26 06:06:12

赞

踩

S-35390A计时芯片介绍及开发方案

计时芯片

S-35390A芯片是计时芯片，一般用来计算时间。低功耗，宽电压，受温度影响小，适用于很多电路。它有一个问题，不阻止用户设置不存在的时间，设置进去之后计时或者闹钟定时会出错。

规格书阅读

首先我们先读懂这个芯片是怎么用的。

引脚表

基本上一看这个引脚表就知道大概，1号和5号引脚是中断输出引脚，2号和3号引脚之间应该接个晶振，6号和7号引脚通过IIC跟主控芯片通讯，其余的都是电源和地。

模块框图

大概就能知道里面的框架是啥样的，里面最主要就是实时时间的寄存器，通过跟中断1和中断2寄存器对比决定两路中断的输出。具体时间通过中间的总线借助IIC串口通讯模块发出去。另外就是有几个检测电源电压的寄存器、状态寄存器、时钟校正寄存器和一个给用户可以当做E方用的自由寄存器。

通讯数据配置

跟普通的IIC一样，主控芯片先发个设备号0110，跟着3位的命令，1位的读写方向，等到计时芯片ACK之后，继续发送剩下的数据。

命令表格

这里有所有的命令，读写状态寄存器1和2、读写实时数据1和2、读写中断寄存器1和2、存取时钟校正寄存器和自由寄存器。

标1的是只写。标2的是用户自由寄存器，对应上面框图的用户自由寄存器。标3和4的是只读。标5的是测试位，使用的时候要保证为0。标6的怎么写都不影响。

状态寄存器1

POC检测电源电流，初始化的时候是0，有电流的时候是1，如果上电之后为0，就要重启整个芯片。

BLD检测电源电压，正常为0,读到是1的时候要重启整个芯片了。

INT1和INT2是中断事件发生标志位。

SC0和SC1都是用户自由定义的。

12/24如果是0就是12小时制，如果是1就是24小时制。

RESET平时为0，写个1进去就重启芯片。

状态寄存器2

TEST测试位设置为0就行，当设置为1的时候，INT1会输出1Hz的方波。

INT2AE、 INT2ME、 INT2FE共同决定了中断输出2引脚的输出模式：无中断、输出用户设定的频率、每分钟边沿中断、50%占空比的每分钟周期中断、闹钟模式。

INT1AE、 INT1ME、 INT1FE共同决定了中断输出1引脚的输出模式：无中断、输出用户设定的频率、每分钟边沿中断、50%占空比的每分钟周期中断、闹钟模式、每分钟周期中断、输出32.768kHz。

实时数据1和2

以写入实时数据寄存器1为例，流程如下。

里面的年是按照西历来计算的，只能写0-99，使用BCD码，低位在前。

譬如2053年，就写入53，二进制Y1-Y80就是1100 1010.

AM/PM如果是24小时制就无所谓写什么，如果是12小时制0是am，1就是pm.

后面的实时数据寄存器2也是一样。

中断寄存器1和2

根据状态寄存器2的设置，选择中断输出引脚是闹钟模式或者输出用户设定的频率。

INT1AE = 1, INT1ME = 0, INT1FE = 0，就是闹钟模式。
INT1ME = 0, INT1FE = 1，就是输出用户设定的频率。
其实就是对应状态寄存器那个表格，INT2也是一样。

闹钟模式

时间到了就触发中断，里面的AM/PM要跟实时时钟里面一致。

B0的三个标志位表示设置的周、时、分是否有效，譬如下面这个设置闹钟为每天晚上7点，周的标志位就需要为0.

输出用户设定的频率

频率是每个位累加的，SC是用户自由寄存器。

校准寄存器

可以提前和延迟一定的时间。

用户自由寄存器

写一些用户想存储的信息，当做E方使用

使用注意事项

上电后POC为0，或者POC为1但是INT没有输出1 Hz方波，芯片内部数据可能处于不确定状态，需要重新上电。
上电之后由于检测电路正在工作，在上电后至少0.5秒后才进行数据传输。

接口编写

基本定义

命令

  1. #define S35390_TIME_ADDRESS             0x32
  2. #define S35390_STATUS1_ADDRESS       	0x30
  3. #define S35390_STATUS2_ADDRESS       	0x31
  4. #define S35390_INT1_REG_ADDRESS       	0x34 
  5. #define S35390_INT2_REG_ADDRESS       	0x35

当前时间结构体和中断闹钟结构体

  1. typedef	struct
  2. {
  3. 	unsigned int 	year;		//year
  4. 	unsigned char 	month;		//month
  5. 	unsigned char 	day;		//day
  6.     unsigned char 	hour;		//hour
  7. 	unsigned char 	minute;		//minute
  8. 	unsigned char 	second;		//second
  9. 	unsigned char 	week;		//week
  10. }rtc_time;
  11.  
  12. typedef	struct
  13. {
  14. 	unsigned char 	minute;		//minute
  15. 	unsigned char 	hour;		//hour
  16.     unsigned char 	week;		//week
  17.     unsigned char 	min_en;		//minute enable
  18.     unsigned char 	hour_en;	//hour enable
  19.     unsigned char 	week_en;	//min enable
  20. }rtc_alarm;

接口

RTC_S35390_Init

初始化函数里面只是要配置下主控芯片的IIC外设，设置下上电默认时间。

S35390_ReadRegs

读取多字节数据

  1. bool S35390_ReadRegs(uint8_t addr, uint8_t length,uint8_t *values)
  2. {
  3. 	status_t ret=STATUS_BUSY;
  4.     uint8_t Try = 3;
  5.  
  6.     if(xSemaphore_i2c != NULL )
  7.     {
  8.         if( xSemaphoreTake( xSemaphore_i2c, ( TickType_t ) 50 ) == pdTRUE )//获取信号量
  9.         {
  10.             while((Try--)&&(ret != STATUS_SUCCESS))//最多尝试3次
  11. 			{
  12.             	 lpi2cMasterState.slaveAddress = addr;//读取地址
  13.  
  14.                 /* Request data from the bus slave */
  15.                 ret = I2C_DRV_MasterReceiveDataBlock(INST_LPI2C1,values,length,true,10);
  16. 			}
  17.             xSemaphoreGive( xSemaphore_i2c);//释放信号量
  18.         }
  19.     }
  20.     
  21.     if(ret != STATUS_SUCCESS)//读出失败
  22. 	{
  23. 		I2C_Reset();//重新初始化IIC模块
  24. 	}
  25.     return ret;
  26. }

S35390_WriteRegs

读取多字节数据

  1. static bool S35390_WriteRegs(uint8_t addr, uint8_t length, uint8_t *values)
  2. {
  3. 	status_t ret=STATUS_BUSY;
  4. 	uint8_t Try = 3;
  5.  
  6. 	uint8_t masterbuffer[32]={0};
  7. 	memcpy(&masterbuffer[0],values,length);
  8.  
  9.     if( xSemaphore_i2c != NULL )
  10.     {
  11.         if( xSemaphoreTake( xSemaphore_i2c, ( TickType_t ) 50 ) == pdTRUE )//获取信号量
  12.         {
  13. 			while((Try--)&&(ret != STATUS_SUCCESS))//最多尝试3次
  14. 			{
  15. 				lpi2cMasterState.slaveAddress = addr;//写入地址
  16. 				
  17. 				ret=I2C_DRV_MasterSendDataBlock(INST_LPI2C1, masterbuffer, length, true,100UL);
  18. 			}
  19. 			xSemaphoreGive( xSemaphore_i2c);//释放信号量
  20.         }
  21.     }
  22.  
  23.     if(ret != STATUS_SUCCESS)//写入失败
  24.     {
  25. 		I2C_Reset();//重新初始化IIC模块
  26.     }
  27.     
  28.     return  ret;
  29. }

S35390_GetYear

别被这个名字骗了，其实就是将获取的年数据BCD码转成十进制数据。

  1. static uint8_t S35390_GetYear(uint8_t regYearData )
  2. {
  3. 	uint8_t timeYearData = 0x00;
  4.  
  5. 	if ( regYearData & 1 )
  6. 	{
  7. 		timeYearData += 80;
  8. 	}
  9. 	regYearData >>= 1;
  10. 	if ( regYearData & 1 )
  11. 	{
  12. 		timeYearData += 40;
  13. 	}
  14. 	regYearData >>= 1;
  15. 	if ( regYearData & 1 )
  16. 	{
  17. 		timeYearData += 20;
  18. 	}
  19. 	regYearData >>= 1;
  20. 	if ( regYearData & 1 )
  21. 	{
  22. 		timeYearData += 10;
  23. 	}
  24. 	regYearData >>= 1;
  25. 	if ( regYearData & 1 )
  26. 	{
  27. 		timeYearData += 8;
  28. 	}
  29. 	regYearData >>= 1;
  30. 	if ( regYearData & 1 )
  31. 	{
  32. 		timeYearData += 4;
  33. 	}
  34. 	regYearData >>= 1;
  35. 	if ( regYearData & 1 )
  36. 	{
  37. 		timeYearData += 2;
  38. 	}
  39. 	regYearData >>= 1;
  40. 	if ( regYearData & 1 )
  41. 	{
  42. 		timeYearData += 1;
  43. 	}
  44.  
  45. 	if ( timeYearData > 99 )//最大限制
  46. 	{
  47. 		timeYearData = 99;
  48. 	}
  49. 	else
  50. 	{
  51. 		; /* do nothing*/
  52. 	}
  53.  
  54. 	return 	timeYearData;
  55. }

S35390_GetMonth

获取月数据BCD码转成十进制数据。

  1. static uint8_t S35390_GetMonth(uint8_t regMonthData )
  2. {
  3. 	uint8_t timeMonthData = 0x00;
  4.  
  5. 	regMonthData >>= 3;
  6. 	if ( regMonthData & 1 )
  7. 	{
  8. 		timeMonthData += 10;
  9. 	}
  10. 	regMonthData >>= 1;
  11. 	if ( regMonthData & 1 )
  12. 	{
  13. 		timeMonthData += 8;
  14. 	}
  15. 	regMonthData >>= 1;
  16. 	if ( regMonthData & 1 )
  17. 	{
  18. 		timeMonthData += 4;
  19. 	}
  20. 	regMonthData >>= 1;
  21. 	if ( regMonthData & 1 )
  22. 	{
  23. 		timeMonthData += 2;
  24. 	}
  25. 	regMonthData >>= 1;
  26. 	if ( regMonthData & 1 )
  27. 	{
  28. 		timeMonthData += 1;
  29. 	}
  30.  
  31. 	if ( timeMonthData == 0x00 )//最小限制
  32. 	{
  33. 		timeMonthData = 0x01;
  34. 	}
  35. 	else if ( timeMonthData > 12 )//最大限制
  36. 	{
  37. 		timeMonthData = 12;
  38. 	}
  39. 	else
  40. 	{
  41. 		; /* do nothing*/
  42. 	}
  43.  
  44. 	return 	timeMonthData;
  45. }

S35390_GetDay

获取日数据BCD码转成十进制数据。

  1. static uint8_t S35390_GetDay(uint8_t regDayData )
  2. {
  3. 	uint8_t timeDayData = 0x00;
  4.  
  5. 	regDayData >>= 2;
  6. 	if ( regDayData & 1 )
  7. 	{
  8. 		timeDayData += 20;
  9. 	}
  10. 	regDayData >>= 1;
  11. 	if ( regDayData & 1 )
  12. 	{
  13. 		timeDayData += 10;
  14. 	}
  15. 	regDayData >>= 1;
  16. 	if ( regDayData & 1 )
  17. 	{
  18. 		timeDayData += 8;
  19. 	}
  20. 	regDayData >>= 1;
  21. 	if ( regDayData & 1 )
  22. 	{
  23. 		timeDayData += 4;
  24. 	}
  25. 	regDayData >>= 1;
  26. 	if ( regDayData & 1 )
  27. 	{
  28. 		timeDayData += 2;
  29. 	}
  30. 	regDayData >>= 1;
  31. 	if ( regDayData & 1 )
  32. 	{
  33. 		timeDayData += 1;
  34. 	}
  35.  
  36. 	if ( timeDayData == 0 )//最小限制
  37. 	{
  38. 		timeDayData = 1;
  39. 	}
  40. 	else if ( timeDayData > 31 )//最大限制
  41. 	{
  42. 		timeDayData = 31;
  43. 	}
  44. 	else
  45. 	{
  46. 		; /* do nothing*/
  47. 	}
  48.  
  49. 	return 	timeDayData;
  50. }

S35390_GetWeek

获取周数据BCD码转成十进制数据。

  1. static uint8_t S35390_GetWeek(uint8_t regWeekData )
  2. {
  3. 	uint8_t timeWeekData = 0x00;
  4.  
  5. 	regWeekData >>= 5;
  6. 	if ( regWeekData & 1 )
  7. 	{
  8. 		timeWeekData += 4;
  9. 	}
  10. 	regWeekData >>= 1;
  11. 	if ( regWeekData & 1 )
  12. 	{
  13. 		timeWeekData += 2;
  14. 	}
  15. 	regWeekData >>= 1;
  16. 	if ( regWeekData & 1 )
  17. 	{
  18. 		timeWeekData += 1;
  19. 	}
  20.  
  21. 	return 	timeWeekData;
  22. }

S35390_GetHour

获取时数据BCD码转成十进制数据。

  1. static uint8_t S35390_GetHour(uint8_t regHourData )
  2. {
  3. 	uint8_t timeHourData = 0x00;
  4.  
  5. 	regHourData >>= 2;
  6. 	if ( regHourData & 1 )
  7. 	{
  8. 		timeHourData += 20;
  9. 	}
  10. 	regHourData >>= 1;
  11. 	if ( regHourData & 1 )
  12. 	{
  13. 		timeHourData += 10;
  14. 	}
  15. 	regHourData >>= 1;
  16. 	if ( regHourData & 1 )
  17. 	{
  18. 		timeHourData += 8;
  19. 	}
  20. 	regHourData >>= 1;
  21. 	if ( regHourData & 1 )
  22. 	{
  23. 		timeHourData += 4;
  24. 	}
  25. 	regHourData >>= 1;
  26. 	if ( regHourData & 1 )
  27. 	{
  28. 		timeHourData += 2;
  29. 	}
  30. 	regHourData >>= 1;
  31. 	if ( regHourData & 1 )
  32. 	{
  33. 		timeHourData += 1;
  34. 	}
  35.  
  36. 	if ( timeHourData > 23 )//最大限制
  37. 	{
  38. 		timeHourData = 23;
  39. 	}
  40. 	else
  41. 	{
  42. 		; /* do nothing*/
  43. 	}
  44.  
  45. 	return 	timeHourData;
  46. }

S35390_GetMinute

获取分数据BCD码转成十进制数据。

  1. static uint8_t S35390_GetMinute(uint8_t regMinuteData )
  2. {
  3. 	uint8_t timeMinuteData = 0x00;
  4.  
  5. 	regMinuteData >>= 1;
  6. 	if ( regMinuteData & 1 )
  7. 	{
  8. 		timeMinuteData += 40;
  9. 	}
  10. 	regMinuteData >>= 1;
  11. 	if ( regMinuteData & 1 )
  12. 	{
  13. 		timeMinuteData += 20;
  14. 	}
  15. 	regMinuteData >>= 1;
  16. 	if ( regMinuteData & 1 )
  17. 	{
  18. 		timeMinuteData += 10;
  19. 	}
  20. 	regMinuteData >>= 1;
  21. 	if ( regMinuteData & 1 )
  22. 	{
  23. 		timeMinuteData += 8;
  24. 	}
  25. 	regMinuteData >>= 1;
  26. 	if ( regMinuteData & 1 )
  27. 	{
  28. 		timeMinuteData += 4;
  29. 	}
  30. 	regMinuteData >>= 1;
  31. 	if ( regMinuteData & 1 )
  32. 	{
  33. 		timeMinuteData += 2;
  34. 	}
  35. 	regMinuteData >>= 1;
  36. 	if ( regMinuteData & 1 )
  37. 	{
  38. 		timeMinuteData += 1;
  39. 	}
  40.  
  41. 	if ( timeMinuteData > 59 )//最大限制
  42. 	{
  43. 		timeMinuteData = 59;
  44. 	}
  45. 	else
  46. 	{
  47. 		; /* do nothing*/
  48. 	}
  49.  
  50. 	return 	timeMinuteData;
  51. }

S35390_SetYear

别被它名字骗了，这个接口只是将年数据转换成BCD码，然后返回回去。

  1. static uint8_t S35390_SetYear(uint16_t timeYearData )
  2. {
  3. 	uint8_t regYearData = 0x00;
  4.  
  5. 	if (timeYearData >= 2000)//允许入参格式为2000+的
  6. 	{
  7. 		timeYearData -= 2000;
  8. 	}
  9. 	else
  10. 	{
  11. 		; /* do nothing*/
  12. 	}
  13.  
  14. 	if (timeYearData > 99)//限制入参大小
  15. 	{
  16. 		timeYearData = 0;
  17. 	}
  18. 	else
  19. 	{
  20. 		; /* do nothing*/
  21. 	}
  22.  
  23. 	if ((timeYearData/80) == 1)
  24. 	{
  25. 		regYearData |= 0x01;
  26. 		timeYearData -= 80;
  27. 	}
  28. 	if ((timeYearData/40) == 1)
  29. 	{
  30. 		regYearData |= 0x02;
  31. 		timeYearData -= 40;
  32. 	}
  33. 	if ((timeYearData/20) == 1)
  34. 	{
  35. 		regYearData |= 0x04;
  36. 		timeYearData -= 20;
  37. 	}
  38. 	if ((timeYearData/10) == 1)
  39. 	{
  40. 		regYearData |= 0x08;
  41. 		timeYearData -= 10;
  42. 	}
  43. 	if ((timeYearData/8) == 1)
  44. 	{
  45. 		regYearData |= 0x10;
  46. 		timeYearData -= 8;
  47. 	}
  48. 	if ((timeYearData/4) == 1)
  49. 	{
  50. 		regYearData |= 0x20;
  51. 		timeYearData -= 4;
  52. 	}
  53. 	if ((timeYearData/2) == 1)
  54. 	{
  55. 		regYearData |= 0x40;
  56. 		timeYearData -= 2;
  57. 	}
  58. 	if (timeYearData == 1)
  59. 	{
  60. 		regYearData |= 0x80;
  61. 	}
  62.  
  63. 	return 	regYearData;
  64. }

S35390_SetMonth

将月数据转换成BCD码，然后返回回去。

  1. static uint8_t S35390_SetMonth(uint8_t timeMonthData )
  2. {
  3. 	uint8_t regMonthData = 0x00;
  4.  
  5. 	if (timeMonthData == 0x00)//限制最小
  6. 	{
  7. 		timeMonthData = 0x01;
  8. 	}
  9. 	else if (timeMonthData > 12)//限制最大
  10. 	{
  11. 		timeMonthData = 1;
  12. 	}
  13. 	else
  14. 	{
  15. 		; /* do nothing*/
  16. 	}
  17.  
  18. 	if ((timeMonthData/10) == 1)
  19. 	{
  20. 		regMonthData |= 0x08;
  21. 		timeMonthData -= 10;
  22. 	}
  23. 	if ((timeMonthData/8) == 1)
  24. 	{
  25. 		regMonthData |= 0x10;
  26. 		timeMonthData -= 8;
  27. 	}
  28. 	if ((timeMonthData/4) == 1)
  29. 	{
  30. 		regMonthData |= 0x20;
  31. 		timeMonthData -= 4;
  32. 	}
  33. 	if ((timeMonthData/2) == 1)
  34. 	{
  35. 		regMonthData |= 0x40;
  36. 		timeMonthData -= 2;
  37. 	}
  38. 	if (timeMonthData == 1)
  39. 	{
  40. 		regMonthData |= 0x80;
  41. 	}
  42.  
  43. 	return 	regMonthData;
  44. }

S35390_SetDay

将日数据转换成BCD码，然后返回回去。

  1. static uint8_t S35390_SetDay(uint8_t timeDayData )
  2. {
  3. 	uint8_t regDayData = 0x00;
  4.  
  5. 	if (timeDayData == 0x00)//限制最小
  6. 	{
  7. 		timeDayData = 0x01;
  8. 	}
  9. 	else if (timeDayData > 31)//限制最大
  10. 	{
  11. 		timeDayData = 1;
  12. 	}
  13. 	else
  14. 	{
  15. 		; /* do nothing*/
  16. 	}
  17.  
  18. 	if ((timeDayData/20) == 1)
  19. 	{
  20. 		regDayData |= 0x04;
  21. 		timeDayData -= 20;
  22. 	}
  23. 	if ((timeDayData/10) == 1)
  24. 	{
  25. 		regDayData |= 0x08;
  26. 		timeDayData -= 10;
  27. 	}
  28. 	if ((timeDayData/8) == 1)
  29. 	{
  30. 		regDayData |= 0x10;
  31. 		timeDayData -= 8;
  32. 	}
  33. 	if ((timeDayData/4) == 1)
  34. 	{
  35. 		regDayData |= 0x20;
  36. 		timeDayData -= 4;
  37. 	}
  38. 	if ((timeDayData/2) == 1)
  39. 	{
  40. 		regDayData |= 0x40;
  41. 		timeDayData -= 2;
  42. 	}
  43. 	if (timeDayData == 1)
  44. 	{
  45. 		regDayData |= 0x80;
  46. 	}
  47.  
  48. 	return 	regDayData;
  49. }

S35390_SetWeek

将周数据转换成BCD码，然后返回回去。

  1. static uint8_t S35390_SetWeek(uint8_t timeWeekData )
  2. {
  3. 	uint8_t regWeekData = 0x00;
  4.  
  5.     if (timeWeekData > 6)//限制最大
  6. 	{
  7.     	timeWeekData = 0;
  8. 	}
  9. 	else
  10. 	{
  11. 		; /* do nothing*/
  12. 	}
  13.  
  14. 	if ((timeWeekData/4) == 1)
  15. 	{
  16. 		regWeekData |= 0x20;
  17. 		timeWeekData -= 4;
  18. 	}
  19. 	if ((timeWeekData/2) == 1)
  20. 	{
  21. 		regWeekData |= 0x40;
  22. 		timeWeekData -= 2;
  23. 	}
  24. 	if (timeWeekData == 1)
  25. 	{
  26. 		regWeekData |= 0x80;
  27. 	}
  28.  
  29. 	return 	regWeekData;
  30. }

S35390_SetHour

将时数据转换成BCD码，然后返回回去。

  1. static uint8_t S35390_SetHour(uint8_t timeHourData)
  2. {
  3. 	uint8_t regHourData = 0x00;
  4.  
  5.     if (timeHourData > 23)//限制最大
  6. 	{
  7.     	timeHourData = 0;
  8. 	}
  9. 	else
  10. 	{
  11. 		; /* do nothing*/
  12. 	}
  13.  
  14.     if ((timeHourData/20) == 1)
  15. 	{
  16.     	regHourData |= 0x04;
  17. 		timeHourData -= 20;
  18. 	}
  19. 	if ((timeHourData/10) == 1)
  20. 	{
  21. 		regHourData |= 0x08;
  22. 		timeHourData -= 10;
  23. 	}
  24. 	if ((timeHourData/8) == 1)
  25. 	{
  26. 		regHourData |= 0x10;
  27. 		timeHourData -= 8;
  28. 	}
  29. 	if ((timeHourData/4) == 1)
  30. 	{
  31. 		regHourData |= 0x20;
  32. 		timeHourData -= 4;
  33. 	}
  34. 	if ((timeHourData/2) == 1)
  35. 	{
  36. 		regHourData |= 0x40;
  37. 		timeHourData -= 2;
  38. 	}
  39. 	if (timeHourData == 1)
  40. 	{
  41. 		regHourData |= 0x80;
  42. 	}
  43.  
  44. 	return 	regHourData;
  45. }

S35390_SetMinute

将分数据转换成BCD码，然后返回回去。

  1. static uint8_t S35390_SetMinute(uint8_t timeMinuteData )
  2. {
  3. 	uint8_t regMinuteData = 0x00;
  4.  
  5.     if (timeMinuteData > 59)//限制最大
  6. 	{
  7.     	timeMinuteData = 0;
  8. 	}
  9. 	else
  10. 	{
  11. 		; /* do nothing*/
  12. 	}
  13.  
  14.     if ((timeMinuteData/40) == 1)
  15. 	{
  16.     	regMinuteData |= 0x02;
  17. 		timeMinuteData -= 40;
  18. 	}
  19.     if ((timeMinuteData/20) == 1)
  20. 	{
  21.     	regMinuteData |= 0x04;
  22.     	timeMinuteData -= 20;
  23. 	}
  24. 	if ((timeMinuteData/10) == 1)
  25. 	{
  26. 		regMinuteData |= 0x08;
  27. 		timeMinuteData -= 10;
  28. 	}
  29. 	if ((timeMinuteData/8) == 1)
  30. 	{
  31. 		regMinuteData |= 0x10;
  32. 		timeMinuteData -= 8;
  33. 	}
  34. 	if ((timeMinuteData/4) == 1)
  35. 	{
  36. 		regMinuteData |= 0x20;
  37. 		timeMinuteData -= 4;
  38. 	}
  39. 	if ((timeMinuteData/2) == 1)
  40. 	{
  41. 		regMinuteData |= 0x40;
  42. 		timeMinuteData -= 2;
  43. 	}
  44. 	if (timeMinuteData == 1)
  45. 	{
  46. 		regMinuteData |= 0x80;
  47. 	}
  48.  
  49. 	return 	regMinuteData;
  50. }

S35390_GetStatusReg1

获取状态寄存器1、状态寄存器2也是如此。

  1. uint8_t S35390_GetStatusReg1(uint8_t *statusReg)
  2. {
  3. 	return S35390_ReadRegs(S35390_STATUS1_ADDRESS,1,statusReg);
  4. }

S35390_SetStatusReg1

设置状态寄存器1、状态寄存器2也是如此。

  1. uint8_t S35390_SetStatusReg1(uint8_t *statusReg)
  2. {
  3. 	return S35390_WriteRegs(S35390_STATUS1_ADDRESS,1, statusReg);
  4. }

S35390_SetAlarm1

设置中断闹钟1、中断闹钟2也是如此，注意需要先在状态寄存器里面设置为闹钟模式。

  1. int S35390_SetAlarm1(rtc_alarm *alarmTime)
  2. {
  3. 	status_t ret=STATUS_BUSY;
  4. 	uint8_t reg_data[3] = {0};
  5. 	uint8_t flg_am_pm = 0;		//0:am,1:pm
  6.  
  7. 	reg_data[0] = S35390_SetWeek(alarmTime->week) | alarmTime->week_en;
  8.  
  9. 	if(alarmTime->hour >= 12)
  10. 	{
  11. 		flg_am_pm = 1;
  12. 	}
  13.     
  14. 	reg_data[1] = S35390_SetHour(alarmTime->hour) | alarmTime->hour_en | (flg_am_pm << 1);
  15. 	reg_data[2] = S35390_SetMinute(alarmTime->minute) | alarmTime->min_en;
  16.  
  17. 	ret = S35390_WriteRegs(S35390_INT1_REG_ADDRESS,3,reg_data);
  18.  
  19. 	return ret;
  20. }

S35390_GetAlarm1

获取闹钟1设置

  1. int S35390_GetAlarm1(rtc_alarm *alarmTime)
  2. {
  3. 	status_t ret=STATUS_BUSY;
  4. 	uint8_t reg_data[3] = {0};
  5.  
  6. 	ret =  S35390_ReadRegs(S35390_INT1_REG_ADDRESS,3, reg_data);
  7.  
  8.     if(ret != STATUS_SUCCESS)
  9. 	{
  10.     	LOG_ERR( "Get alarm set  time error!\r\n");
  11. 	}
  12. 	else
  13. 	{
  14. 		alarmTime->week = S35390_GetWeek(reg_data[0]);
  15. 		alarmTime->week_en = reg_data[0] & 0x01;
  16.  
  17. 		alarmTime->hour = S35390_GetHour(reg_data[1]);
  18. 		alarmTime->hour_en = reg_data[1] & 0x01;
  19.  
  20. 		alarmTime->minute = S35390_GetMinute(reg_data[2]);
  21. 		alarmTime->min_en = reg_data[2] & 0x01;
  22. 	}
  23.     
  24.     return  ret;
  25. }

S35390_EnableAlarm1

使能闹钟模式，其实就是将状态寄存器1改成闹钟模式。

  1. int S35390_EnableAlarm1(void)
  2. {
  3. 	status_t ret=STATUS_BUSY;
  4. 	uint8_t reg_data = 0;
  5.  
  6. 	ret =  S35390_ReadRegs(S35390_STATUS2_ADDRESS,1, &reg_data);
  7.  
  8. 	if(STATUS_SUCCESS == ret)
  9. 	{
  10. 		//INT1AE = 1;INT1ME = 0;INT1FE = 0;
  11. 		reg_data &= ~(0x01 << 4);
  12. 		reg_data |= (0x01 << 5);
  13. 		reg_data &= ~(0x03 << 6);
  14. 		ret =  S35390_WriteRegs(S35390_STATUS2_ADDRESS,1, &reg_data);
  15. 	}
  16.  
  17. 	return ret;
  18. }

S35390_DisableAlarm

失能闹钟模式，其实就是改变状态寄存器1。

  1. int S35390_DisableAlarm(void)
  2. {
  3. 	status_t ret=STATUS_BUSY;
  4. 	uint8_t reg_data = 0;
  5.  
  6. 	ret =  S35390_ReadRegs(S35390_STATUS1_ADDRESS,1, &reg_data);
  7.  
  8. 	if(STATUS_SUCCESS == ret)
  9. 	{
  10. 		//INT1AE = 0;INT1ME = 0;INT1FE = 0;
  11. 		reg_data &= ~(0x01 << 4);
  12. 		reg_data &= ~(0x01 << 5);
  13. 		reg_data &= ~(0x03 << 6);
  14. 		ret =  S35390_WriteRegs(S35390_STATUS1_ADDRESS,1, &reg_data);
  15. 	}
  16.  
  17. 	return ret;
  18. }

S35390_GetTime

获取当前时间

  1. #define S35390_BTC_SEC					0x06
  2. #define S35390_BTC_MIN					0x05
  3. #define S35390_BTC_HOUR					0x04
  4. #define S35390_BTC_WEEK					0x03
  5. #define S35390_BTC_DAY					0x02
  6. #define S35390_BTC_MONTH				0x01
  7. #define S35390_BTC_YEAR					0x00
  8.  
  9. uint8_t S35390_GetTime(rtc_time *time)
  10. {
  11. 	uint8_t reg_date[7]={0};
  12. 	uint8_t err = 0;
  13.  
  14. 	err = S35390_ReadRegs(S35390_TIME_ADDRESS,7,reg_date);//获取当前时间到reg_date
  15.  
  16. 	time->second  = S35390_GetMinute(reg_date[S35390_BTC_SEC]); //转换成十进制数据
  17. 	time->minute  = S35390_GetMinute(reg_date[S35390_BTC_MIN]);
  18. 	time->hour = S35390_GetHour(reg_date[S35390_BTC_HOUR]);
  19. 	time->week = S35390_GetWeek(reg_date[S35390_BTC_WEEK]);
  20. 	time->day = S35390_GetDay(reg_date[S35390_BTC_DAY]);
  21. 	time->month  = S35390_GetMonth(reg_date[S35390_BTC_MONTH]);
  22. 	time->year = S35390_GetYear(reg_date[S35390_BTC_YEAR])+2000;
  23.  
  24. 	LOG_INFO("%-30s%s%d,%d,%d,%d,%d,%d,%d\r\n","GetRTC","=",time->year,time->month,time->day,time->hour,time->minute,time->second,time->week);
  25.  
  26. 	return err;
  27. }

S35390_EnableAlarm

其实就是将状态寄存器设置为闹钟模式

  1. int S35390_EnableAlarm(void)
  2. {
  3. 	status_t ret=STATUS_BUSY;
  4. 	uint8_t reg_data = 0;
  5.  
  6. 	ret =  S35390_ReadRegs(S35390_STATUS2_ADDRESS,1, &reg_data);
  7.  
  8. 	if(STATUS_SUCCESS == ret)
  9. 	{
  10. 		//INT1AE = 1;INT1ME = 0;INT1FE = 0;
  11. 		reg_data &= ~(0x01 << 4);
  12. 		reg_data |= (0x01 << 5);
  13. 		reg_data &= ~(0x03 << 6);
  14. 		ret =  S35390_WriteRegs(S35390_STATUS2_ADDRESS,1, &reg_data);
  15. 	}
  16.  
  17. 	return ret;
  18. }

S35390_SetTime

设置当前时间

  1. uint8_t  S35390_SetTime(rtc_time *time)
  2. {
  3. 	uint8_t reg_date[7] = {0};
  4. 	uint8_t ret = 0xff;
  5. 	uint8_t week_tmp = 0;
  6.  
  7. 	reg_date[S35390_BTC_SEC]   = S35390_SetMinute(time->second); //转换成BCD码
  8. 	reg_date[S35390_BTC_MIN]   = S35390_SetMinute(time->minute);
  9. 	reg_date[S35390_BTC_HOUR]  = S35390_SetHour(time->hour);
  10.  
  11. 	week_tmp = CalculateWeekForKimLarsenCalculationFormula(time->year,time->month,time->day);//计算出周数据
  12. 	
  13. 	if(time->week != week_tmp)
  14. 	{
  15. 		LOG_ERR("week set error!\r\n");
  16. 	}
  17. 	reg_date[S35390_BTC_WEEK]  = S35390_SetWeek(week_tmp);
  18.  
  19. 	reg_date[S35390_BTC_DAY]   = S35390_SetDay(time->day);
  20. 	reg_date[S35390_BTC_MONTH] = S35390_SetMonth(time->month);
  21. 	reg_date[S35390_BTC_YEAR]  = S35390_SetYear(time->year);
  22.  
  23. 	ret =  S35390_WriteRegs(S35390_TIME_ADDRESS,7, reg_date);
  24.  
  25. 	return ret;
  26. }
  27.  
  28. static uint8_t CalculateWeekForKimLarsenCalculationFormula(uint16_t year, uint8_t month, uint8_t date)
  29. {
  30.     uint8_t week;
  31.  
  32.     if ((month == 1) || (month == 2)) {
  33.         month += 12;
  34.         year--;
  35.     }
  36.     week = (date + 2 * month + 3 * (month + 1) / 5 + year + year / 4 - year / 100 + year / 400 + 1) % 7;
  37.  
  38.     return week;
  39. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/144564
推荐阅读
相关标签

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

  

闽ICP备14008679号