record.cpp

wince外部中断计数小驱动

// Record.cpp: implementation of the CRecord class.
//
//////////////////////////////////////////////////////////////////////

#include "Record.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CRecord::CRecord()
{
	pFramOnBorad = new CFram();
	if (NULL == pFramOnBorad)
	{
		RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Fail to malloc FramOnBoard!\n\r")));
	}
	
	VIMinIndex = 0;
	VIBlockIndex[0] = 0;
	VIBlockIndex[1] = 0;
	minuVi = 0;
	lastTime = new SYSTEMTIME();
	counter = 1;
	defaultKModulus = 640;
}

CRecord::~CRecord()
{
	delete pFramOnBorad;
	pFramOnBorad = NULL;

	delete lastTime;
	lastTime = NULL;
}

BOOL CRecord::HighLevelFormat()
{
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//写入公司描述
	RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Heigh level format starting......\n\r")));
	unsigned char str[] = "Cortoi Intelligent Electric(SiChuan)Co.Ltd";
	pFramOnBorad->Writeblock(ADD_CORTOI_DESCRIB,sizeof(str),str);
	Sleep(1000);
	
	unsigned long add = 0;
	//写入电子标签
	ELABLE elable;
	SYSTEMTIME CurrentTime;
	::GetLocalTime(&CurrentTime);
	elable.year = (unsigned char)(CurrentTime.wYear - 2000);
	elable.month = (unsigned char)CurrentTime.wMonth;
	elable.day =  (unsigned char)CurrentTime.wDay;
	elable.hour = (unsigned char)CurrentTime.wHour;
	elable.min = (unsigned char)CurrentTime.wMinute;
	elable.UID[0] = 1;
	elable.UID[1] = 2;
	elable.UID[2] = 3;
	elable.UID[3] = 4;
	elable.isRepair = 0;
	elable.hardVer = 0xa;
	elable.sysVer = 0xa;
	elable.QAid = 0;
	elable.customerID[0] = 0;
	elable.customerID[1] = 0;
	if (FALSE == WriteElable(&elable))
	{
		return FALSE;
	}
	RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Creat elable successed!\n")));
	
	


	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//写入默认车辆信息
	VEC_INF ifn;
	ifn.type = 0;
	int i = 0;
	for (i = 0; i < 17; i++)
	{
		ifn.VIN[i] = 0;
	}
	unsigned char id[11] = "川D0001";
	memcpy(ifn.ID,id,11);
	for (i = 0; i < 5; i++)
	{
		ifn.ID_self[i] = 0;
	}

	BOOL bRet= FALSE;
	bRet = SetVecInf(&ifn);
	if (FALSE == bRet)
	{
		return FALSE;
	}
	RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Creat vehicle  successed!\n")));




	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//初始化K值
	SetKModulus(DEFAULT_K_MODULUS);
	RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Creat K Modulus  successed!\n")));


	
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//初始化驾驶员信息	



	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//初始化掉电时间和上电时间
	


	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//初始化块索引
	unsigned char blockIndex[2] = {0,1};
	pFramOnBorad->Writeblock(ADD_BLOCK_INDEX,2,blockIndex);
	SYSTEMTIME time;
	::GetLocalTime(&time);
	pFramOnBorad->WriteByte(ADD_MIN_INDEX,(unsigned char)time.wMinute);
	
	//初始化平均速度存储区
	unsigned long l = 0;
	unsigned char data[VI_SIZE] = {0};

	for(l = 0; l < 4; l++)
	{
		data[l] = 0x99;
	}
	for(l = 4; l < VI_SIZE; l++)
	{
		data[l] = 251;
	}
	for (l = 0; l < MAX_HOUR_NUM; l++)
	{
		add = ADD_VI_START + l * VI_SIZE;
		pFramOnBorad->Writeblock(add,VI_SIZE,data);
		RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Heigh level format block %d: (0x%x to 0x%x)\r\n"),l,(add - VI_SIZE),add));
	}

	::GetLocalTime(&CurrentTime);


	//创建第一块平均速度存储区
	add = ADD_VI_START;
	pFramOnBorad->WriteByte(add,unsigned char(CurrentTime.wYear - 2000));
	add++;
	pFramOnBorad->WriteByte(add,unsigned char(CurrentTime.wMonth));
	add++;
	pFramOnBorad->WriteByte(add,unsigned char(CurrentTime.wDay));
	add++;
	pFramOnBorad->WriteByte(add,unsigned char(CurrentTime.wHour));
	RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Creat vi block  successed!\n")));



	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//创建里程存储区索引号
	add = ADD_MILEAGE_INDEX;
	pFramOnBorad->WriteByte(add,1);
	unsigned char tmp;
	//初始化里程存储区

// #define MAX_NUMBER_OF_MILEAGE_RECORD 30
// #define NUM_OF_BYTE_IN_ITEM 9
// #define ADD_MILEAGE_INDEX 0x8000
// #define ADD_MILEAGE_START 0x8001

	unsigned char mileAge[NUM_OF_BYTE_IN_ITEM] = {0};
	for (l = 0; l < 3; l++)
	{
		mileAge[l] = 0x99;
	}
	for (l = 3; l < NUM_OF_BYTE_IN_ITEM; l++)
	{
		mileAge[l] = 0x0;
	}
	for (l = 0; l < MAX_NUMBER_OF_MILEAGE_RECORD; l ++)
	{
		add = ADD_MILEAGE_START + l * NUM_OF_BYTE_IN_ITEM;
		pFramOnBorad->Writeblock(add,NUM_OF_BYTE_IN_ITEM,mileAge);
	}
	//创建第一里程存储区
	add = ADD_MILEAGE_START;
	//年
	tmp = unsigned char(CurrentTime.wYear - 2000);
	pFramOnBorad->WriteByte(add,tmp);
	add++;
	
	//月
	tmp = unsigned char(CurrentTime.wMonth);
	pFramOnBorad->WriteByte(add,tmp);
	add++;
	
	//日
	tmp = unsigned char(CurrentTime.wDay);
	pFramOnBorad->WriteByte(add,tmp);
//	add++;
	RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Creat mileage block  successed!\n")));




	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//创建进出站存储区索引
	add = ADD_STATION_INDEX;
	tmp = 0;
	pFramOnBorad->WriteByte(add,tmp);
	add++;
	tmp = 1;
	pFramOnBorad->WriteByte(add,tmp);
	//初始化进出站存储区
	
	//进出站记录
// #define NUM_OF_STATION_REC 2000
// #define SIZEOF_STATION_ITEM 10
// #define IN_STTION 0xa
// #define OUT_STTION 0xb
// #define DIR_UP 0xaa
// #define DIR_DOWN 0xbb
// #define ADD_STATION_INDEX 0x8200
// #define ADD_STATION_START 0x8202
	RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Creat station,please wait")));
	unsigned char station[10] = {0};
	for (l = 0; l < 6; l++)
	{
		station[l] = 0x99;
	}
	for (l = 6; l < SIZEOF_STATION_ITEM; l++)
	{
		station[l] = 0x0;
	}

	for (l = 0; l < NUM_OF_STATION_REC; l ++)
	{
		add = ADD_STATION_START + SIZEOF_STATION_ITEM * l;
		pFramOnBorad->Writeblock(add,SIZEOF_STATION_ITEM,station);
		RETAILMSG(FRAM_DEBUG_INF_OUT,(_T(".",l)));
		
	}
	RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Creat station block  successed!\n")));
	




	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//创建疑点数据存储区索引
	tmp = 1;
	add = ADD_DOUBT_INDEX;
	pFramOnBorad->WriteByte(ADD_DOUBT_INDEX,tmp);
	//初始化疑点数据存储区
	unsigned char doubt[SIZEOF_A_DOUT_REC] = {0};
	for (i = 0; i < 6; i++)
	{//年月日时分秒
		doubt[i] = 0x09;
	}

	//最后一条记录索引
	doubt[6] = 0;

	for (i = 7; i < 10; i++)
	{//驾驶员ID
		doubt[i] = 0x1;
	}

	for (i = 10; i <11; i++)
	{//重要特殊数据
		doubt[i] = 0x07;
	}

	for (i = 11; i < 12; i++)
	{//是否翻页
		doubt[i] = 0x0;
	}

	doubt[12] = 0;
	for (i = 13; i < SIZEOF_A_DOUT_REC; i ++)
	{//实际数据
		doubt[i] = 0xfd;
	}

	for (i = 0; i < MAX_NUM_OF_DOUT_REC; i++)
	{
		add = ADD_DOUBT_START + i * SIZEOF_A_DOUT_REC;
		pFramOnBorad->Writeblock(add,SIZEOF_A_DOUT_REC,doubt);
	}
	RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Creat doubt data block  successed!\n")));






	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//创建超速存储区索引
	unsigned char index[2] = {0,1};
	pFramOnBorad->Writeblock(ADD_OVERSPEED_INDEX,2,index);
	//初始化超速记录存储区
	unsigned char overSpeed[SIZEOF_A_OVERSPEED_REC] = {0};
	for (i = 0; i < 12; i++)
	{//超速开始年月日时分秒，超速结束年月日时分秒
		overSpeed[i] = 0x99;
	}
	overSpeed[12] = 0x28;//默认当前限速值40公里
	overSpeed[13] = 0x28;//默认超速最高速度

	for (l = 0; l < MAX_NUM_OF_OVERSPEED_REC; l++)
	{
		add = ADD_OVERSPEED_START + SIZEOF_A_OVERSPEED_REC * l;
		pFramOnBorad->Writeblock(add,SIZEOF_A_OVERSPEED_REC,overSpeed);
	}
	//创建第一块超速记录存储区
	




	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	//***************************************************************************
	RETAILMSG(FRAM_DEBUG_INF_OUT,(_T("Heigh level format successed!\n")));
	return TRUE;
}



