1. Toy模板网首页
  2. > Toy博客

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

7月前 作者：不吃鱼的羊 分类：Toy博客 阅读(29) 违法举报

这篇具有很好参考价值的文章主要介绍了S-35390A计时芯片介绍及开发方案。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

计时芯片

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

规格书阅读

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

引脚表

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

模块框图

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

通讯数据配置

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

命令表格

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

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

状态寄存器1

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

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

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

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

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

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

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

状态寄存器2

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

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

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

实时数据1和2

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

里面的年是按照西历来计算的，只能写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要跟实时时钟里面一致。

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

输出用户设定的频率

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

校准寄存器

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

用户自由寄存器

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

S-35390A计时芯片介绍及开发方案,C语言,单片机,嵌入式硬件

使用注意事项

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

接口编写

基本定义

命令

#define S35390_TIME_ADDRESS             0x32
#define S35390_STATUS1_ADDRESS       	0x30
#define S35390_STATUS2_ADDRESS       	0x31
#define S35390_INT1_REG_ADDRESS       	0x34 
#define S35390_INT2_REG_ADDRESS       	0x35

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

typedef	struct
{
	unsigned int 	year;		//year
	unsigned char 	month;		//month
	unsigned char 	day;		//day
    unsigned char 	hour;		//hour
	unsigned char 	minute;		//minute
	unsigned char 	second;		//second
	unsigned char 	week;		//week
}rtc_time;

typedef	struct
{
	unsigned char 	minute;		//minute
	unsigned char 	hour;		//hour
    unsigned char 	week;		//week
    unsigned char 	min_en;		//minute enable
    unsigned char 	hour_en;	//hour enable
    unsigned char 	week_en;	//min enable
}rtc_alarm;

接口

RTC_S35390_Init

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

S35390_ReadRegs

读取多字节数据

bool S35390_ReadRegs(uint8_t addr, uint8_t length,uint8_t *values)
{
	status_t ret=STATUS_BUSY;
    uint8_t Try = 3;

    if(xSemaphore_i2c != NULL )
    {
        if( xSemaphoreTake( xSemaphore_i2c, ( TickType_t ) 50 ) == pdTRUE )//获取信号量
        {
            while((Try--)&&(ret != STATUS_SUCCESS))//最多尝试3次
			{
            	 lpi2cMasterState.slaveAddress = addr;//读取地址

                /* Request data from the bus slave */
                ret = I2C_DRV_MasterReceiveDataBlock(INST_LPI2C1,values,length,true,10);
			}
            xSemaphoreGive( xSemaphore_i2c);//释放信号量
        }
    }
    
    if(ret != STATUS_SUCCESS)//读出失败
	{
		I2C_Reset();//重新初始化IIC模块
	}
    return ret;
}

S35390_WriteRegs

读取多字节数据

static bool S35390_WriteRegs(uint8_t addr, uint8_t length, uint8_t *values)
{
	status_t ret=STATUS_BUSY;
	uint8_t Try = 3;

	uint8_t masterbuffer[32]={0};
	memcpy(&masterbuffer[0],values,length);

    if( xSemaphore_i2c != NULL )
    {
        if( xSemaphoreTake( xSemaphore_i2c, ( TickType_t ) 50 ) == pdTRUE )//获取信号量
        {
			while((Try--)&&(ret != STATUS_SUCCESS))//最多尝试3次
			{
				lpi2cMasterState.slaveAddress = addr;//写入地址
				
				ret=I2C_DRV_MasterSendDataBlock(INST_LPI2C1, masterbuffer, length, true,100UL);
			}
			xSemaphoreGive( xSemaphore_i2c);//释放信号量
        }
    }

    if(ret != STATUS_SUCCESS)//写入失败
    {
		I2C_Reset();//重新初始化IIC模块
    }
    
    return  ret;
}

S35390_GetYear

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

