HBshuiwuConcentrator/filedata/filedata.c

#include "file.h"
#include "filedata.h"

extern u8 GetSum(u8 * buffer, u16 length);


struct waterdata_struct waterdata;
struct curtime_struct curtime;
struct valid_struct valid;

uint8_t get_ck(uint8_t *val, uint16_t len)
{
	return GetSum(val, len);
}


//得到正向数据
static void get_forwarddata()
{
}

//得到反向数据
static void get_reverseddata()
{
}

/*
//得到状态
static void get_status()
{
waterdata.status[0] = 0;
waterdata.status[1] = 0;
}
*/
//得到状态


static void get_waterdata(int32_t year,uint8_t mon,uint8_t day,uint8_t hour,uint8_t min)
{
	get_forwarddata();
	get_reverseddata();
	waterdata.invalid = DATA_VALID_AA;
	waterdata.year = year;
	waterdata.mon = mon;
	waterdata.day = day;
	waterdata.hour = hour;
	waterdata.min = min;
	waterdata.crc = get_ck(&(waterdata.invalid),WATERDATA_LEN);
}

uint32_t get_base_time()
{
	return curtime.time;
}


bool curtime_iscmp(struct curtime_struct * time1,struct curtime_struct * time2)
{
	if(time1->time == time2->time && time1->year == time2->year && 
		time1->mon == time2->mon && time1->day == time2->day && 
		time1->crc == time2->crc)
	{
		return true;
	}
	return false;
}

void curtime_write()
{
	uint32_t year = 0;
	uint8_t mon = 0;
	uint8_t day = 0;
	struct curtime_struct tmpcurtime;

	curtime.time = get_curtime(&year,&mon,&day);
	curtime.year = year;
	curtime.mon = mon;
	curtime.day = day;
	curtime.crc = get_ck((uint8_t*)&(curtime),CUR_TIME_LEN);

	file_curtime_read((uint8_t*)&tmpcurtime,sizeof(tmpcurtime));

	if(!curtime_iscmp(&tmpcurtime,&curtime))
	{
		file_curtime_write((uint8_t*)&curtime,sizeof(curtime));
	}
}

void validflag_read(uint8_t day)
{
	file_validflag_read(day,(uint8_t*)&valid,sizeof(valid));

	if(valid.crc != get_ck((uint8_t*)&(valid),VALID_DATA_LEN))
	{
		valid.valid = 0xFF;
	}
}

void validflag_write(uint32_t year,uint8_t mon,uint8_t date,uint8_t day)
{
	//标志每天只写一直。
	//如果年月日和保存的年月日不等，认为写入。
	//数据是否有效
	validflag_read(day);
	if(valid.year != year || valid.mon != mon || valid.day != date)
	{
		valid.year = year;
		valid.mon = mon;
		valid.day = date;
		valid.valid = DATA_VALID_AA;
		valid.crc = get_ck((uint8_t*)&(valid),VALID_DATA_LEN);
		file_validflag_write(day,(uint8_t*)&valid,sizeof(valid));
	}
	else
	{
		//如果年月日和保存的年月日相等，但是有效标志不等于AA
		if(valid.valid == DATA_VALID_AA)
		{
		}
		else
		{
			valid.year = year;
			valid.mon = mon;
			valid.day = date;
			valid.valid = DATA_VALID_AA;
			valid.crc = get_ck((uint8_t*)&(valid),VALID_DATA_LEN);
			file_validflag_write(day,(uint8_t*)&valid,sizeof(valid));
		}
	}
}

uint8_t get_validflag()
{
	return valid.valid;
}

uint32_t get_validyear()
{
	return valid.year;
}

uint8_t get_validmon()
{
	return valid.mon;
}

uint8_t get_validday()
{
	return valid.day;
}

void adjust_basetime()
{
	uint32_t year = 0;
	uint8_t mon = 0;
	uint8_t date = 0;
	uint8_t day = 0;
	uint32_t time = 0;

	time = get_curtime(&year,&mon,&date);
	file_curtime_read((uint8_t*)&curtime,sizeof(curtime));
	//第一次开机
	if(curtime.crc != get_ck((uint8_t*)&(curtime),CUR_TIME_LEN))
	{
		curtime_write();
	}
	//如果基准时间大于当前时间
	if(curtime.time>time)
	{
		curtime_write();
	}
	else
	{
		day = get_space_day(time,curtime.time);
		//如果间隔时间大于DATA_DAY_MAX，重新计数
		if(day>=DATA_DAY_MAX)
		{
			curtime_write();
		}
	}
}


bool is_waterdata_save(uint8_t space,uint32_t year,uint8_t mon,uint8_t day,uint8_t hour,uint8_t min)
{
	struct waterdata_struct waterdata;
	file_waterdata_read(space,hour,min,(uint8_t *)&waterdata,sizeof(waterdata));
	if(waterdata.year == year && waterdata.mon == mon &&  waterdata.day == day && waterdata.hour == hour && waterdata.min == min)
	{
		return false;
	}
	return true;
}


void waterdata_write(uint32_t year,uint8_t mon,uint8_t day,uint8_t hour,uint8_t min,uint8_t sec)
{
	uint8_t space = 0;  
	uint32_t oldtime = 0;
	uint32_t newtime = 0;

	//修正基准时间，新时间会大于等于基准时间，并且小于DATA_DAY_MAX
	//建立在时间准确的条件下
	adjust_basetime();

	oldtime = get_base_time();
	newtime = mktime(year,mon,day,0,0,0);
        
	min = 0;
        
	if(newtime>=oldtime)
	{
		space =  get_space_day(oldtime,newtime);

		//如果是当前年月日，不处理。
		validflag_write(year,mon,day,space);
		//得到时间和数据，保存。
		get_waterdata(year,mon,day,hour,min);

		if(is_waterdata_save(space,year,mon,day,hour,min))
		{
			file_waterdata_write(space,hour,min,(uint8_t *)&waterdata,sizeof(waterdata));
		}
	}
}

//当前时间减去基准时间，得到天数
static uint8_t get_sub_day()
{
	uint32_t year = 0;
	uint8_t mon = 0;
	uint8_t date = 0;
	uint32_t oldtime = get_base_time();
	uint32_t newtime = get_curtime(&year,&mon,&date);
	uint16_t day = 0;
	if(newtime>oldtime)
	{
		day =  get_space_day(oldtime,newtime);
	}
	return day;
}

//得到在i2c中的位置
uint8_t get_realday(uint8_t day)
{
	uint8_t realday = 0;
	uint8_t subday = 0;
	//计算需要重新测试
	subday = get_sub_day();
	if(subday>day)
	{
		realday = subday - day-1;
		if(realday>DATA_DAY_MAX-1)
		{
			realday = 0;
		}
	}
	else
	{
		realday = DATA_DAY_MAX - 1 - (day - subday);
	}

#ifdef DEBUG_FILEI2C  
	HT_PRINT("总天数=%02d i2c位置=%02d 前几日=%02d\r\n",DATA_DAY_MAX,realday,day);
#endif
	return realday;
}


void hb_waterdata_write(u16 count,struct waterdata_struct * waterdata)
{
      file_waterdata_write(count,0,0,(uint8_t *)waterdata,sizeof(struct waterdata_struct));
}

void hb_waterdata_read(u16 count,struct waterdata_struct * waterdata)
{
      file_waterdata_read(count,0,0,(uint8_t *)waterdata,sizeof(struct waterdata_struct));
}