data_flash.c

bf533平台图像采集程序

	
	return ret;
}


//sent:		if has been sent out through gprs
int df_write_jpeg(jpeg_pack_t* jpeg_pack)
{
	jpeg_storage_t* jpeg = km29_ctrl->jpeg + km29_ctrl->jpeg_cur_index; 
	int last_block;
	
	jpeg->channel		= -1;
	jpeg->sent			= jpeg_pack->sent;	
	jpeg->size			= jpeg_pack->info.size;
	jpeg->pic_big		= jpeg_pack->info.pic_big;	
	jpeg->quality		= jpeg_pack->info.quality;
	jpeg->itime			= calc_itime(jpeg_pack->info.time);
	jpeg->start_block	= km29_ctrl->jpeg_cur_block;
	
	last_block = program_blocks(jpeg_pack->data, jpeg->size, km29_ctrl->jpeg_cur_block, 
		BLOCK_JPEG_START, BLOCK_JPEG_END);
	
	if(last_block < 0)
		return -1;

	jpeg->channel		= jpeg_pack->info.channel;
	jpeg->end_block		= last_block;
	
	//below reuse jpeg pointer
	while(1)	
	{
		jpeg_storage_t* j;
		j = km29_ctrl->jpeg + km29_ctrl->jpeg_start_index;
		
		if(km29_ctrl->jpeg_start_index == km29_ctrl->jpeg_cur_index)
			break;
		else			
		{
			int a0 = km29_ctrl->jpeg_cur_block, a1 = last_block;
			int b0 = j->start_block, b1 = j->end_block;
			int overlap = 0, tmp;
			int a[20], b[20], ac, bc, m, n;


			ac = 0;						
			while(a0 != a1)
			{
				a[ac++] = a0++;
				if(a0 >= BLOCK_JPEG_END) a0 = BLOCK_JPEG_START;
			}
			a[ac++] = a0++;
			
			bc = 0;						
			while(b0 != b1)
			{
				b[bc++] = b0++;
				if(b0 >= BLOCK_JPEG_END) b0 = BLOCK_JPEG_START;
			}
			b[bc++] = b0++;
			
			for(m = 0; m < ac; m++)
				for(n = 0; n < bc; n++)	
					if(a[m] == b[n]) overlap = 1;
			
			if(overlap)
			{
				j->channel = -1; //over write it
				km29_ctrl->jpeg_start_index++;
				km29_ctrl->jpeg_start_index %= MAX_JPEG;
			}
			else
				break;
		}
	}

	last_block++;
	if(last_block >= BLOCK_JPEG_END)
		last_block = BLOCK_JPEG_START;
		
	km29_ctrl->jpeg_cur_block = last_block;
	
	km29_ctrl->jpeg_cur_index++;
	km29_ctrl->jpeg_cur_index %= MAX_JPEG;
		
	km29_ctrl_updated = 1;
			
	return 0;
}

int next_block(int cur_block)
{
	while(1)
	{
		km29_ctrl->electricity_cur_block += 1;
		
		if(km29_ctrl->electricity_cur_block >= BLOCK_ELECTRICITY_END)
			km29_ctrl->electricity_cur_block = BLOCK_ELECTRICITY_START;
			
		if(km29_ctrl->electricity_cur_block == cur_block)
			return -1;
			
		if(km29_ctrl->block_invalid[km29_ctrl->electricity_cur_block] == 0)
			break;
	}
	
	km29_ctrl_updated = 1;
	return 0;	
}

int df_write_electricity(electricity_pack_t* electricity_pack)
{
	int ret, page, i;
	
	electricity_block_t* b = km29_ctrl->electricity;
	int size = sizeof(electricity_pack_t);
	int cur_block = km29_ctrl->electricity_cur_block;
	
	//获取目标blcok, page
	ret = read_block((char*)block_buf, BLOCK_SIZE, km29_ctrl->electricity_cur_block);
	if(ret < 0)
	{
		ret = erase_block(km29_ctrl->electricity_cur_block);
		if(ret < 0)
		{
			km29_ctrl->block_invalid[km29_ctrl->electricity_cur_block] = 1;
			ret = next_block(cur_block);
			if(ret < 0) return -1;
		}
		page = 0;
	}
	else
	{
		int* t;
		
		page = -1; //assume -1
		for(i = 0; i < PAGES_PER_BLOCK; i++)
		{
			t = (int*)(block_buf+i*BYTES_PER_PAGE);
			if((*t) == -1)
			{
				page = i;
				break;
			}
		}
		if(page == -1)	
		{
			ret = next_block(cur_block);
			if(ret < 0) return -1;
			page = 0;				
		}
	}
	//获得了目标block, page
	
	while(1)
	{
		ret = program_page((char*)electricity_pack, size, km29_ctrl->electricity_cur_block, page);
		if(ret == 0) 
		{
			if(page == 0)
			{
				b[km29_ctrl->electricity_cur_block-BLOCK_ELECTRICITY_START].have_elec = 1;
				b[km29_ctrl->electricity_cur_block-BLOCK_ELECTRICITY_START].itime = electricity_pack->itime;
				km29_ctrl_updated = 1;
			}
			if(electricity_pack->sent_fail)			
			{
				b[km29_ctrl->electricity_cur_block-BLOCK_ELECTRICITY_START].sent_fail_mark |= 1 << page;
				km29_ctrl_updated = 1;
			}
			if(page == PAGES_PER_BLOCK-1)
			{
				b[km29_ctrl->electricity_cur_block-BLOCK_ELECTRICITY_START].itime2 = electricity_pack->itime;
				ret = next_block(cur_block);
				if(ret < 0) return -1;		
				erase_block(km29_ctrl->electricity_cur_block);		
			}
			break;
		}
		else
		{
			km29_ctrl->block_invalid[km29_ctrl->electricity_cur_block] = 1;
			km29_ctrl_updated = 1;
			ret = next_block(cur_block);
			if(ret < 0) return -1;

			page = 0;
		}
	}
	
	return 0;
}
	