static uint8_t S35390_GetYear(uint8_t regYearData )
{
	uint8_t timeYearData = 0x00;

	if ( regYearData & 1 )
	{
		timeYearData += 80;
	}
	regYearData >>= 1;
	if ( regYearData & 1 )
	{
		timeYearData += 40;
	}
	regYearData >>= 1;
	if ( regYearData & 1 )
	{
		timeYearData += 20;
	}
	regYearData >>= 1;
	if ( regYearData & 1 )
	{
		timeYearData += 10;
	}
	regYearData >>= 1;
	if ( regYearData & 1 )
	{
		timeYearData += 8;
	}
	regYearData >>= 1;
	if ( regYearData & 1 )
	{
		timeYearData += 4;
	}
	regYearData >>= 1;
	if ( regYearData & 1 )
	{
		timeYearData += 2;
	}
	regYearData >>= 1;
	if ( regYearData & 1 )
	{
		timeYearData += 1;
	}

	if ( timeYearData > 99 )//最大限制
	{
		timeYearData = 99;
	}
	else
	{
		; /* do nothing*/
	}

	return 	timeYearData;
}

S35390_GetMonth

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

static uint8_t S35390_GetMonth(uint8_t regMonthData )
{
	uint8_t timeMonthData = 0x00;

	regMonthData >>= 3;
	if ( regMonthData & 1 )
	{
		timeMonthData += 10;
	}
	regMonthData >>= 1;
	if ( regMonthData & 1 )
	{
		timeMonthData += 8;
	}
	regMonthData >>= 1;
	if ( regMonthData & 1 )
	{
		timeMonthData += 4;
	}
	regMonthData >>= 1;
	if ( regMonthData & 1 )
	{
		timeMonthData += 2;
	}
	regMonthData >>= 1;
	if ( regMonthData & 1 )
	{
		timeMonthData += 1;
	}

	if ( timeMonthData == 0x00 )//最小限制
	{
		timeMonthData = 0x01;
	}
	else if ( timeMonthData > 12 )//最大限制
	{
		timeMonthData = 12;
	}
	else
	{
		; /* do nothing*/
	}

	return 	timeMonthData;
}

S35390_GetDay

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

static uint8_t S35390_GetDay(uint8_t regDayData )
{
	uint8_t timeDayData = 0x00;

	regDayData >>= 2;
	if ( regDayData & 1 )
	{
		timeDayData += 20;
	}
	regDayData >>= 1;
	if ( regDayData & 1 )
	{
		timeDayData += 10;
	}
	regDayData >>= 1;
	if ( regDayData & 1 )
	{
		timeDayData += 8;
	}
	regDayData >>= 1;
	if ( regDayData & 1 )
	{
		timeDayData += 4;
	}
	regDayData >>= 1;
	if ( regDayData & 1 )
	{
		timeDayData += 2;
	}
	regDayData >>= 1;
	if ( regDayData & 1 )
	{
		timeDayData += 1;
	}

	if ( timeDayData == 0 )//最小限制
	{
		timeDayData = 1;
	}
	else if ( timeDayData > 31 )//最大限制
	{
		timeDayData = 31;
	}
	else
	{
		; /* do nothing*/
	}

	return 	timeDayData;
}

S35390_GetWeek

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

static uint8_t S35390_GetWeek(uint8_t regWeekData )
{
	uint8_t timeWeekData = 0x00;

	regWeekData >>= 5;
	if ( regWeekData & 1 )
	{
		timeWeekData += 4;
	}
	regWeekData >>= 1;
	if ( regWeekData & 1 )
	{
		timeWeekData += 2;
	}
	regWeekData >>= 1;
	if ( regWeekData & 1 )
	{
		timeWeekData += 1;
	}

	return 	timeWeekData;
}

S35390_GetHour

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

static uint8_t S35390_GetHour(uint8_t regHourData )
{
	uint8_t timeHourData = 0x00;

	regHourData >>= 2;
	if ( regHourData & 1 )
	{
		timeHourData += 20;
	}
	regHourData >>= 1;
	if ( regHourData & 1 )
	{
		timeHourData += 10;
	}
	regHourData >>= 1;
	if ( regHourData & 1 )
	{
		timeHourData += 8;
	}
	regHourData >>= 1;
	if ( regHourData & 1 )
	{
		timeHourData += 4;
	}
	regHourData >>= 1;
	if ( regHourData & 1 )
	{
		timeHourData += 2;
	}
	regHourData >>= 1;
	if ( regHourData & 1 )
	{
		timeHourData += 1;
	}

	if ( timeHourData > 23 )//最大限制
	{
		timeHourData = 23;
	}
	else
	{
		; /* do nothing*/
	}

	return 	timeHourData;
}

