gconfig.c

这是一个潜入式开发的c语言代码

#include "gconfig.h"

VOID g_memcpy(BYTE* to, BYTE* from, UINT32 size, UINT32* pOffset, Boolean setOffset)
{
	memcpy(to, from, size);

	if(setOffset)
	{
		*pOffset = (UINT32)(*pOffset) + size;
	}
}

/* open configuation file */
Boolean gconfig_OpenCfgFile(CHAR* filename, GConfigFile* cfg)
{
	REGINT fd,size;
	struct stat sb;

	DBG_MSG("opening file..\n");
	/* open */
	//if ((fd = open (filename, O_RDONLY|O_BINARY)) < 0)
	if ((fd = open (filename, O_RDONLY)) < 0)
	{
		DBG_MSG("open error\n");
		return False;
	}
	fstat(fd,&sb);
	cfg->fd = fd;
	cfg->size = size;
	return True;
}

Boolean gconfig_ParaseDIU(DIUCONFIG* pConfig)
{
	UINT32 offset = 0;
	REGINT size = 0;
	BYTE buffer[60];
	UINT32* pOffset = &offset;

	DBG_MSG("now parase DIU..\n");

	// read buffer
	size = 56;
	if(f_SeekRead(pConfig->configfile.fd, buffer, 0, size) != size)
	{
		DBG_MSG("read error.\n");
		return False;
	}

	// parase
	g_memcpy(&pConfig->u32BAH, buffer+offset, 4, pOffset, True);
	g_memcpy(&pConfig->DIU_NO, buffer+offset, 4, pOffset, True);
	g_memcpy(&pConfig->DIU_NAME, buffer+offset, 20, pOffset, True);
	g_memcpy(&pConfig->bRemote_IP, buffer+offset, 4, pOffset, True);
	g_memcpy(&pConfig->u16OutTagNum, buffer+offset, 2, pOffset, True);
	g_memcpy(&pConfig->u32OutTagTableOffset, buffer+offset, 4, pOffset, True);
	g_memcpy(&pConfig->u16TagNum, buffer+offset, 2, pOffset, True);
	g_memcpy(&pConfig->u32TagTableOffset, buffer+offset, 4, pOffset, True);
	g_memcpy(&pConfig->u16GroupNum, buffer+offset, 2, pOffset, True);
	g_memcpy(&pConfig->u32GroupTableOffset, buffer+offset, 4, pOffset, True);
	g_memcpy(&pConfig->u16EquipNum, buffer+offset, 2, pOffset, True);
	g_memcpy(&pConfig->u32EquipTableOffset, buffer+offset, 4, pOffset, True);

	if(gconfig_ParaseOutputTagIndex(pConfig) == False)
		return False;
	if(gconfig_ParaseTagIndex(pConfig) == False)
		return False;
	if(gconfig_ParaseEquipIndex(pConfig) == False)
		return False;
	if(gconfig_ParaseGroupIndex(pConfig) == False)
		return False;

	DBG_MSG("parase DIU ok\n");
	return True;
}

/* init */
Boolean gconfig_Init(CHAR* cfgFileName, DIUCONFIG* pConfig)
{
	DBG_MSG("configuation init..\n");

	if( gconfig_OpenCfgFile(cfgFileName, &pConfig->configfile) == False)
		return False;
	if( gconfig_ParaseDIU(pConfig) == False)
		return False;

	DBG_MSG("init ok\n");
	return True;
}

Boolean gconfig_ParaseOutputTagIndex(DIUCONFIG* pConfig)
{
	UDATA temp;
	REGINT index,size;
	REGINT offset = 0;
	DBG_MSG("parasing output tags Index..\n");

	offset = pConfig->u32OutTagTableOffset;
	
	for(index=0; index<pConfig->u16OutTagNum; index++)
	{
		pConfig->u32OutTagIndex[index] = offset;

		if(f_SeekRead(pConfig->configfile.fd, &temp.u16, offset+24, 2) != 2)
			return False;
		size = 24 + 2 + temp.u16*4 + 1;
		offset += size;
	}
	DBG_MSG("parase ok\n");
	return True;
}

