small_water_meter_4g_src/Users/bill/bill.c

#include "board.h"
#include "bill.h"
#include "prj_com.h"
#include "param.h"
#include "rtc_run.h"
#include "eeprom.h"
#include "wdg_drv.h"
#include "alarm.h"
#include "tdc_tof.h"

bill_run_t BillRun;
CUR_FLOW_INDEX_DEF cum_flow_index;
unsigned char save_cur_flow_flag; //
res_bill_t bak_month_cum_flow;
res_bill_t bak_day_cum_flow;
res_bill_t bak_hour_cum_flow;
bill_5min_ctrl_def bak_5min_cum_flow;
uint8_t StartUp = 0;
uint8_t global_settle_flag = 0;

void bill_init(void)
{
	BillRun.fw_use_hour = 0.0f;
	BillRun.fw_use_day = 0.0f;
	BillRun.fw_use_day = 0.0f;
	BillRun.fw_use_five_min = 0.0f;

	BillRun.bw_use_hour = 0.0f;
	BillRun.bw_use_day = 0.0f;
	BillRun.bw_use_month = 0.0f;
	BillRun.bw_use_five_min = 0.0f;

	BillRun.cum_flow = 0.0f;
	BillRun.fw_cum_flow = 0.0f;
	BillRun.bw_cum_flow = 0.0f;

	init_5min_cur_flow_bill();
	init_hour_cur_flow_bill();
	init_day_cur_flow_bill();
	init_month_cur_flow_bill();
	init_cur_flow_bill();
}

uint32_t cal_cur_flow(double cum)
{
	uint64_t x = (uint64_t)cum;
    return (uint32_t)((x + 5000ULL) / 10000ULL);
}
uint32_t get_month_fw_used_bill(void)
{ // 获取月正向流量数据

	if (BillRun.fw_cum_flow <= bak_month_cum_flow.fw_cum_flow)
		return 0;
	else
		return cal_cur_flow(BillRun.fw_cum_flow) - cal_cur_flow(bak_month_cum_flow.fw_cum_flow); // 
}
uint32_t get_month_bw_used_bill(void)
{ // 获取月反向流量
	if (BillRun.bw_cum_flow <= bak_month_cum_flow.bw_cum_flow)
		return 0;
	else
		return cal_cur_flow(BillRun.bw_cum_flow) - cal_cur_flow(bak_month_cum_flow.bw_cum_flow);
}

uint32_t get_day_fw_used_bill(void) // 月结和日结都是两位小数点m3 wxl2026-5-6
{									// 获取日正向流量数据
	if (BillRun.fw_cum_flow <= bak_day_cum_flow.fw_cum_flow)
		return 0;
	else
		return cal_cur_flow(BillRun.fw_cum_flow) - cal_cur_flow(bak_day_cum_flow.fw_cum_flow);
}
uint32_t get_day_bw_used_bill(void)
{ // 获取日反向流量
	if (BillRun.bw_cum_flow <= bak_day_cum_flow.bw_cum_flow)
		return 0;
	else
		return cal_cur_flow(BillRun.bw_cum_flow) - cal_cur_flow(bak_day_cum_flow.bw_cum_flow);
}

uint32_t get_hour_fw_used_bill(void)
{
	// 获取小时正向流量数据
	if (BillRun.fw_cum_flow <= bak_hour_cum_flow.fw_cum_flow)
		return 0;
	else
		return (uint32_t)((BillRun.fw_cum_flow - bak_hour_cum_flow.fw_cum_flow) * 0.001);
}
uint32_t get_hour_bw_used_bill(void)
{ // 获取小时反向流量数据
	if (BillRun.bw_cum_flow <= bak_hour_cum_flow.bw_cum_flow)
		return 0;
	else
		return (uint32_t)((BillRun.bw_cum_flow - bak_hour_cum_flow.bw_cum_flow) * 0.001);
}

uint32_t get_5min_fw_used_bill(void)
{ // 获取5min正向流量数据
	if (BillRun.fw_cum_flow <= bak_5min_cum_flow.fw_cum_flow)
		return 0;
	else
		return (uint32_t)((BillRun.fw_cum_flow - bak_5min_cum_flow.fw_cum_flow) * 0.001);
}
uint32_t get_5min_bw_used_bill(void)
{ // 获取5min反向流量数据
	if (BillRun.bw_cum_flow <= bak_5min_cum_flow.bw_cum_flow)
		return 0;
	else
		return (uint32_t)((BillRun.bw_cum_flow - bak_5min_cum_flow.bw_cum_flow) * 0.001);
}

/////////////将瞬时流量转换为要求的比例//////////////////////////
int32_t get_flow_rate_bill(void)
{ // 获取瞬时流速
	return (int32_t)(BillRun.flow_rate * 0.001 * 3600);
}
//////////////////////对外接口 从采样模块获取瞬时流量到bill  和以前的SetBillVol兼容///////////////////////////////////
// fw_vol:正向瞬时流量
// bw_vol:反向瞬时流量
/////////////////////////////////////////////////////////
void set_flow_rate_bill(double fw_vol, double bw_vol) // 当前月日小时5min累计流量累加
{

	BillRun.flow_rate = (fw_vol > 0) ? fw_vol : bw_vol;
}

///////////////////在采集计算中调用 获取当前流量累计数据当前流量累计值,///////////////////
// 参数cum:绝对流量
// 参数 fw_cum:正向流量
// 参数 bw_cum:反向流量
// 返回:无
////////////////////////////////////////////
void set_cur_flow_bill(double cum, double fw_cum, double bw_cum)
{
	BillRun.cum_flow = fw_cum - bw_cum;
	BillRun.fw_cum_flow = fw_cum;
	BillRun.bw_cum_flow = bw_cum;

	CumFlow = fw_cum - bw_cum;
	FwCumFlow = fw_cum;
	BwCumFlow = bw_cum;
}

/// 读取当前累计流量到指针参数,本模块对外输出/////////////
void get_cur_flow_bill(double *cum, double *fw_cum, double *bw_cum)
{

	*cum = CumFlow;
	*fw_cum = FwCumFlow;
	*bw_cum = BwCumFlow;
}

////////////////保存月使用量///////////////////////
/// 参数:年月日
/// 无返回
/////////////////////////////////////////
void set_month_used_bill(uint8_t year, uint8_t month, uint8_t day)
{
	uint32_t fw_used;
	uint32_t bw_used;
	bill_t month_bill;
	uint16_t len = sizeof(bill_t);
	uint32_t addr = MONTH_BILL_START_ADDR + len * MONTH_BILL_INDEX(year, month);
	if (CheckDateValid(year, month, day, 0, 0, 0) == 0)
		return;
	/////////////////////如果数据已经存在,则在原来的基础上累加////////////////////////////////////////
	uint8_t ret;
	ret = get_month_used_bill(year, month, &month_bill);
	if (ret == 0)
	{
		fw_used = month_bill.fw_used;
		bw_used = month_bill.bw_used;
	}
	else
	{
		fw_used = 0;
		bw_used = 0;
	}
	////////////////////////////////////////////////////////////////////////////////////////////////////////

	fw_used += get_month_fw_used_bill();
	bw_used += get_month_bw_used_bill();

	month_bill.flag = 1;
	month_bill.date[0] = year;
	month_bill.date[1] = month;
	month_bill.date[2] = day;
	month_bill.fw_used = fw_used;
	month_bill.bw_used = bw_used;

	write_eeprom(addr, (uint8_t *)&month_bill, len);
}