S35390_GetMinute

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

static uint8_t S35390_GetMinute(uint8_t regMinuteData )
{
	uint8_t timeMinuteData = 0x00;

	regMinuteData >>= 1;
	if ( regMinuteData & 1 )
	{
		timeMinuteData += 40;
	}
	regMinuteData >>= 1;
	if ( regMinuteData & 1 )
	{
		timeMinuteData += 20;
	}
	regMinuteData >>= 1;
	if ( regMinuteData & 1 )
	{
		timeMinuteData += 10;
	}
	regMinuteData >>= 1;
	if ( regMinuteData & 1 )
	{
		timeMinuteData += 8;
	}
	regMinuteData >>= 1;
	if ( regMinuteData & 1 )
	{
		timeMinuteData += 4;
	}
	regMinuteData >>= 1;
	if ( regMinuteData & 1 )
	{
		timeMinuteData += 2;
	}
	regMinuteData >>= 1;
	if ( regMinuteData & 1 )
	{
		timeMinuteData += 1;
	}

	if ( timeMinuteData > 59 )//最大限制
	{
		timeMinuteData = 59;
	}
	else
	{
		; /* do nothing*/
	}

	return 	timeMinuteData;
}

S35390_SetYear

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

static uint8_t S35390_SetYear(uint16_t timeYearData )
{
	uint8_t regYearData = 0x00;

	if (timeYearData >= 2000)//允许入参格式为2000+的
	{
		timeYearData -= 2000;
	}
	else
	{
		; /* do nothing*/
	}

	if (timeYearData > 99)//限制入参大小
	{
		timeYearData = 0;
	}
	else
	{
		; /* do nothing*/
	}

	if ((timeYearData/80) == 1)
	{
		regYearData |= 0x01;
		timeYearData -= 80;
	}
	if ((timeYearData/40) == 1)
	{
		regYearData |= 0x02;
		timeYearData -= 40;
	}
	if ((timeYearData/20) == 1)
	{
		regYearData |= 0x04;
		timeYearData -= 20;
	}
	if ((timeYearData/10) == 1)
	{
		regYearData |= 0x08;
		timeYearData -= 10;
	}
	if ((timeYearData/8) == 1)
	{
		regYearData |= 0x10;
		timeYearData -= 8;
	}
	if ((timeYearData/4) == 1)
	{
		regYearData |= 0x20;
		timeYearData -= 4;
	}
	if ((timeYearData/2) == 1)
	{
		regYearData |= 0x40;
		timeYearData -= 2;
	}
	if (timeYearData == 1)
	{
		regYearData |= 0x80;
	}

	return 	regYearData;
}

S35390_SetMonth

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

static uint8_t S35390_SetMonth(uint8_t timeMonthData )
{
	uint8_t regMonthData = 0x00;

	if (timeMonthData == 0x00)//限制最小
	{
		timeMonthData = 0x01;
	}
	else if (timeMonthData > 12)//限制最大
	{
		timeMonthData = 1;
	}
	else
	{
		; /* do nothing*/
	}

	if ((timeMonthData/10) == 1)
	{
		regMonthData |= 0x08;
		timeMonthData -= 10;
	}
	if ((timeMonthData/8) == 1)
	{
		regMonthData |= 0x10;
		timeMonthData -= 8;
	}
	if ((timeMonthData/4) == 1)
	{
		regMonthData |= 0x20;
		timeMonthData -= 4;
	}
	if ((timeMonthData/2) == 1)
	{
		regMonthData |= 0x40;
		timeMonthData -= 2;
	}
	if (timeMonthData == 1)
	{
		regMonthData |= 0x80;
	}

	return 	regMonthData;
}

S35390_SetDay

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