BOOL CRecord::WriteElable(const ELABLE* elable)
{
	BOOL bRet = FALSE;
	bRet = pFramOnBorad->Writeblock(ADD_ELABLE,sizeof(ELABLE),(unsigned char*)elable);
	if (FALSE == bRet)
	{
		return FALSE;
	}
	Sleep(1000);

// 	ELABLE* temp = new ELABLE;
// 	pFramOnBorad->ReadBlock(ADD_ELABLE,sizeof(ELABLE),(unsigned char*)temp);
// 	if (FALSE == bRet)
// 	{
// 		return FALSE;
// 	}
// 
// 	bRet = memcmp(elable,temp,sizeof(ELABLE));
// 	if (0 != bRet)
// 	{
// 		//不相等
// 		return FALSE;
// 	}

	return TRUE;
}

BOOL CRecord::SetVecInf(const VEC_INF* inf)
{
	BOOL bRet = FALSE;
	bRet = pFramOnBorad->Writeblock(ADD_VEC_INF,sizeof(VEC_INF),(unsigned char*)inf);
	if (FALSE == bRet)
	{
		return FALSE;
	}
	Sleep(1000);
	
	VEC_INF* temp = new VEC_INF;
	pFramOnBorad->ReadBlock(ADD_VEC_INF,sizeof(VEC_INF),(unsigned char*)temp);
	if (FALSE == bRet)
	{
		return FALSE;
	}
	
	bRet = memcmp(inf,temp,sizeof(VEC_INF));
	if (0 != bRet)
	{
		//不相等
		return FALSE;
	}
	
	return TRUE;
}

BOOL CRecord::SetDriver()
{
	BOOL bRet = FALSE;
	unsigned char a[48] = {0};
	for (int i = 0; i < 48; i++)
	{
		bRet = pFramOnBorad->Writeblock(ADD_DRIVER,48,a);
		if (FALSE == bRet)
		{
			return FALSE;
		}
	}
	return TRUE;
}





BOOL CRecord::SetVIIndex()
{
	BOOL bRet = FALSE;
	if (VIMinIndex > 60)
	{
		return FALSE;	
	}

	unsigned int temp;
	temp = (unsigned int)(VIBlockIndex[0] * 0xff);