/////////////////////保存日使用量////////////////////////////////
// 参数 年月日
///////////////////////////////////////////////
void set_day_used_bill(uint8_t year, uint8_t month, uint8_t day)
{
	uint32_t fw_used;
	uint32_t bw_used;

	bill_t day_bill;
	uint16_t len = sizeof(bill_t);
	uint16_t days = days_from_leap_year_begin(month, day);
	uint32_t addr = DAY_BILL_START_ADDR + len * (days - 1);
	///////////////////检查日期是否合法/////////////////////////////
	if (CheckDateValid(year, month, day, 0, 0, 0) == 0)
		return;
	///////////////////检查是否存有相同的记录 有就加上/////////////////////////////
	uint8_t ret;
	ret = get_day_used_bill(year, month, day, &day_bill);
	if (ret == 0) // 数据合法,且年月日都相同
	{
		fw_used = day_bill.fw_used;
		bw_used = day_bill.bw_used;
	}
	else
	{
		fw_used = 0;
		bw_used = 0;
	}
	////////////////////////////////////////////////////////////////////////////////

	fw_used += get_day_fw_used_bill();
	bw_used += get_day_bw_used_bill();

	day_bill.flag = 1;
	day_bill.date[0] = year;
	day_bill.date[1] = month;
	day_bill.date[2] = day;
	day_bill.fw_used = fw_used;
	day_bill.bw_used = bw_used;
	write_eeprom(addr, (uint8_t *)&day_bill, len);
}

////////////////////保存小时使用量///////////////////////////////////
/// 参数:年月日时
/////////////////////////////////////////////////////////
void set_hour_used_bill(uint8_t year, uint8_t month, uint8_t day, uint8_t hour)
{
	uint32_t fw_used;
	uint32_t bw_used;
	uint32_t fr;
	hour_bill_t hour_bill;
	uint16_t len = sizeof(hour_bill_t);
	uint32_t addr = HOUR_BILL_START_ADDR + HOUR_BILL_INDEX(day, hour) * len;
	/////////////////////////////////检查时间是否合法///////////////////////////////////////
	if (CheckDateValid(year, month, day, hour, 0, 0) == 0)
		return; // 时间不合法
	/////////////////////////如果记录中存在相同日期的数据,则累加//////////////////////

	uint8_t ret;
	ret = get_hour_used_bill(year, month, day, hour, &hour_bill);
	if (ret == 0) // 数据合法且日期相同
	{
		fw_used = hour_bill.fw_used[0] + ((uint32_t)hour_bill.fw_used[1] << 8) + ((uint32_t)hour_bill.fw_used[2] << 16);
		bw_used = hour_bill.bw_used[0] + ((uint32_t)hour_bill.bw_used[1] << 8) + ((uint32_t)hour_bill.bw_used[2] << 16);
		fr = hour_bill.flow_rate[0] + ((uint32_t)hour_bill.flow_rate[1] << 8) + ((uint32_t)hour_bill.flow_rate[2] << 16);
	}
	else
	{
		fw_used = 0;
		bw_used = 0;
		fr = 0;
	}
	//////////////////////////////////////////////////////////////////////////////

	fw_used += get_hour_fw_used_bill();
	bw_used += get_hour_bw_used_bill();

	fr = (uint32_t)get_flow_rate_bill() > fr ? (uint32_t)get_flow_rate_bill() : fr;

	memset(&hour_bill, 0, sizeof(hour_bill_t));

	hour_bill.flag = 1;
	hour_bill.date[0] = year;
	hour_bill.date[1] = month;
	hour_bill.date[2] = day;
	hour_bill.date[3] = hour;

	hour_bill.fw_used[0] = (uint8_t)(fw_used);
	hour_bill.fw_used[1] = (uint8_t)(fw_used >> 8);
	hour_bill.fw_used[2] = (uint8_t)(fw_used >> 16);

	hour_bill.bw_used[0] = (uint8_t)(bw_used);
	hour_bill.bw_used[1] = (uint8_t)(bw_used >> 8);
	hour_bill.bw_used[2] = (uint8_t)(bw_used >> 16);

	hour_bill.flow_rate[0] = (uint8_t)(fr);
	hour_bill.flow_rate[1] = (uint8_t)(fr >> 8);
	hour_bill.flow_rate[2] = (uint8_t)(fr >> 16);

	if (Paramx.pressure_sensor == 1)
	{
		hour_bill.pressure = (uint8_t)(WaterPressure * 100);
	}
	else
	{
		hour_bill.pressure = 0x00; // 无压力传感器,修改为0
	}

	write_eeprom(addr, (uint8_t *)&hour_bill, len);
}

/////////////////保存5分钟使用量///////////////////////
// 参数:年月日时分
///////////////////////////////////////////////
void set_5min_used_bill(uint8_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute)
{
	uint32_t fw_used;
	uint32_t bw_used;
	uint32_t fr;
	hour_bill_t bill;
	uint16_t len = sizeof(hour_bill_t);
	uint32_t addr = FIVE_MIN_BILL_START_ADDR + len * FIVE_MIN_BILL_INDEX(day, hour, minute);
	/////////////////////////////////检查时间是否合法///////////////////////////////////////
	if (CheckDateValid(year, month, day, hour, minute, 0) == 0)
		return;
	////////////////////////////////////////////////////////////////////////////////////////
	uint8_t ret;
	ret = get_5min_used_bill(year, month, day, hour, minute, &bill);
	if (ret == 0)
	{
		fw_used = bill.fw_used[0] + ((uint32_t)bill.fw_used[1] << 8) + ((uint32_t)bill.fw_used[2] << 16);
		bw_used = bill.bw_used[0] + ((uint32_t)bill.bw_used[1] << 8) + ((uint32_t)bill.bw_used[2] << 16);
		fr = bill.flow_rate[0] + ((uint32_t)bill.flow_rate[1] << 8) + ((uint32_t)bill.flow_rate[2] << 16);
	}
	else
	{
		fw_used = 0;
		bw_used = 0;
		fr = 0;
	}
	////////////////////////////////////////////////////////////////////////////////////////

	fw_used += get_5min_fw_used_bill();
	bw_used += get_5min_bw_used_bill();
	fr = (uint32_t)get_flow_rate_bill() > fr ? (uint32_t)get_flow_rate_bill() : fr;

	////////////////////////////////////////////////////////////////////////////////////////
	bill.date[0] = year;

	bill.flag = 1;
	bill.date[0] = year;
	bill.date[1] = month; // num保存该小时内第几个5分钟数据
	bill.date[2] = day;
	bill.date[3] = hour;
	bill.fw_used[0] = (uint8_t)(fw_used);
	bill.fw_used[1] = (uint8_t)(fw_used >> 8);
	bill.fw_used[2] = (uint8_t)(fw_used >> 16);
	bill.bw_used[0] = (uint8_t)(bw_used);
	bill.bw_used[1] = (uint8_t)(bw_used >> 8);
	bill.bw_used[2] = (uint8_t)(bw_used >> 16);
	bill.flow_rate[0] = (uint8_t)(fr);
	bill.flow_rate[1] = (uint8_t)(fr >> 8);
	bill.flow_rate[2] = (uint8_t)(fr >> 16);

	if (Paramx.pressure_sensor == 1)
	{
		bill.pressure = (uint8_t)(WaterPressure * 100);
	}
	else
	{
		bill.pressure = 0x0; // 无压力传感器 ,修改为0x0
	}

	write_eeprom(addr, (uint8_t *)&bill, len);
}