static uint8_t S35390_SetDay(uint8_t timeDayData )
{
	uint8_t regDayData = 0x00;

	if (timeDayData == 0x00)//限制最小
	{
		timeDayData = 0x01;
	}
	else if (timeDayData > 31)//限制最大
	{
		timeDayData = 1;
	}
	else
	{
		; /* do nothing*/
	}

	if ((timeDayData/20) == 1)
	{
		regDayData |= 0x04;
		timeDayData -= 20;
	}
	if ((timeDayData/10) == 1)
	{
		regDayData |= 0x08;
		timeDayData -= 10;
	}
	if ((timeDayData/8) == 1)
	{
		regDayData |= 0x10;
		timeDayData -= 8;
	}
	if ((timeDayData/4) == 1)
	{
		regDayData |= 0x20;
		timeDayData -= 4;
	}
	if ((timeDayData/2) == 1)
	{
		regDayData |= 0x40;
		timeDayData -= 2;
	}
	if (timeDayData == 1)
	{
		regDayData |= 0x80;
	}

	return 	regDayData;
}

S35390_SetWeek

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

static uint8_t S35390_SetWeek(uint8_t timeWeekData )
{
	uint8_t regWeekData = 0x00;

    if (timeWeekData > 6)//限制最大
	{
    	timeWeekData = 0;
	}
	else
	{
		; /* do nothing*/
	}

	if ((timeWeekData/4) == 1)
	{
		regWeekData |= 0x20;
		timeWeekData -= 4;
	}
	if ((timeWeekData/2) == 1)
	{
		regWeekData |= 0x40;
		timeWeekData -= 2;
	}
	if (timeWeekData == 1)
	{
		regWeekData |= 0x80;
	}

	return 	regWeekData;
}

S35390_SetHour

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

static uint8_t S35390_SetHour(uint8_t timeHourData)
{
	uint8_t regHourData = 0x00;

    if (timeHourData > 23)//限制最大
	{
    	timeHourData = 0;
	}
	else
	{
		; /* do nothing*/
	}

    if ((timeHourData/20) == 1)
	{
    	regHourData |= 0x04;
		timeHourData -= 20;
	}
	if ((timeHourData/10) == 1)
	{
		regHourData |= 0x08;
		timeHourData -= 10;
	}
	if ((timeHourData/8) == 1)
	{
		regHourData |= 0x10;
		timeHourData -= 8;
	}
	if ((timeHourData/4) == 1)
	{
		regHourData |= 0x20;
		timeHourData -= 4;
	}
	if ((timeHourData/2) == 1)
	{
		regHourData |= 0x40;
		timeHourData -= 2;
	}
	if (timeHourData == 1)
	{
		regHourData |= 0x80;
	}

	return 	regHourData;
}

S35390_SetMinute

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

static uint8_t S35390_SetMinute(uint8_t timeMinuteData )
{
	uint8_t regMinuteData = 0x00;

    if (timeMinuteData > 59)//限制最大
	{
    	timeMinuteData = 0;
	}
	else
	{
		; /* do nothing*/
	}

    if ((timeMinuteData/40) == 1)
	{
    	regMinuteData |= 0x02;
		timeMinuteData -= 40;
	}
    if ((timeMinuteData/20) == 1)
	{
    	regMinuteData |= 0x04;
    	timeMinuteData -= 20;
	}
	if ((timeMinuteData/10) == 1)
	{
		regMinuteData |= 0x08;
		timeMinuteData -= 10;
	}
	if ((timeMinuteData/8) == 1)
	{
		regMinuteData |= 0x10;
		timeMinuteData -= 8;
	}
	if ((timeMinuteData/4) == 1)
	{
		regMinuteData |= 0x20;
		timeMinuteData -= 4;
	}
	if ((timeMinuteData/2) == 1)
	{
		regMinuteData |= 0x40;
		timeMinuteData -= 2;
	}
	if (timeMinuteData == 1)
	{
		regMinuteData |= 0x80;
	}

	return 	regMinuteData;
}

S35390_GetStatusReg1

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