Boolean gconfig_ParaseTagIndex(DIUCONFIG* pConfig)
{
	REGINT index, size;
	REGINT offset = 0;

	DBG_MSG("parasing tags Index..\n");
	offset = pConfig->u32TagTableOffset;
	size = 58;
	
	for(index=0; index<pConfig->u16TagNum; index++)
	{
		pConfig->u32TagIndex[index] = offset;
		offset += size;
	}
	DBG_MSG("parase ok\n");
	return True;
}

Boolean gconfig_ParaseEquipIndex(DIUCONFIG* pConfig)
{
	UDATA temp;
	REGINT index, size;
	UINT32 offset = 0;

	DBG_MSG("parasing equips Index..\n");
	offset = pConfig->u32EquipTableOffset;
	
	for(index=0; index<pConfig->u16EquipNum; index++)
	{
		pConfig->u32EquipIndex[index] = offset;

		if(f_SeekRead(pConfig->configfile.fd, &temp.u16, offset+8, 2) != 2)
			return False;
		size = 8 + 2 + temp.u16*9;

		offset += size;
	}
	DBG_MSG("parase ok\n");
	return True;
}

Boolean gconfig_ParaseGroupIndex(DIUCONFIG* pConfig)
{
	UDATA temp;
	REGINT index, size;
	REGINT num1,num2,num3;
	REGINT offset = 0;

	DBG_MSG("parasing groups Index..\n");
	offset = pConfig->u32GroupTableOffset;

	for(index=0; index<pConfig->u16GroupNum; index++)
	{
		// read buffer
		pConfig->u32GrpIndex[index] = offset;
		size = 0;

		if(f_SeekRead(pConfig->configfile.fd, &temp.u16, offset+25, 2) != 2)
			return False;
		size += 25 + 2 + temp.u16 * 4;

		if(f_SeekRead(pConfig->configfile.fd, &temp.u16, offset+size, 2) != 2)
			return False;
		size += 2 + temp.u16 * 4;

		if(f_SeekRead(pConfig->configfile.fd, &temp.u16, offset+size, 2) != 2)
			return False;
		size += 2 + temp.u16 * 4;

		offset += size;
	}
	DBG_MSG("parase ok\n");
	return True;
}

Boolean gconfig_getOutputTags(DIUCONFIG* pConfig, FOutputTag outtags[], UINT32 outtagsize, FTag tags[], UINT32 tagsize)
{
	REGINT i;
	DBG_MSG("init tags..\n");

	if(pConfig->u16OutTagNum > outtagsize)
	{
		DBG_MSG("number of output-tag overrange\n");
		return False;
	}

	for(i=0; i<pConfig->u16TagNum; i++)
	{
		if(gconfig_ParaseOutTag(pConfig, &outtags[i], i, tags, tagsize) == False)
		{
			DBG_MSG("parase tag failed\n");
			return False;
		}
	}

	DBG_MSG("tags init ok\n");
	return True;
}

Boolean gconfig_getTags(DIUCONFIG* pConfig, FTag tags[], UINT32 length)
{
	REGINT i;
	DBG_MSG("init tags..\n");

	if(pConfig->u16TagNum > length)
	{
		DBG_MSG("number of tag overrange\n");
		return False;
	}

	for(i=0; i<pConfig->u16TagNum; i++)
	{
		if( !gconfig_ParaseTag(pConfig, &tags[i], i) )
		{
			DBG_MSG("parase tag failed\n");
			return False;
		}
	}

	DBG_MSG("tags init ok\n");
	return True;
}