/////////////////////////保存当前累计流量数据和时间,防止意外丢失///////////////////////////////
// 无参数
// 无返回值
// 256点循环保存,最快10秒一次, 最慢5分钟一次
///////////////////////////////////////////////////////////////////////
uint8_t save_5min_trik_flag = 0;
void save_cur_flow_bill(void)
{

	rtc_run_t *rr;
	bill_cum_flow_tx bill;
	if (global_settle_flag == 1) // 结算中,只有结算完成才保存新的底读
		return;
	get_rtc_run(&rr); // 获取当前时间
	if (rr->minute % 5 == 0)
	{
		save_5min_trik_flag++;
	}
	else
	{
		save_5min_trik_flag = 0;
	}

	if ((save_5min_trik_flag == 1) || ((BillRun.fw_cum_flow != cum_flow_index.fw || BillRun.bw_cum_flow != cum_flow_index.bw) && rr->second /*% 10*/ == 0) || save_cur_flow_flag == 1)
	{ // 整5分钟或流量值发生变化
	}
	else
		return;

	save_cur_flow_flag = 0;
	memset(&bill, 0, sizeof(bill_cum_flow_tx)); // 初始化0
	bill.flag = 1;
	bill.date_time[0] = rr->year;
	bill.date_time[1] = rr->month;
	bill.date_time[2] = rr->day;
	bill.date_time[3] = rr->hour;
	bill.date_time[4] = rr->minute;
	bill.date_time[5] = rr->second;
	bill.date_time[6] = rr->week;
	bill.fw_cum_flow = BillRun.fw_cum_flow;
	bill.bw_cum_flow = BillRun.bw_cum_flow;

	cum_flow_index.fw = BillRun.fw_cum_flow;
	cum_flow_index.bw = BillRun.bw_cum_flow;

	bill.gcnt = cum_flow_index.cur_gcnt; // 保存当前累计序列值 long型有符号,用于读取时,找到最近一条记录的条件, 最大值为最新记录
	cum_flow_index.cur_gcnt++;			 // 累加当前序列,作为下次保存时使用
	cum_flow_index.npos %= MAX_CUM_FLOW_NUM;
	write_eeprom(CUM_FLOW_START_ADDR + cum_flow_index.npos * CUM_FLOW_SIZE, (uint8_t *)&bill, sizeof(bill_cum_flow_tx)); // 写锟斤拷锟斤拷锟斤拷

	cum_flow_index.npos++;					 // 存储位置后移
	cum_flow_index.npos %= MAX_CUM_FLOW_NUM; // 循环存储

#ifdef DEBUG_BILL
	LOG("save_time %d-%d-%d %d:%d:%d fw = %f,bw = %f gcnt= %d, npos = %d\r\n", rr->year, rr->month, rr->day, rr->hour, rr->minute, rr->second, cum_flow_index.fw, cum_flow_index.bw, cum_flow_index.cur_gcnt, cum_flow_index.npos);
#endif
}