uint8_t S35390_GetStatusReg1(uint8_t *statusReg)
{
	return S35390_ReadRegs(S35390_STATUS1_ADDRESS,1,statusReg);
}

S35390_SetStatusReg1

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

uint8_t S35390_SetStatusReg1(uint8_t *statusReg)
{
	return S35390_WriteRegs(S35390_STATUS1_ADDRESS,1, statusReg);
}

S35390_SetAlarm1

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

int S35390_SetAlarm1(rtc_alarm *alarmTime)
{
	status_t ret=STATUS_BUSY;
	uint8_t reg_data[3] = {0};
	uint8_t flg_am_pm = 0;		//0:am,1:pm

	reg_data[0] = S35390_SetWeek(alarmTime->week) | alarmTime->week_en;

	if(alarmTime->hour >= 12)
	{
		flg_am_pm = 1;
	}
    
	reg_data[1] = S35390_SetHour(alarmTime->hour) | alarmTime->hour_en | (flg_am_pm << 1);
	reg_data[2] = S35390_SetMinute(alarmTime->minute) | alarmTime->min_en;

	ret = S35390_WriteRegs(S35390_INT1_REG_ADDRESS,3,reg_data);

	return ret;
}

S35390_GetAlarm1

获取闹钟1设置

int S35390_GetAlarm1(rtc_alarm *alarmTime)
{
	status_t ret=STATUS_BUSY;
	uint8_t reg_data[3] = {0};

	ret =  S35390_ReadRegs(S35390_INT1_REG_ADDRESS,3, reg_data);

    if(ret != STATUS_SUCCESS)
	{
    	LOG_ERR( "Get alarm set  time error!\r\n");
	}
	else
	{
		alarmTime->week = S35390_GetWeek(reg_data[0]);
		alarmTime->week_en = reg_data[0] & 0x01;

		alarmTime->hour = S35390_GetHour(reg_data[1]);
		alarmTime->hour_en = reg_data[1] & 0x01;

		alarmTime->minute = S35390_GetMinute(reg_data[2]);
		alarmTime->min_en = reg_data[2] & 0x01;
	}
    
    return  ret;
}

S35390_EnableAlarm1

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

int S35390_EnableAlarm1(void)
{
	status_t ret=STATUS_BUSY;
	uint8_t reg_data = 0;

	ret =  S35390_ReadRegs(S35390_STATUS2_ADDRESS,1, &reg_data);

	if(STATUS_SUCCESS == ret)
	{
		//INT1AE = 1;INT1ME = 0;INT1FE = 0;
		reg_data &= ~(0x01 << 4);
		reg_data |= (0x01 << 5);
		reg_data &= ~(0x03 << 6);
		ret =  S35390_WriteRegs(S35390_STATUS2_ADDRESS,1, &reg_data);
	}

	return ret;
}

S35390_DisableAlarm

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

int S35390_DisableAlarm(void)
{
	status_t ret=STATUS_BUSY;
	uint8_t reg_data = 0;

	ret =  S35390_ReadRegs(S35390_STATUS1_ADDRESS,1, &reg_data);

	if(STATUS_SUCCESS == ret)
	{
		//INT1AE = 0;INT1ME = 0;INT1FE = 0;
		reg_data &= ~(0x01 << 4);
		reg_data &= ~(0x01 << 5);
		reg_data &= ~(0x03 << 6);
		ret =  S35390_WriteRegs(S35390_STATUS1_ADDRESS,1, &reg_data);
	}

	return ret;
}

S35390_GetTime

获取当前时间

#define S35390_BTC_SEC					0x06
#define S35390_BTC_MIN					0x05
#define S35390_BTC_HOUR					0x04
#define S35390_BTC_WEEK					0x03
#define S35390_BTC_DAY					0x02
#define S35390_BTC_MONTH				0x01
#define S35390_BTC_YEAR					0x00