Boolean gconfig_getGroups(DIUCONFIG* pConfig, FTagGroup grps[], UINT32 grpsize, FTag tags[], UINT32 tagsize, FOutputTag outtags[], UINT32 outtagsize)
{
	REGINT i;
	DBG_MSG("init groups..\n");

	if(pConfig->u16GroupNum > grpsize)
	{
		DBG_MSG("number of group overrange\n");
		return False;
	}

	for(i=0; i<pConfig->u16GroupNum; i++)
	{
		if(gconfig_ParaseGroup(pConfig, &grps[i], i, tags, tagsize, outtags, outtagsize) == False)
		{
			DBG_MSG("parase group failed\n");
			return False;
		}
	}

	DBG_MSG("groups init ok\n");
	return True;
}

Boolean gconfig_ParaseOutTag(DIUCONFIG* pConfig, FOutputTag* tag, /*from 0*/UINT32 tagIndex, FTag tags[], UINT32 tagsize)
{
	UDATA tmpUDATA;
	BYTE  tmpBuffer[50];
	REGINT offset = 0;
	REGINT rsize = 0;
	REGINT i;

	// read
	offset = 0;
	rsize = 26;
	if(f_SeekRead(pConfig->configfile.fd, tmpBuffer, pConfig->u32OutTagIndex[tagIndex]+offset, rsize) != rsize)
		return False;

	// parase
	f_memcpy(&tag->TagName, sizeof(tag->TagName), tmpBuffer + 4, 20, 20);
	// parase
	memcpy(&tmpUDATA.u16, tmpBuffer + 24, 2);
	tag->RelatedTagNum = tmpUDATA.u16;

	// parase
	offset = 26;
	for(i=0; i<tag->RelatedTagNum; i++)
	{
		rsize = 4;
		if(f_SeekRead(pConfig->configfile.fd, &tmpUDATA.u32, pConfig->u32OutTagIndex[tagIndex]+offset, rsize) != rsize)
			return False;
		if(tmpUDATA.u32+1 > tagsize)
		{
			DBG_MSG("tag index of output tag overrange\n");
			return False;
		}
		tag->RelatedTag[i] = &tags[tmpUDATA.u32];

		offset += rsize;
	}
	// parase
	rsize = 1;
	if(f_SeekRead(pConfig->configfile.fd, &tmpUDATA.u8, pConfig->u32OutTagIndex[tagIndex]+offset, rsize) != rsize)
		return False;
	tag->RelationType = tmpUDATA.u8;

	return True;
}

Boolean gconfig_ParaseTag(DIUCONFIG* pConfig, FTag* tag, /*from 0*/UINT32 tagIndex)
{
	UDATA tmpUDATA;
	BYTE  tmpBuffer[50];
	REGINT offset = 0;
	REGINT rsize = 0;

	// read
	offset = 0;
	rsize = 50;
	if(f_SeekRead(pConfig->configfile.fd, tmpBuffer, pConfig->u32TagIndex[tagIndex]+offset, rsize) != rsize)
		return False;

	// parase
	memcpy(&tmpUDATA.u32, tmpBuffer, 4);
	tag->TagID = tmpUDATA.u32;
	// parase
	f_memcpy(&tag->TagName, sizeof(tag->TagName), tmpBuffer + 4, 20, 20);
	// parase
	memcpy(&tmpUDATA.u32, tmpBuffer + 24, 4);
	tag->TypeID = tmpUDATA.u32;
	// parase
	tag->RangeMax = ext_ParaseDouble(tmpBuffer+28, DOUBLE_IEEE_LH);
	// parase
	tag->RangeMin = ext_ParaseDouble(tmpBuffer+36, DOUBLE_IEEE_LH);

	// read
	offset = 44;
	rsize = 14;
	if(f_SeekRead(pConfig->configfile.fd, tmpBuffer, pConfig->u32TagIndex[tagIndex]+offset, rsize) != rsize)
		return False;

	// parase
	// f_memcpy(&tag->u, sizeof(tag->bUnit), tmpBuffer, 12, 12);
	// parase
	tag->DType = tmpBuffer[12];
	// parase
	tag->Mode  = tmpBuffer[13];
	tag->RSW = 0;

	return True;
}