///////////////读取指定时间的月使用量///////////////////////////
uint8_t get_month_used_bill(uint8_t year, uint8_t month, bill_t *bill)
{

	memset(bill, 0, sizeof(bill_t));
	uint16_t len = sizeof(bill_t);
	uint32_t addr = MONTH_BILL_START_ADDR + len * MONTH_BILL_INDEX(year, month);
	uint8_t ret;
	ret = read_eeprom(addr, (uint8_t *)bill, len);
	if (ret != 0)
		return ret;
	if (bill->date[0] != year || bill->date[1] != month) // 读取的月份和日期不匹配
	{
		// memset(bill, 0, sizeof(bill_t));
		return 1;
	}
	return 0;
}
uint16_t get_days_from_year(uint8_t year, uint8_t month, uint8_t day)
{
	uint16_t days = 0;
	uint8_t i;
	if (month == 0 || day == 0)
		return 0;
	for (i = 0; i < month - 1; i++)
	{
		days += monthday[i];
		if (i == 1 && year % 4 == 0)
			days++;
	}
	days = days + day - 1;
	return days;
}
/*
int32_t get_days_between_now(uint8_t byear, uint8_t bmonth, uint8_t bday)
{
	rtc_run_t *rr;
	get_rtc_run(&rr);
	int32_t adays, bdays;
	adays = rr->year * 366 + get_days_from_year(rr->year, rr->month, rr->day);
	bdays = byear * 366 + get_days_from_year(byear, bmonth, bday);
	return adays - bdays;
} */
int32_t get_days_between_now(uint8_t y2, uint8_t m2, uint8_t d2)
{
	uint16_t i;
	uint32_t days1 = 0, days2 = 0;
	uint8_t monthDays[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
	rtc_run_t *rr;
	get_rtc_run(&rr);
	uint8_t y1 = rr->year;
	uint8_t m1 = rr->month;
	uint8_t d1 = rr->day;
	// 计算日期1总天数
	for (i = 1; i < y1; i++)
	{
		if ((i % 4 == 0 && i % 100 != 0) || (i % 400 == 0))
			days1 += 366;
		else
			days1 += 365;
	}
	for (i = 1; i < m1; i++)
	{
		days1 += monthDays[i - 1];
		if (i == 2 && ((y1 % 4 == 0 && y1 % 100 != 0) || (y1 % 400 == 0)))
			days1++;
	}
	days1 += d1;

	// 日期1 - 日期2，自动产生正负
	for (i = 1; i < y2; i++)
	{
		if ((i % 4 == 0 && i % 100 != 0) || (i % 400 == 0))
			days2 += 366;
		else
			days2 += 365;
	}
	for (i = 1; i < m2; i++)
	{
		days2 += monthDays[i - 1];
		if (i == 2 && ((y2 % 4 == 0 && y2 % 100 != 0) || (y2 % 400 == 0)))
			days2++;
	}
	days2 += d2;

	// 日期1 - 日期2，自动产生正负
	return days1 - days2;
}
//////////////////读取指定时间的日使用量//////////////////////////
uint8_t get_day_used_bill(uint8_t year, uint8_t month, uint8_t day, bill_t *bill)
{

	uint16_t days = days_from_leap_year_begin(month, day);
	uint16_t len = sizeof(bill_t); // 16
	uint32_t addr = DAY_BILL_START_ADDR + len * (days - 1);
#ifdef DEBUG_BILL2
	LOG("%d-%d\r\n", month, day);
#endif
	memset(bill, 0, sizeof(bill_t));

	uint8_t ret = read_eeprom(addr, (uint8_t *)bill, len);
	if (ret != 0)
		return ret;
	if (bill->date[0] != year || bill->date[1] != month || bill->date[2] != day)
		return 1;
	return 0;
}

int32_t get_hours_between_now(uint8_t year, uint8_t month, uint8_t day, uint8_t hour)
{
	int32_t hours;
	hours = 24 * get_days_between_now(year, month, day);

	rtc_run_t *rr;
	get_rtc_run(&rr);
	hours += (signed char)(rr->hour - hour);
	return hours;
}

///////////////读取指定时间的小时使用量//////////////////////////
uint8_t get_hour_used_bill(uint8_t year, uint8_t month, uint8_t day, uint8_t hour, hour_bill_t *bill)
{
	uint16_t len = sizeof(hour_bill_t);
	uint32_t addr = HOUR_BILL_START_ADDR + HOUR_BILL_INDEX(day, hour) * len;
	memset(bill, 0, sizeof(hour_bill_t));

	// int32_t hours = get_hours_between_now(year,month,day,hour);
	// if(hours <= 0 || hours > 31 * 24)return 0;
	uint8_t ret;
	ret = read_eeprom(addr, (uint8_t *)bill, len);
	if (ret != 0)
		return ret;
	if (bill->date[0] != year || bill->date[1] != month || bill->date[2] != day || bill->date[3] != hour)
		return 1;
	return 0;
}

//////////////////读取指定时间的5分钟使用量////////////////////////////
uint8_t get_5min_used_bill(uint8_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, hour_bill_t *bill)
{
	uint16_t len = sizeof(hour_bill_t);
	uint32_t addr = FIVE_MIN_BILL_START_ADDR + len * FIVE_MIN_BILL_INDEX(day, hour, minute);

	memset(bill, 0, sizeof(hour_bill_t));
	uint8_t ret;
	ret = read_eeprom(addr, (uint8_t *)bill, len);
	if (ret != 0)
		return ret;
	if (bill->date[0] != year || bill->date[1] != month || bill->date[2] != day || bill->date[3] != hour)
		return 1;
	return 0;
}

////////////数据累加和校验生成///////////////////////
// 参数1:dat 指向数据指针
// 参数2:len数据长度
// 返回:单字节校验和
/////////////////////////////////////////////////////
uint8_t Sum8(uint8_t *dat, uint16_t len)
{
	uint8_t sum = 0;
	while (len--)
	{
		sum += dat[len]; // 单字节累加
	}
	return sum; // 返回校验值
}

///////////// 检查时间日期是否合法/////////////////////////
// 参数:时间字符串 依次是年月日时分秒周
// 异常:返回0     正常:返回1
/////////////////////////////////////
uint8_t CheckTime(uint8_t *date)
{
	if (date[1] == 0 || date[1] > 12)
		return 0; // 月
	if (date[2] == 0 || date[2] > 31)
		return 0; // 日
	if (date[3] > 23)
		return 0; // 时
	if (date[4] > 59)
		return 0; // 分
	if (date[5] > 59)
		return 0; // 秒

	return 1;
}
/////////////////备用看门狗喂狗////////////////////////////////////
void dog(void)
{

#ifdef APP_USING_SWDG
	WDG_Feed();
#endif
}
///////////////////上电初始化后读取当前流量值为累计初始流量///////////////////////////////////
// 无参数
// 无返回
////////////////////////////////////////////////////////////////////////////////
void init_cur_flow_bill(void)
{

	tm_t tm;

	cum_flow_index.cur_gcnt = 0; // 当前累计计数值 用于判断是否最新的记录,最大值为最新记录long型
	cum_flow_index.npos = 0;	 // 当前存储位置,用于写入时的地址寻址

	uint16_t i;
	uint8_t check;
	bill_cum_flow_tx cur_bill;
	for (i = 0; i < MAX_CUM_FLOW_NUM; i++)
	{

		read_eeprom(CUM_FLOW_START_ADDR + i * CUM_FLOW_SIZE, (uint8_t *)&cur_bill, sizeof(bill_cum_flow_tx)); // 依次读取每个记录
		if (cur_bill.flag == 1																				  // 有效标志 1:有效,其他无效
			&& cur_bill.gcnt >= 0																			  // 计数器在正常范围内(long型 >0有效)
			&& CheckTime(cur_bill.date_time) == 1)
		{ // 时间有效

			if (cur_bill.gcnt >= cum_flow_index.cur_gcnt)
			{

				cum_flow_index.cur_gcnt = cur_bill.gcnt + 1;		// 下一个要写入的序列号
				cum_flow_index.npos = ((i + 1) % MAX_CUM_FLOW_NUM); // 下一个要写入的相对地址
				cum_flow_index.fw = cur_bill.fw_cum_flow;
				cum_flow_index.bw = cur_bill.bw_cum_flow;
				tm.year = cur_bill.date_time[0];
				tm.month = cur_bill.date_time[1];
				tm.day = cur_bill.date_time[2];
				tm.hour = cur_bill.date_time[3];
				tm.min = cur_bill.date_time[4];
				tm.sec = cur_bill.date_time[5];
			}
		}
		feed_dog(); // 看门狗 防止复位
	}
	SetBillCumFlow(cum_flow_index.fw - cum_flow_index.bw, cum_flow_index.fw, cum_flow_index.bw); // 初始化当前流量数据

	CumFlow = cum_flow_index.fw - cum_flow_index.bw;
	FwCumFlow = cum_flow_index.fw;
	BwCumFlow = cum_flow_index.bw;

#ifdef DEBUG_BILL
	LOG("init_cum_flow fw=%f,bw=%f,gcnt=%d, add=%d\r\n", cum_flow_index.fw, cum_flow_index.bw, cum_flow_index.cur_gcnt, cum_flow_index.npos);
#endif
	// 初始化时间日期
	SetRtcTime(&tm);
}
//////////////////保存当前月存储时累积量/////////////////////////
void set_month_cur_flow_bill(void)
{ // 只输入fw_cum_flow和bw_cum_flow
	rtc_run_t *rr;
	get_rtc_run(&rr); // 获取当前时间

	bak_month_cum_flow.date[0] = rr->year;
	bak_month_cum_flow.date[1] = rr->month;
	bak_month_cum_flow.date[2] = rr->day;
	bak_month_cum_flow.date[3] = rr->hour;
	bak_month_cum_flow.date[4] = rr->minute;
	bak_month_cum_flow.date[5] = rr->second;
	bak_month_cum_flow.flag = 1;

	// if (bak_month_cum_flow.bw_cum_flow == BillRun.bw_cum_flow && bak_month_cum_flow.fw_cum_flow == BillRun.fw_cum_flow)
	//	return; // 无变化,不保存

	bak_month_cum_flow.fw_cum_flow = BillRun.fw_cum_flow;
	bak_month_cum_flow.bw_cum_flow = BillRun.bw_cum_flow;

	uint32_t addr = PRE_MONTH_COW_BAK_ADDR;
	write_eeprom(addr, (uint8_t *)&bak_month_cum_flow, sizeof(res_bill_t));
}

//////////////上电初始化时,读取上次保存的月累积量,作为下次参考/////////////////////////////////////
void init_month_cur_flow_bill(void)
{ // 只输入fw_cum_flow和bw_cum_flow
	uint32_t addr = PRE_MONTH_COW_BAK_ADDR;
	res_bill_t bill;
	memset(&bak_month_cum_flow, 0, sizeof(res_bill_t));
	read_eeprom(addr, (uint8_t *)&bill, sizeof(res_bill_t));
	if (bill.flag == 1)
	{
		bak_month_cum_flow = bill;
	}
}

//////////////////////保存当前日存储的累计量//////////////////////////////////
void set_day_cur_flow_bill(void)
{
	rtc_run_t *rr;

	get_rtc_run(&rr); // 获取当前时间
	bak_day_cum_flow.date[0] = rr->year;
	bak_day_cum_flow.date[1] = rr->month;
	bak_day_cum_flow.date[2] = rr->day;
	bak_day_cum_flow.date[3] = rr->hour;
	bak_day_cum_flow.date[4] = rr->minute;
	bak_day_cum_flow.date[5] = rr->second;
	bak_day_cum_flow.flag = 1;

	// if (bak_day_cum_flow.bw_cum_flow == BillRun.bw_cum_flow && bak_day_cum_flow.fw_cum_flow == BillRun.fw_cum_flow)
	//	return; // 无变化,不保存

	bak_day_cum_flow.fw_cum_flow = BillRun.fw_cum_flow;
	bak_day_cum_flow.bw_cum_flow = BillRun.bw_cum_flow;

	uint32_t addr = PRE_DAY_COW_BAK_ADDR;
	write_eeprom(addr, (uint8_t *)&bak_day_cum_flow, sizeof(res_bill_t));
}

////////////////////上电初始化上次日存储的累积量//////////////////
void init_day_cur_flow_bill(void)
{ // 只输入fw_cum_flow和bw_cum_flow

	uint32_t addr = PRE_DAY_COW_BAK_ADDR;
	res_bill_t bill;
	memset(&bak_day_cum_flow, 0, sizeof(res_bill_t));
	read_eeprom(addr, (uint8_t *)&bill, sizeof(res_bill_t));
	if (bill.flag == 1)
	{
		bak_day_cum_flow = bill;
	}
}

/////////////////////保存当前小时累积量///////////////////////////
void set_hour_cur_flow_bill(void)
{ // 只输入fw_cum_flow和bw_cum_flow

	rtc_run_t *rr;
	get_rtc_run(&rr); // 获取当前时间
	bak_hour_cum_flow.date[0] = rr->year;
	bak_hour_cum_flow.date[1] = rr->month;
	bak_hour_cum_flow.date[2] = rr->day;
	bak_hour_cum_flow.date[3] = rr->hour;
	bak_hour_cum_flow.date[4] = rr->minute;
	bak_hour_cum_flow.date[5] = rr->second;

	// if (bak_hour_cum_flow.bw_cum_flow == BillRun.bw_cum_flow && bak_hour_cum_flow.fw_cum_flow == BillRun.fw_cum_flow)
	//	return; // 无变化,不保存

	bak_hour_cum_flow.flag = 1;
	bak_hour_cum_flow.fw_cum_flow = BillRun.fw_cum_flow;
	bak_hour_cum_flow.bw_cum_flow = BillRun.bw_cum_flow;

	uint32_t addr = PRE_HOUR_COW_BAK_ADDR;
	write_eeprom(addr, (uint8_t *)&bak_hour_cum_flow, sizeof(res_bill_t));
}

///////////////上电初始化上次小时累积量//////////////////
void init_hour_cur_flow_bill(void)
{ // 只输入fw_cum_flow和bw_cum_flow
	uint32_t addr = PRE_HOUR_COW_BAK_ADDR;
	res_bill_t bill;
	memset(&bak_hour_cum_flow, 0, sizeof(res_bill_t));
	read_eeprom(addr, (uint8_t *)&bill, sizeof(res_bill_t));
	if (bill.flag == 1)
	{
		bak_hour_cum_flow = bill;
	}
}

void set_5min_cur_flow_bill(void)
{
	// 1. 获取当前时间
	rtc_run_t *rr;
	get_rtc_run(&rr);

	// 2. 判断数据是否有变化 (可选：如果时间变了但流量没变，是否也要保存？通常流量计费以流量变化或时间周期为准)
	// 原逻辑仅比较流量，这里保持原逻辑，但注意：如果仅靠流量变化触发，可能会丢失纯时间流逝的记录。
	// 建议结合 app_bill_run 中的时间判断逻辑，确保每5分钟强制调用一次。

	bak_5min_cum_flow.date[0] = rr->year;
	bak_5min_cum_flow.date[1] = rr->month;
	bak_5min_cum_flow.date[2] = rr->day;
	bak_5min_cum_flow.date[3] = rr->hour;
	bak_5min_cum_flow.date[4] = rr->minute;
	bak_5min_cum_flow.date[5] = rr->second;

	// if (bak_5min_cum_flow.bw_cum_flow == BillRun.bw_cum_flow && bak_5min_cum_flow.fw_cum_flow == BillRun.fw_cum_flow)
	//	{
	//		return;
	//	}

	// 3. 更新内存中的备份控制块的时间字段 (假设 bill_5min_ctrl_def 中有 date 字段，如果没有，需添加)
	// 注意：原代码 bak_5min_cum_flow 是 bill_5min_ctrl_def 类型
	// 如果该结构体没有 date 字段，建议添加 uint8_t date[6]; 以便快速比对

	bak_5min_cum_flow.bw_cum_flow = BillRun.bw_cum_flow;
	bak_5min_cum_flow.fw_cum_flow = BillRun.fw_cum_flow;

	// 4. 准备写入 EEPROM 的结构体
	uint32_t addr = PRE_5MIN_COW_BAK_ADDR + bak_5min_cum_flow.add_cnt * BAK_5MIN_SIZE;

	bak_5min_bill_t bill;
	memset(&bill, 0, sizeof(bak_5min_bill_t));

	bill.flag = 1;
	bill.global_cnt = bak_5min_cum_flow.global_cnt;
	bill.fw_cum_flow = BillRun.fw_cum_flow;
	bill.bw_cum_flow = BillRun.bw_cum_flow;

	write_eeprom(addr, (uint8_t *)&bill, sizeof(bak_5min_bill_t));

	// 5. 更新索引和计数器
	bak_5min_cum_flow.add_cnt++;
	bak_5min_cum_flow.add_cnt %= BAK_5MIN_NUM;
	bak_5min_cum_flow.global_cnt++;
}

void init_5min_cur_flow_bill(void)
{
	uint32_t addr = PRE_5MIN_COW_BAK_ADDR;
	uint8_t i;
	int32_t gcnt = -1;
	bak_5min_bill_t bill;

	// 初始化内存控制块
	memset(&bak_5min_cum_flow, 0, sizeof(bill_5min_ctrl_def));
	memset(&bill, 0, sizeof(bak_5min_bill_t));

	for (i = 0; i < BAK_5MIN_NUM; i++)
	{
		// 读取 EEPROM
		read_eeprom(addr + i * BAK_5MIN_SIZE, (uint8_t *)&bill, sizeof(bak_5min_bill_t));

		// 检查标志位
		if (bill.flag == 1)
		{
			if (bill.global_cnt > gcnt)
			{
				// 恢复累积流量
				bak_5min_cum_flow.fw_cum_flow = bill.fw_cum_flow;
				bak_5min_cum_flow.bw_cum_flow = bill.bw_cum_flow;

				gcnt = bill.global_cnt;

				// 计算下一个写入位置
				bak_5min_cum_flow.add_cnt = i + 1;
				bak_5min_cum_flow.add_cnt %= BAK_5MIN_NUM;

				// 更新全局计数器
				bak_5min_cum_flow.global_cnt = gcnt + 1;
			}
		}
	}

	// 如果没有找到有效记录，使用当前系统时间和流量初始化
	if (gcnt == -1)
	{
		rtc_run_t *rr;
		get_rtc_run(&rr);

		bak_5min_cum_flow.fw_cum_flow = BillRun.fw_cum_flow;
		bak_5min_cum_flow.bw_cum_flow = BillRun.bw_cum_flow;

		bak_5min_cum_flow.add_cnt = 0;
		bak_5min_cum_flow.global_cnt = 0;
	}
}
//////////////////////获取当前时间到结构体tm_t指针////////////////////////
void get_now_time(tm_t *tm)
{
	rtc_run_t *rr;
	get_rtc_run(&rr);
	tm->year = rr->year;
	tm->month = rr->month;
	tm->day = rr->day;
	tm->hour = rr->hour;
	tm->min = rr->minute;
	tm->sec = rr->second;
}
///////////////////////////获取上一个小时的时间/////////////////////////////////////////////////
// 参数:tm_t指针
// 返回:上一个小时的时间
/////////////////////////////////////////////////////////////
tm_t prev_hour(tm_t *date)
{
	tm_t ndate = *date;

	if (ndate.hour != 0)
	{
		ndate.hour--;
		return ndate;
	}

	ndate.hour = 23;
	uint32_t sdate = prev_day((ndate.year << 16) + (ndate.month << 8) + ndate.day);
	ndate.day = (uint8_t)sdate;
	ndate.month = (uint8_t)(sdate >> 8);
	ndate.year = (uint8_t)(sdate >> 16);
	return ndate;
}
/**
 * 获取当前流量数据并更新账单信息
 * @param ntm 指向时间结构体的指针，包含年、月、日、时、分等信息
 */
void get_cur_flow_data(tm_t *ntm)
{
	if (global_settle_flag != 0) // 在设置更新的底读之前,先进行结算
	{
		global_settle_flag = 0;
		set_month_used_bill(ntm->year, ntm->month, ntm->day);					  // 设置月度已用账单
		set_day_used_bill(ntm->year, ntm->month, ntm->day);						  // 设置日度已用账单
		set_hour_used_bill(ntm->year, ntm->month, ntm->day, ntm->hour);			  // 设置小时已用账单
		set_5min_used_bill(ntm->year, ntm->month, ntm->day, ntm->hour, ntm->min); // 设置5分钟已用账单

		BillRun.fw_cum_flow = FwCumFlow; // 设置正向累计流量
		BillRun.bw_cum_flow = BwCumFlow;
		BillRun.flow_rate = FlowVol;

		set_month_cur_flow_bill();
		set_day_cur_flow_bill();
		set_hour_cur_flow_bill();
		set_5min_cur_flow_bill();
	}
	else
	{
		BillRun.fw_cum_flow = FwCumFlow;
		BillRun.bw_cum_flow = BwCumFlow;
		BillRun.flow_rate = FlowVol;
	}
}

void app_bill_run(void)
{
//
#ifdef DEBUG_BILL
	// Debug_bill();
/* 	if (StartUp == 5)
	{
		clear_all_record();
		clear_log();
		verify_clear_operations();
		while (1)
			;
	} */
#endif
#ifdef DEBUG_LOG_WARM
	if (StartUp == 5)
		Debug_log();
#endif
	if (StartUp < 250)
		StartUp++;
	if (StartUp < 5)
		return;

	tm_t ntm;
	uint32_t ndate;

	// 1. 获取当前时间，作为所有判断的基准
	get_now_time(&ntm);

	// 获取当前流量数据，用于计算差值
	get_cur_flow_data(&ntm);

	////////////////////////////////// 月使用量记录 //////////////////////////////////
	// 判断依据：当前时间的年或月 与 备份的年月不一致
	if (bak_month_cum_flow.date[0] != ntm.year || bak_month_cum_flow.date[1] != ntm.month)
	{
		// 计算上个月的最后一天
		//	ndate = (ntm.year << 16) | (ntm.month << 8) | 1; // 当前月1号
		//	ndate = prev_day(ndate);						 // 回退一天，即上个月最后一天
		set_month_used_bill(bak_month_cum_flow.date[0], bak_month_cum_flow.date[1], bak_month_cum_flow.date[2]);
		// 使用备份的日期进行存储,无论是自然过度到第二月还是修改日期到新的月份,数据始终保存到老月份去
		//  更新备份：将当前累积流量保存为新的月度起始基准
		set_month_cur_flow_bill();
#ifdef DEBUG_BILL
		LOG("%d-%d-%d write month bill\r\n", (uint8_t)(ndate >> 16), (uint8_t)(ndate >> 8), (uint8_t)(ndate));
#endif
	}

	////////////////////////////// 日使用量记录 ////////////////////////////////////////
	// 判断依据：当前时间的年月日 与 备份的年月日不一致
	// 注意：这里必须使用原始的 ntm，不能受下方小时逻辑影响
	if (bak_day_cum_flow.date[0] != ntm.year || bak_day_cum_flow.date[1] != ntm.month || bak_day_cum_flow.date[2] != ntm.day)
	{
		// 计算昨天
		// ndate = (ntm.year << 16) | (ntm.month << 8) | ntm.day;
		// ndate = prev_day(ndate);

		// 存储昨天的使用量
		// if ((uint8_t)(ndate >> 16) == bak_day_cum_flow.date[0] && (uint8_t)(ndate >> 8) == bak_day_cum_flow.date[1] && (uint8_t)(ndate) == bak_day_cum_flow.date[2])
		// if (ndate >= ((bak_day_cum_flow.date[0] << 16) | (bak_day_cum_flow.date[1] << 8) | bak_day_cum_flow.date[2]))
		//{ // 结算日期必须大于等于备份日期, 否则只更新基准,不记录使用量
		set_day_used_bill(bak_day_cum_flow.date[0], bak_day_cum_flow.date[1], bak_day_cum_flow.date[2]);
		//}
		// 更新备份：将当前累积流量保存为新的日度起始基准
		set_day_cur_flow_bill();
#ifdef DEBUG_BILL
		LOG("%d-%d-%d write day bill\r\n", (uint8_t)(ndate >> 16), (uint8_t)(ndate >> 8), (uint8_t)(ndate));
#endif
	}

	/////////////////////////////// 小时使用量记录 /////////////////////////////////////
	// 判断依据：当前时间的年月日时 与 备份的年月日时不一致
	if (bak_hour_cum_flow.date[0] != ntm.year || bak_hour_cum_flow.date[1] != ntm.month ||
		bak_hour_cum_flow.date[2] != ntm.day || bak_hour_cum_flow.date[3] != ntm.hour)
	{
		// tm_t prev_h_tm;

		// 计算上一个小时的时间，用于存入记录的数据头（表示该小时结束的时间点或归属）
		// 注意：不要直接修改 ntm，而是使用临时变量
		// prev_h_tm = ntm;
		// if (prev_h_tm.hour == 0)
		// {
		// 	// 如果当前是0点，上一个小时是昨天的23点
		// 	uint32_t prev_day_date = (prev_h_tm.year << 16) | (prev_h_tm.month << 8) | prev_h_tm.day;
		// 	prev_day_date = prev_day(prev_day_date);
		// 	prev_h_tm.year = (uint8_t)(prev_day_date >> 16);
		// 	prev_h_tm.month = (uint8_t)(prev_day_date >> 8);
		// 	prev_h_tm.day = (uint8_t)(prev_day_date);
		// 	prev_h_tm.hour = 23;
		// }
		// else
		// {
		// 	prev_h_tm.hour--;
		// }

		// 存储上一个小时的使用量
		// uint32_t baklong = ((bak_hour_cum_flow.date[0] << 24) | (bak_hour_cum_flow.date[1] << 16) | (bak_hour_cum_flow.date[2] << 8) | (bak_hour_cum_flow.date[3]));
		// uint32_t prevlong = ((prev_h_tm.year << 24) | (prev_h_tm.month << 16) | (prev_h_tm.day << 8) | (prev_h_tm.hour));
		// if (bak_hour_cum_flow.date[0] == prev_h_tm.year && bak_hour_cum_flow.date[1] == prev_h_tm.month && bak_hour_cum_flow.date[2] == prev_h_tm.day && bak_hour_cum_flow.date[3] == prev_h_tm.hour)
		// if (baklong <= prevlong)
		//{ // 备份的时间必须早于当前时间的上一个小时,才记录时结数据
		set_hour_used_bill(bak_hour_cum_flow.date[0], bak_hour_cum_flow.date[1], bak_hour_cum_flow.date[2], bak_hour_cum_flow.date[3]);
		//}
		// 更新备份：将当前累积流量保存为新的小时起始基准
		set_hour_cur_flow_bill();
		// #ifdef DEBUG_BILL
		//		LOG("%d-%d-%d %d write hour bill\r\n", prev_h_tm.year, prev_h_tm.month, prev_h_tm.day, prev_h_tm.hour);
		// #endif
	}

	////////////////////////////// 5min使用量记录 /////////////////////////////////////
	if (bak_5min_cum_flow.date[0] != ntm.year || bak_5min_cum_flow.date[1] != ntm.month ||
		bak_5min_cum_flow.date[2] != ntm.day || bak_5min_cum_flow.date[3] != ntm.hour ||
		bak_5min_cum_flow.date[4] / 5 != ntm.min / 5)
	{
		// tm_t bak_t;
		// bak_t.year = bak_5min_cum_flow.date[0];
		// bak_t.month = bak_5min_cum_flow.date[1];
		// bak_t.day = bak_5min_cum_flow.date[2];
		// bak_t.hour = bak_5min_cum_flow.date[3];
		// bak_t.min = bak_5min_cum_flow.date[4];

		// tm_t prev_5min_tm = get_prev_5min_tm(bak_t);
		// if (datecmp(bak_t, ntm) < 0) // 备份时间小于当前时间，则记录使用量
		//{
		set_5min_used_bill(bak_5min_cum_flow.date[0], bak_5min_cum_flow.date[1], bak_5min_cum_flow.date[2], bak_5min_cum_flow.date[3], bak_5min_cum_flow.date[4]);
		//}
		set_5min_cur_flow_bill();
#ifdef DEBUG_BILL
		LOG("%d-%d-%d %d:%d write 5min bill\r\n", ntm.year, ntm.month, ntm.day, ntm.hour, ntm.min);
#endif
	}
	save_cur_flow_bill();
}

#ifdef DEBUG_BILL
/////////////调试bill各种计量用/////////////////
unsigned short dbg_bill_cnt = 0;
double debug_fw = 0, debug_bw = 0, debug_vol, debug_w;
void Debug_bill(void)
{
	dbg_bill_cnt++;
	/////////模拟计量/////////////

	get_cur_flow_bill(&debug_w, &debug_fw, &debug_bw);
	debug_fw += 10000; //*date.day;
	debug_bw += 10000; //*date.day;
	debug_w = 0;
	debug_vol = 50000; //+date.hour;

	set_cur_flow_bill(debug_w, debug_fw, debug_bw);
	///////////test month///////////////////
	tm_t date, date2;
	if (dbg_bill_cnt == 1)
	{
		date.year = 26;
		date.month = 1;
		date.day = 1;
		date.hour = 0;
		date.min = 0;
		date.sec = 0;
		SetRtcTime(&date);
	}

	get_now_time(&date);
#if DEBUG_SAVE_BAK == 1 // 1min
	if (date.sec >= 3 && date.sec <= 57)
		date.sec = 58;
#elif DEBUG_5MIN_REC == 1  // 5min
	if (date.sec >= 3 && date.sec <= 20)
	{
		date.sec = 55 - date.min / 5;
		// if ((date.min % 5) != 0)
		//	date.min = date.min - (date.min % 5);
		date.min += 4;
		date.min %= 60;
	}
#elif DEBUG_HOUR_REC == 1  // 1hour
	if (date.sec >= 3 && date.sec <= 30)
	{
		date.sec = 58 - date.hour;
		// if((date.min != 0)date.min = 0;//date.min - (date.min%5);
		date.min = 59;
	}
#elif DEBUG_DAY_REC == 1   // 1day
	if (date.sec >= 3 && date.sec <= 20)
	{
		date.sec = 58 - date.day;
		// if((date.min != 0)date.min = 0;//date.min - (date.min%5);
		date.min = 59;
		date.hour = 23;
	}
#elif DEBUG_MONTH_REC == 1 // 1month
	if (date.sec >= 3 && date.sec <= 40)
	{
		date.sec = 58 - date.month;
		// if((date.min != 0)date.min = 0;//date.min - (date.min%5);
		date.min = 59;
		date.hour = 23;
		date.day = monthday[date.month - 1];
		if ((date.year % 4) == 0 && date.month == 2)
			date.day += 1;
	}
#endif
	SetRtcTime(&date);
	//}
	if (dbg_bill_cnt > 1000)
		while (1)
			;
/////////////////disp time//////////////////////
#ifdef DEBUG_DISP_TIME
	rtc_run_t *rr;
	get_rtc_run(&rr);
	LOG("run_time:20%2d-%2d-%2d:%2d:%2d:%2d fw=%f,bw=%f\r\n", rr->year, rr->month, rr->day, rr->hour, rr->minute, rr->second, BillRun.fw_cum_flow, BillRun.bw_cum_flow); // 锟斤拷示时锟斤拷
#endif
}
#endif

int8_t SetRtcTime(tm_t *date)
{
	if (date->month == 0 || date->month > 12)
		return 2;
	if (date->day == 0 || date->day > 31)
		return 2;
	if (date->hour > 23)
		return 2;
	if (date->min > 59)
		return 2;
	if (date->sec > 59)
		return 2;

	uint8_t year_bcd;
	uint8_t month_bcd;
	uint8_t day_bcd;
	uint8_t second_bcd;
	uint8_t minute_bcd;
	uint8_t hour_bcd;
	// year = ((NbAppFrame.data[4] << 8) | NbAppFrame.data[5]) % 2000;
	year_bcd = OctToBcd((uint8_t)date->year); // 自取了低8位,8位二进制转换为
	month_bcd = OctToBcd(date->month);
	day_bcd = OctToBcd(date->day);
	set_rtc_date(year_bcd, month_bcd, day_bcd); // 直接操作寄存器写入日期

	hour_bcd = OctToBcd(date->hour);
	minute_bcd = OctToBcd(date->min);
	second_bcd = OctToBcd(date->sec);
	set_rtc_time(hour_bcd, minute_bcd, second_bcd); // 保存时分秒
	rtc_run_t tm;
	tm.year = date->year;
	tm.month = date->month;
	tm.day = date->day;
	tm.hour = date->hour;
	tm.minute = date->min;
	tm.second = date->sec;
	set_rtc_run(&tm);
	return 1;
}
void clear_log(void)
{
	uint32_t addr = ALARM_START_ADDR;
	// 计算日志区域的总大小
	uint32_t end_addr = ALARM_START_ADDR + (uint32_t)MAX_ALARM_NUM * ALARM_DATA_SIZE;

	if (end_addr <= addr)
	{
		LOG("Clear log error: Invalid address range.\r\n");
		return;
	}

	uint32_t total_size = end_addr - addr;

// 定义单次写入块大小，与 clear_all_record 保持一致
// write_eeprom_para 内部缓冲区支持最大 128 字节有效数据
#define LOG_CLEAR_BLOCK_SIZE 128

	uint8_t dat[LOG_CLEAR_BLOCK_SIZE];
	memset(dat, 0xFF, LOG_CLEAR_BLOCK_SIZE);

	LOG("Start clearing logs (%d bytes)...\r\n", total_size);

	uint32_t processed = 0;
	uint8_t last_progress = 0;
	uint8_t ret;

	while (processed < total_size)
	{
		// 计算本次实际写入长度
		uint32_t remaining = total_size - processed;
		uint16_t write_len = (remaining > LOG_CLEAR_BLOCK_SIZE) ? LOG_CLEAR_BLOCK_SIZE : (uint16_t)remaining;

		// 执行写入
		ret = write_eeprom_para(addr, dat, write_len);

		if (ret != 0)
		{
			LOG("EEPROM log clear error at addr %d\r\n", addr);
			// 可根据需求选择 break 或继续
		}

		addr += write_len;
		processed += write_len;

		// 计算进度百分比
		uint8_t progress = (uint8_t)(processed * 100 / total_size);

		// 每 10% 打印一次进度
		if (progress >= last_progress + 10)
		{
			last_progress = progress;
			LOG("Clearing logs... %d%%\r\n", progress);

// 重要：长时间操作需喂狗
#ifdef APP_USING_SWDG
			WDG_Feed();
#endif
		}
	}

	LOG("Clear log complete.\r\n");
}

extern void clr_max_flow_rate(void);
extern void clr_max_flow_rate_all(void);

void clear_all_record(void)
{
	// 定义单次写入块大小 (128字节效率较高且栈安全)
	clear_bottom_data();	 // 底读设置为0,并保存
	clr_max_flow_rate_all(); // 清最高瞬时流量
	clr_bill_struct_data();	 // 清除日结,月结等所有结算数据的基准累积量
							 // 下面是清除所有结算数据
#define CLEAR_BLOCK_SIZE 128
	uint8_t dat[CLEAR_BLOCK_SIZE];
	memset(dat, 0xFF, CLEAR_BLOCK_SIZE);

	LOG("Start clearing all records and backups...\r\n");

	// --- 第一部分：清除原有账单记录区域 (MONTH_BILL_START_ADDR 到 END_RECORD_ADDR) ---
	uint32_t addr = MONTH_BILL_START_ADDR;
	uint32_t end_addr = END_RECORD_ADDR;

	if (end_addr > addr)
	{
		uint32_t total_size = end_addr - addr;
		uint32_t processed = 0;
		uint8_t last_progress = 0;
		uint8_t ret;

		LOG("Clearing Bill Records (0x%x - 0x%x)...\r\n", addr, end_addr);

		while (processed < total_size)
		{
			uint32_t remaining = total_size - processed;
			uint16_t write_len = (remaining > CLEAR_BLOCK_SIZE) ? CLEAR_BLOCK_SIZE : (uint16_t)remaining;

			ret = write_eeprom_para(addr, dat, write_len);
			if (ret != 0)
			{
				LOG("EEPROM clear error at addr %d\r\n", addr);
			}

			addr += write_len;
			processed += write_len;

			uint8_t progress = (uint8_t)(processed * 100 / total_size);
			if (progress >= last_progress + 20)
			{
				last_progress = progress;
				LOG("  Records: %d%%\r\n", progress);
#ifdef APP_USING_SWDG
				WDG_Feed();
#endif
			}
		}
		LOG("Bill Records cleared.\r\n");
	}

	// --- 第二部分：清除备份数据区域 (从 PRE_MONTH_COW_BAK_ADDR 开始) ---
	// 计算备份区域的总长度：
	// 1. 月/日/时备份: 3 * COW_BAK_DATA_SIZE (3 * 32 = 96 bytes)
	// 2. 5分钟备份: BAK_5MIN_NUM * BAK_5MIN_SIZE (8 * 32 = 256 bytes)
	// 总长度 = 96 + 256 = 352 bytes (0x160)
	addr = PRE_MONTH_COW_BAK_ADDR;
	uint32_t backup_total_size = (3 * COW_BAK_DATA_SIZE) + (BAK_5MIN_NUM * BAK_5MIN_SIZE);

	if (backup_total_size > 0)
	{
		uint32_t processed = 0;
		LOG("Clearing Backup Area (Start: 0x%x, Size: %d bytes)...\r\n", addr, backup_total_size);

		while (processed < backup_total_size)
		{
			uint32_t remaining = backup_total_size - processed;
			uint16_t write_len = (remaining > CLEAR_BLOCK_SIZE) ? CLEAR_BLOCK_SIZE : (uint16_t)remaining;

			write_eeprom_para(addr, dat, write_len);

			addr += write_len;
			processed += write_len;

// 备份区域较小，每完成一次循环或最后喂狗即可，也可按比例打印
#ifdef APP_USING_SWDG
			WDG_Feed();
#endif
		}
		LOG("Backup Area cleared.\r\n");
	}

	LOG("Clear all records and backups complete.\r\n");
}
void clear_bottom_data(void)
{ // 清除底读
	set_cur_flow_bill(0, 0, 0);
	save_cur_flow_flag = 1;
}
#ifdef DEBUG_BILL
static uint8_t verify_eeprom_region(uint32_t start_addr, uint32_t size, const char *name)
{
#define VERIFY_BUF_SIZE 128
	uint8_t buf[VERIFY_BUF_SIZE];
	uint32_t processed = 0;
	uint8_t ret = 0; // 0: OK, 1: Error

	LOG("Verifying %s (Addr: 0x%x, Size: %d)... ", name, start_addr, size);

	while (processed < size)
	{
		uint32_t remaining = size - processed;
		uint16_t read_len = (remaining > VERIFY_BUF_SIZE) ? VERIFY_BUF_SIZE : (uint16_t)remaining;

		// 批量读取
		if (eeprom_MassRead(buf, start_addr + processed, read_len) != 0)
		{
			LOG("READ ERR\r\n");
			return 1;
		}

		// 检查是否全为 0xFF
		for (uint16_t i = 0; i < read_len; i++)
		{
			if (buf[i] != 0xFF)
			{
				LOG("FAIL at offset %d (Byte: 0x%X)\r\n", processed + i, buf[i]);
				ret = 1;
				// 可以选择继续检查以发现更多错误，或者直接返回
				// return 1;
			}
		}

		processed += read_len;

// 防止看门狗复位，特别是大区域验证时
#ifdef APP_USING_SWDG
		if (processed % (VERIFY_BUF_SIZE * 10) == 0)
		{
			WDG_Feed();
		}
#endif
	}

	if (ret == 0)
	{
		LOG("OK\r\n");
	}

	return ret;
}

/**
 * @brief 验证清除操作的结果
 */
void verify_clear_operations(void)
{
	LOG("--- Start Verification of Clear Operations ---\r\n");

	uint8_t err_cnt = 0;

	// 1. 验证账单记录区域
	if (END_RECORD_ADDR > MONTH_BILL_START_ADDR)
	{
		if (verify_eeprom_region(MONTH_BILL_START_ADDR, END_RECORD_ADDR - MONTH_BILL_START_ADDR, "Bill Records") != 0)
		{
			err_cnt++;
		}
	}

	// 2. 验证备份区域 (从 PRE_MONTH_COW_BAK_ADDR 开始)
	// 长度 = 月/日/时备份 (3 * 32) + 5分钟备份 (8 * 32) = 96 + 256 = 352 字节
	uint32_t backup_size = (3 * COW_BAK_DATA_SIZE) + (BAK_5MIN_NUM * BAK_5MIN_SIZE);
	if (verify_eeprom_region(PRE_MONTH_COW_BAK_ADDR, backup_size, "Backup Area") != 0)
	{
		err_cnt++;
	}

	// 3. 验证日志区域
	uint32_t log_size = (uint32_t)MAX_ALARM_NUM * ALARM_DATA_SIZE;
	if (verify_eeprom_region(ALARM_START_ADDR, log_size, "Alarm Logs") != 0)
	{
		err_cnt++;
	}

	if (err_cnt == 0)
	{
		LOG("--- All Verifications PASSED ---\r\n");
	}
	else
	{
		LOG("--- Verification FAILED with %d errors ---\r\n", err_cnt);
	}
}

#endif
void clr_bill_struct_data(void)
{
	memset(&bak_month_cum_flow, 0, sizeof(bak_month_cum_flow));
	memset(&bak_day_cum_flow, 0, sizeof(bak_day_cum_flow));
	memset(&bak_hour_cum_flow, 0, sizeof(bak_hour_cum_flow));
	memset(bak_5min_cum_flow.date, 0, 6);
	bak_5min_cum_flow.fw_cum_flow = 0;
	bak_5min_cum_flow.bw_cum_flow = 0;
	cum_flow_index.bw = 0;
	cum_flow_index.fw = 0;
}
//// 检查日期是否有效
uint8_t CheckDateValid(uint8_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t min, uint8_t sec)
{
	if (year >= 100 || month == 0 || month > 12 || day == 0 || day > 31 || hour > 23 || min > 59 || sec > 59)
		return 0;
	if (day > monthday[month - 1] + ((year % 4 == 0 && month == 2) ? 1 : 0))
		return 0;
	return 1;
}