uint8_t S35390_GetTime(rtc_time *time)
{
	uint8_t reg_date[7]={0};
	uint8_t err = 0;

	err = S35390_ReadRegs(S35390_TIME_ADDRESS,7,reg_date);//获取当前时间到reg_date

	time->second  = S35390_GetMinute(reg_date[S35390_BTC_SEC]); //转换成十进制数据
	time->minute  = S35390_GetMinute(reg_date[S35390_BTC_MIN]);
	time->hour = S35390_GetHour(reg_date[S35390_BTC_HOUR]);
	time->week = S35390_GetWeek(reg_date[S35390_BTC_WEEK]);
	time->day = S35390_GetDay(reg_date[S35390_BTC_DAY]);
	time->month  = S35390_GetMonth(reg_date[S35390_BTC_MONTH]);
	time->year = S35390_GetYear(reg_date[S35390_BTC_YEAR])+2000;

	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);

	return err;
}

S35390_EnableAlarm

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

int S35390_EnableAlarm(void)
{
	status_t ret=STATUS_BUSY;
	uint8_t reg_data = 0;

	ret =  S35390_ReadRegs(S35390_STATUS2_ADDRESS,1, &reg_data);

	if(STATUS_SUCCESS == ret)
	{
		//INT1AE = 1;INT1ME = 0;INT1FE = 0;
		reg_data &= ~(0x01 << 4);
		reg_data |= (0x01 << 5);
		reg_data &= ~(0x03 << 6);
		ret =  S35390_WriteRegs(S35390_STATUS2_ADDRESS,1, &reg_data);
	}

	return ret;
}

S35390_SetTime

设置当前时间文章来源地址https://www.toymoban.com/news/detail-835335.html

uint8_t  S35390_SetTime(rtc_time *time)
{
	uint8_t reg_date[7] = {0};
	uint8_t ret = 0xff;
	uint8_t week_tmp = 0;

	reg_date[S35390_BTC_SEC]   = S35390_SetMinute(time->second); //转换成BCD码
	reg_date[S35390_BTC_MIN]   = S35390_SetMinute(time->minute);
	reg_date[S35390_BTC_HOUR]  = S35390_SetHour(time->hour);

	week_tmp = CalculateWeekForKimLarsenCalculationFormula(time->year,time->month,time->day);//计算出周数据
	
	if(time->week != week_tmp)
	{
		LOG_ERR("week set error!\r\n");
	}
	reg_date[S35390_BTC_WEEK]  = S35390_SetWeek(week_tmp);

	reg_date[S35390_BTC_DAY]   = S35390_SetDay(time->day);
	reg_date[S35390_BTC_MONTH] = S35390_SetMonth(time->month);
	reg_date[S35390_BTC_YEAR]  = S35390_SetYear(time->year);

	ret =  S35390_WriteRegs(S35390_TIME_ADDRESS,7, reg_date);

	return ret;
}

static uint8_t CalculateWeekForKimLarsenCalculationFormula(uint16_t year, uint8_t month, uint8_t date)
{
    uint8_t week;

    if ((month == 1) || (month == 2)) {
        month += 12;
        year--;
    }
    week = (date + 2 * month + 3 * (month + 1) / 5 + year + year / 4 - year / 100 + year / 400 + 1) % 7;

    return week;
}