Boolean gconfig_ParaseEquip(DIUCONFIG* pConfig, FInstrument* equip, /*from 0*/UINT32 equipIndex, FTag tags[], UINT32 tagsize)
{
	UDATA tmpUDATA;
	BYTE  tmpBuffer[50];
	REGINT i;
	REGINT offset = 0;
	REGINT rsize = 0;
	
	// read
	offset = 0;
	rsize = 10;
	if(f_SeekRead(pConfig->configfile.fd, tmpBuffer, pConfig->u32EquipIndex[equipIndex]+offset, rsize) != rsize)
		return False;

	// parase
	equip->Adr = tmpBuffer[4];
	// parase
	equip->Fun = tmpBuffer[5];
	equip->Reg0 = 0;
	// parase
	memcpy(&tmpUDATA.u16, tmpBuffer + 6, 2);
	equip->RegNum = tmpUDATA.u16;
	// parase
	memcpy(&tmpUDATA.u16, tmpBuffer + 8, 2);
	equip->TagNum = tmpUDATA.u16;

	if(equip->TagNum > INSTRU_MAX_TAG)
	{
		DBG_MSG2("equip TagNum %d\n", equip->TagNum);
		DBG_MSG2("equip %d TagNum OverRange\n", equipIndex);
		return False;
	}

	offset = 10;
	for(i=0; i<equip->TagNum; i++)
	{
		// read
		rsize = 9;
		if(f_SeekRead(pConfig->configfile.fd, tmpBuffer, pConfig->u32EquipIndex[equipIndex]+offset, rsize) != rsize)
			return False;

		// parase
		memcpy(&tmpUDATA.u32, tmpBuffer, 4);
		if(tmpUDATA.u32+1 > tagsize)
		{
			DBG_MSG("equip tag number overrange\n");
			return False;
		}
		equip->Tag[i] = &tags[tmpUDATA.u32];

		// parase
		equip->RegTYPE[i] = tmpBuffer[4];
		// parase
		memcpy(&tmpUDATA.u32, tmpBuffer + 5, 4);
		equip->RegNO[i] = tmpUDATA.u32;
		
		offset += rsize;
	}

	return True;
}