int df_get_electricity(electricity_pack_t* epack, char* start_time, char* end_time, 
		electricity_search_index_t* si, int max_cnt)
{
	int stime, etime, i, page, cnt = 0;
	electricity_pack_t* p;
	
	electricity_block_t* eb = km29_ctrl->electricity;
	
	stime = calc_itime(start_time);
	etime = calc_itime(end_time);
	
	i = si->array_index;
	page = si->page;
	
	for(; i < MAX_ELECTRICITY; i++)
	{
		if(km29_ctrl->block_invalid[i+BLOCK_ELECTRICITY_START] == 1 
			|| eb[i].have_elec == 0)
			continue;
			
		if((eb[i].itime >= stime && eb[i].itime <= etime)
			|| (eb[i].itime2 >= stime && eb[i].itime2 <= etime))
		{
			read_block((char*)block_buf, BLOCK_SIZE, i+BLOCK_ELECTRICITY_START);
			for(; page < PAGES_PER_BLOCK; page++)
			{
				p = (electricity_pack_t*)(block_buf+page*BYTES_PER_PAGE);
				if(p->cnt != 3)
					return cnt;
				
				if(p->itime >= stime && p->itime <= etime)
				{
					if(page + 1 >= PAGES_PER_BLOCK)
					{
						si->array_index = i + 1;
						si->page = 0;
					}
					else
					{
						si->array_index = i;
						si->page = page+1;
					}
					
					*epack++ = *p;
					if(++cnt >= max_cnt)
						return cnt;
				}
			}
			page = 0;
		}
	}
	
	return cnt;
}


//return: records count
int df_get_electricity_sent_fail(electricity_pack_t* epack, int max_cnt, 
		electricity_search_index_t* si, electricity_search_index_t* items)
{
	int i, j, page, ret, cnt = 0;
	char buf[BYTES_PER_PAGE];
	
	electricity_pack_t* epage = (electricity_pack_t*) buf;
	electricity_block_t* eb = km29_ctrl->electricity;
	
	i = si->array_index;
	page = si->page;
			
	for(; i < MAX_ELECTRICITY; i++)
	{
		if(km29_ctrl->block_invalid[i+BLOCK_ELECTRICITY_START] == 1
			|| eb[i].have_elec != 1)
			continue;
			
		for(; page < PAGES_PER_BLOCK; page++)
		{
			if( eb[i].sent_fail_mark & (1<<page) )
			{
				ret = read_page(buf, 0, i+BLOCK_ELECTRICITY_START, page);
				if(ret < 0)
				{
					eb[i].sent_fail_mark &= ~(1<<page); //read data error, ignore this record
					continue;
				}

				*epack++ = *epage;
				
				//fill search struct
				items[cnt].array_index = i;
				items[cnt].page = page;
				
				if(++cnt >= max_cnt)
				{
					if(page >= PAGES_PER_BLOCK-1)
					{
						si->array_index = i + 1;
						si->page = 0;
					}
					else
					{
						si->array_index = i;
						si->page = page+1;
					}
					return cnt;
				}
			}
		}
		
		page = 0;
	}
	
	return cnt;
}

int df_electricity_sent(electricity_search_index_t* items, int cnt)
{
	int i;
	electricity_block_t* eb = km29_ctrl->electricity;
	
	for(i = 0; i < cnt; i++)
	{
		eb[items[i].array_index].sent_fail_mark &= ~(1<<items[i].page);
	}
	
	km29_ctrl_updated = 1;
	return 0;
}
*/

 
void GPRS_INFO_INIT(GPRS_INFORMATION_T *gprs_info)
{
	
	strcpy(gprs_info->passwords, "12345678");
	strcpy(gprs_info->administrator,"13750849639");
	strcpy(gprs_info->arbiter,"13750849639");
	strcpy(gprs_info->server_number, "13757174774" );
	gprs_info->camera_switch = 1<<3;
	gprs_info->pic_size = '0';
	gprs_info->pic_Q[0] = '8';
	gprs_info->pic_Q[1] = '0';
	gprs_info->auto_detect_open = '0';
	
}