到了这里，关于S-35390A计时芯片介绍及开发方案的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 烟感报警器单片机方案开发，解决方案

    烟感报警器单片机方案开发，解决方案

    烟感报警器也叫做烟雾报警器。烟感报警器适用于火灾发生时有大量烟雾，而正常情况下无烟的场所。例如写字楼、医院、学校、博物馆等场所。烟感报警器一般安装于所需要保护或探测区域的天花板上，因火灾中烟雾比空气轻，更容易向上飘散，安装部位在上方，提高感烟

    2024年02月09日
    浏览(36)
  • 单片机GD32F303RCT6 (Macos环境)开发 （二十）—— 光感芯片veml7700的使用

    单片机GD32F303RCT6 (Macos环境)开发 （二十）—— 光感芯片veml7700的使用

    1、veml有7个寄存器，每个十六位，见图。 00是config寄存器， 01 02 是中断设置的阈值 03是节能模式的设置 04 是得到的光的亮度值 05是得到的data of whole WHITE 06是中断设置值。 2、我们只测试得到光的亮度值，所以veml寄存器设置如下： 设置gain，integration time ,power save mode ,interrup

    2024年02月04日
    浏览(47)
  • 【74HC595】51单片机（普中A2开发板）LED点阵屏点亮以及74HC595芯片的使用笔记

    【74HC595】51单片机（普中A2开发板）LED点阵屏点亮以及74HC595芯片的使用笔记

    纯小白写的文章，如有问题，欢迎评论区讨论，反驳，指正。 如果你只想了解74HC595如何使用，建议只看2.3。 通过查看普中A2开发板的原理图（图1）可以知道，通过P0（P0_0、P0_1…P0_7）口和DPa、DPb…DPh来控制哪一颗LED点亮。我这个开发板上的点阵模块没有按照他给的原理图上

    2024年02月05日
    浏览(55)
  • 单片机C51计时器秒表

    单片机C51计时器秒表

    鱼弦：CSDN内容合伙人、CSDN新星导师、全栈领域创作新星创作者 、51CTO(Top红人+专家博主) 、github开源爱好者（go-zero源码二次开发、游戏后端架构 https://github.com/Peakchen） 单片机C51（或称8051）计时器秒表的实现原理如下： 原理解释： C51微控制器通常包括多个计时器/计数器，可

    2024年02月03日
    浏览(36)
  • 基于PIC单片机篮球计分计时器

    基于PIC单片机篮球计分计时器

    一、系统方案 本设计采用PIC单片机作为主控制器，矩阵键盘控制，比分，计时控制，24秒，液晶12864显示。 二、硬件设计 原理图如下： 三、单片机软件设计 1、首先是系统初始化 2、液晶显示程序 /******************************************************************************************** 函数名

    2024年02月11日
    浏览(32)
  • STM32单片机开发-01 STM32介绍

    STM32单片机开发-01 STM32介绍

    通过野火开发板学习单片机 从内核上分有Cortex-M0、M3、M4 和M7 F1 代表了基础型，基于Cortex-M3 内核，主频为72MHZ F4 代表了高性能，基于Cortex-M4 内核，主频180M。 数据手册：用于芯片选型和设计原理图 参考手册：用于编程时查阅 Icode总线 – 该总线讲M3内核的指令总线与闪存指令

    2024年01月21日
    浏览(44)

  • 嵌入式单片机——60秒计时器的实现

    1.设计秒计时器，要求实现60秒计时，用2位LED数码管显示。 2.按键K1，实现秒表的停止和启动。

    2024年02月03日
    浏览(38)
  • 基于51单片机的倒计时秒表proteus仿真设计

    基于51单片机的倒计时秒表proteus仿真设计

    目录 一、设计背景 二、实现功能 三、仿真演示 四、源程序         近年来随着科技的飞速发展，单片机的应用正在不断的走向深入。本文阐述了基于单片机的数字电子秒表倒计时设计，倒计时精度达0.05s了，解决了传统的由于倒计时精度不够造成的误差和不公平性，是各种

    2024年02月02日
    浏览(38)
  • 四位数码管显示计时分钟和秒（单片机代码）

    四位数码管显示计时分钟和秒（单片机代码）

    8051系列单片机有两个定时器:T0和T1,分别称为定时器和定时器T1,这两个定时器都是16位的定时器/计数器;8052系列单片机增加了第三个定时器/计数器T2;它们都有定时或事件计数功能,常用于时间控制、延时、对外部时间计数和检测等场合。 8051单片机的两个定时器T0和T1分别都由两

    2024年02月12日
    浏览(33)
  • 基于51单片机交通灯带紧急开关+黄灯倒计时+可调时间

    基于51单片机交通灯带紧急开关+黄灯倒计时+可调时间

    仿真图proteus 7.8 程序编译器：keil 4/keil 5 编程语言：C语言 设计编号：J000 功能说明： 采用51单片机以及单片机最小系统和三极管驱动电路以及外围的按键和数码管显示等部件，设计一个基于单片机的交通灯设计。 1.四路交通灯，带有红绿灯倒计时，绿灯倒计时结束后转黄灯

    2024年02月06日
    浏览(32)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包