Boolean gconfig_ParaseGroup(DIUCONFIG* pConfig, FTagGroup* grp, UINT32 grpIndex, FTag tags[], UINT32 tagsize, FOutputTag outTags[], UINT32 outtagSize)
{
	UDATA tmpUDATA;
	BYTE  tmpBuffer[50];
	REGINT i;
	REGINT offset = 0;
	REGINT rsize = 0;

	// 基本信息
	// read 
	offset = 0;
	rsize = 25;
	if(f_SeekRead(pConfig->configfile.fd, tmpBuffer, pConfig->u32GrpIndex[grpIndex]+offset, rsize) != rsize)
		return False;

	// parase
	memcpy(&tmpUDATA.u32, tmpBuffer, 4);
	grp->GroupID = tmpUDATA.u32;
	// parase
	f_memcpy(&grp->GrpName, sizeof(grp->GrpName), tmpBuffer + 4, 20, 20);
	// parase
	memcpy(&tmpUDATA.u8, tmpBuffer + 24, 1);
	grp->TypeID = tmpUDATA.u8;


	// 采集点
	// read
	offset = 25;
	rsize = 2;
	if(f_SeekRead(pConfig->configfile.fd, &tmpUDATA.u16, pConfig->u32GrpIndex[grpIndex]+offset, rsize) != rsize)
		return False;
	grp->TagNum = tmpUDATA.u16;

	// parase
	offset = 27;
	for(i=0; i<grp->TagNum; i++)
	{
		rsize = 4;
		if(f_SeekRead(pConfig->configfile.fd, &tmpUDATA.u32, pConfig->u32GrpIndex[grpIndex]+offset, rsize) != rsize)
			return False;
		if(tmpUDATA.u32 + 1 > tagsize)
		{
			DBG_MSG("tag index of group overrange\n");
			return False;
		}
		grp->Tag[i] = &tags[tmpUDATA.u32];
		offset += rsize;
	}

	// 输出点
	// read
	rsize = 2;
	if(f_SeekRead(pConfig->configfile.fd, &tmpUDATA.u16, pConfig->u32GrpIndex[grpIndex]+offset, rsize) != rsize)
		return False;
	grp->OutTagNum = tmpUDATA.u16;
	offset += rsize;

	// parase
	for(i=0; i<grp->OutTagNum; i++)
	{
		rsize = 4;
		if(f_SeekRead(pConfig->configfile.fd, &tmpUDATA.u32, pConfig->u32GrpIndex[grpIndex]+offset, rsize) != rsize)
			return False;
		if(tmpUDATA.u32 + 1 > outtagSize)
		{
			DBG_MSG("output tag index of group overrange\n");
			return False;
		}
		grp->OutTag[i] = &outTags[tmpUDATA.u32];
		offset += rsize;
	}

	// 仪表
	// read
	rsize = 2;
	if(f_SeekRead(pConfig->configfile.fd, &tmpUDATA.u16, pConfig->u32GrpIndex[grpIndex]+offset, rsize) != rsize)
		return False;
	grp->InstruNum = tmpUDATA.u16;
	offset += rsize;
	
	// parase
	for(i=0; i<grp->InstruNum; i++)
	{
		rsize = 4;
		if(f_SeekRead(pConfig->configfile.fd, &tmpUDATA.u32, pConfig->u32GrpIndex[grpIndex]+offset, rsize) != rsize)
			return False;
		if(tmpUDATA.u32 + 1 > pConfig->u16EquipNum)
		{
			DBG_MSG("equip index of group overrange\n");
			return False;
		}
		if(gconfig_ParaseEquip(pConfig,	&grp->Instru[i], tmpUDATA.u32, tags, tagsize) == False)
		{
			DBG_MSG("parase equip failed.\n");
			return False;
		}

		offset += rsize;
	}

	return True;
}


/* get gather unit configuation */
Boolean gconfig_Config(DIUCONFIG* pConfig, FTagGroup grps[], UINT32 grpsize, 
					   FTag tags[], UINT32 tagsize, FOutputTag outtags[], UINT32 outtagsize)
{
	if(gconfig_getTags(pConfig, tags, tagsize) == False)
		return False;
	if(gconfig_getOutputTags(pConfig, outtags, outtagsize, tags, tagsize) == False)
		return False;
	if(gconfig_getGroups(pConfig, grps, grpsize, tags, tagsize, outtags, outtagsize) == False)
		return False;
}

/* free resources */
VOID gconfig_Free(DIUCONFIG* pConfig)
{
	close(pConfig->configfile.fd);
}

/* print gained configuation */
VOID gconfig_Print(DIUCONFIG* pConfig)
{
#ifdef __F_DEBUG__
	REGINT index,i;
	UINT32 ip;

	memcpy(&ip, pConfig->bRemote_IP, 4);
	print("remoute ip:%s\n", inet_ntoa(ip) );

	print("unit name: %s\n", pConfig->DIU_NAME);
	print("unit NO. : %d\n", pConfig->DIU_NO);
	print("unit output tags NUM : %d\n", pConfig->u16OutTagNum);
	print("unit tags NUM : %d\n", pConfig->u16TagNum);
	print("unit equips NUM : %d\n", pConfig->u16EquipNum);
	print("unit groups NUM : %d\n", pConfig->u16GroupNum);
	print("unit BAH : %d\n", pConfig->u32BAH);
	print("output tags table offset : %d\n", pConfig->u32OutTagTableOffset);
	print("tags table offset : %d\n", pConfig->u32TagTableOffset);
	print("equips table offset : %d\n", pConfig->u32EquipTableOffset);
	print("groups table offset : %d\n", pConfig->u32GroupTableOffset);

#endif
}