//init once
//return: -1 error, bad flash chip; 2 success
int DF_First_init()
{
	int i, ret;
	char buf[20];
	char identifier[24] = "[e-mail]";
	
	
	memset((char*)data_flash,0,sizeof(DATA_FLASH_T));
	
	memcpy(data_flash->identifier, identifier, strlen(identifier));

	memcpy(data_flash->time_base, "20060101000000", 14);
	
	GPRS_INFO_INIT(&(data_flash->gprs_info));
	
	data_flash->jpeg_cur_block				= BLOCK_JPEG_START;
	data_flash->Pic_Total_Number				= 0;
	data_flash->Pic_Cur_Num			= 0;


	for(i = 0; i < TOTAL_BLOCK; i++)
	{
		data_flash->block_invalid[i] = 0; //assume valid
		
		ret = read_page(buf, 1, i, 0);
		if(buf[5] == 0xff || ret < 0)
			data_flash->block_invalid[i] = 1;
			
		ret = read_page(buf, 1, i, 1);
		if(buf[5] == 0xff || ret < 0)
			data_flash->block_invalid[i] = 1;
	}
	
	if(data_flash->block_invalid[0] == 1||data_flash->block_invalid[1] == 1||
		data_flash->block_invalid[2] == 1)
		return -1;
/*		
 typedef struct
{
	unsigned char time[14];		//图像的采集时间
	char channel;				//哪一路图像, -1 invalid data
	char sent_flag;				//是否发送成功的标志
	char sys_status;			//图片的状态，"1"报警图像，"0"正常图像
	char pic_size;				//图像的大小
	char pic_Q;             	//图像的质量
	unsigned short start_block;	//图像数据的起始块
	unsigned short end_block;	//图像数据的结束块
	int size;				       //图像的数据长度
	char receive_num[11];		//保存接收方的手机，便于以后分析
} JPEG_STORAGE_T;//40byte

*/	
	for(i = 0; i < MAX_PIC_NUM; i++)
	{
		data_flash->jpeg[i].channel		= -1;
		data_flash->jpeg[i].sent_flag	= -1;
		data_flash->jpeg[i].sys_status	= -1;	
		data_flash->jpeg[i].pic_size	= -1;	
		data_flash->jpeg[i].pic_Q		= -1;		
		data_flash->jpeg[i].start_block	= 0xffff;
		data_flash->jpeg[i].end_block	= 0xffff;
		data_flash->jpeg[i].size			= -1;
	}
	
	ret = program_blocks((char*)data_flash, sizeof(DATA_FLASH_T), 0,BLOCK_GPRS_INFO_START, BLOCK_GPRS_INFO_END);
	return ret;
}

//0 df工作正常且已初始化，1 df工作正常但未初始化， -1 df硬件错误
int data_flash_init()
{
	int ret;
	int i;
	

 
	data_flash=&Data_Info;



	jpeg_storage=&jpeg_store;

	
	for(i = BLOCK_GPRS_INFO_START;i<BLOCK_GPRS_INFO_END;i++)
			data_flash->block_invalid[i] = 0; //assume the first block is good, for read_data will check it


	*pFIO_DIR		|= (1 << 6); //output
	
//	sys_params = &km29_ctrl->sys_params;
//	sys_params2 = &km29_ctrl->sys_params2;
	
	ret = read_id();
	if(ret < 0)
		return -1;
	
	//memset((char*)data_flash,0,sizeof(DATA_FLASH_T));
	delay(100);
	ret = read_data((char*)data_flash, sizeof(DATA_FLASH_T), 0, BLOCK_GPRS_INFO_START, BLOCK_GPRS_INFO_END);


	
	//wd();	
	if(ret == 2)	
	{
		if(memcmp(data_flash->identifier, "[e-mail]", strlen("[e-mail]")) == 0)
			ret = 0;
		else
		{
			ret = DF_First_init();
			if(ret == 2)
				ret = 1;
		}
	}
	
	return ret;
}

int df_updated()
{
	if(data_flash_updated)
	{
		data_flash_updated = 0;
		delay(100);
		return program_blocks((char*)data_flash, sizeof(DATA_FLASH_T), 0, BLOCK_GPRS_INFO_START, BLOCK_GPRS_INFO_END);
	}
	
	return 0;
}

int updated_flag()
{
	data_flash_updated = 1;
	return 0;
}

/*
int df_log_error(char* error)
{	
	if(km29_ctrl->error_msg_len + strlen(error) > MAX_ERROR_MSG_LEN-1)
	{
		strcpy(km29_ctrl->error_msg, error);
		km29_ctrl->error_msg_len = strlen(error);
	}
	else
	{
		strcat(km29_ctrl->error_msg, error);
		km29_ctrl->error_msg_len += strlen(error);
	}
	
	km29_ctrl_updated = 1;
	
	df_uninit();
	
	return 0;
}
*/