/**
  ******************************************************************************
  * @file           : KMachine.c
  * @brief          : KMachine program body
  ******************************************************************************
	*/

#include "KMachine.h"
#include "string.h"
#include "Globaldef.h"
#include "stm32f0xx_hal.h"

//#define OB_BASE               ((uint32_t)0x1FFFF800U)       /*!< FLASH Option Bytes base address */
//#define FLASHSIZE_BASE        ((uint32_t)0x1FFFF7CCU)       /*!< FLASH Size register base address */
//#define UID_BASE              ((uint32_t)0x1FFFF7ACU)       /*!< Unique device ID register base address */


stStoredKMSysCfg storedKMSysCfg ;
stKMem KMem;
stRunStat KMRunStat;

//uint8_t * pFlash1 = (uint8_t *)(STORECFGBASE);

//void * pConfigFlashBase = (uint8_t *)(STORECFGBASE);

//uint16_t FlashDatas[16];

//uint32_t * pUID = (uint32_t *)(UID_BASE);
const stKMInfoBlock KMInfoBlock =
{
	(BOARD_TYPE<<8) + BOARD_VER,			//nDeviceType 	BOARD_VER,			//nDevieVer
	0x0100,			//ProgVer
	0x0100,			//KLinkVer
	0x0100,			//KBusVer
//	0x0100,			//KNetVer
//	0x0100,			//KWLVer
	
	4,					//nCapacity1	?K
	1,					//nCapacity2	?k
	
	DINPUT,					//nDInput;
	DOUTPUT,				//nDOutput
	
	0,					//nAInput
	0,					//nAOutput
	0,					//nHInput
	0,					//nHOutput
	0,					//nExt1;
	0,					//nExt2;
	0,					//nLogSize;
	0,					//nPorts;
	0,					//nManSize;
	0,					//nAbility;
	6,					//nSwitchBits;
};
const char VersionStr[] __attribute__((at(FLASH_BASE + 0X1000))) //__attribute__((at(0X8001000)))
	= "3.00";

const stStoredKMSysCfg KMDefaultSysCfg /*__attribute__((at(STORECFGBASE)))*/ =
{
	START_SIGN,
	0x0000,
	
	CFG_VER,
	0x0000,
	0x0000,
	{0,0,0,0,0,0},
	{
		{
			1,
			0,
			2304,						//Buadrate * 100;
			PortType_KLink,	//PorttType
			1,							//ByteSize
			0,							//Parity
			0,							//StopBits
			0,							//EofChar
			0,							//SofChar
		},
		{
			1,
			0,
			2304,						//Buadrate * 100;
			PortType_KBus,	//PorttType
			1,							//ByteSize
			0,							//Parity
			0,							//StopBits
			0,							//EofChar
			0,							//SofChar
		}
	},
	{{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0}},
	{{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1}},
	0x0003,
		0x0004,
		0x0005,
		0x0006,
		0x0007,
		0x0008,
		0x0009,
		0x000a,
		0x000b,
		0x000c,
		0x000d,
		0x000e,
		0x000f,
		0x0010,
	{0},
	0x0011,
	END_SIGN,
};

const stKMSysCfg KMDefaultSysCfg2[7] /*__attribute__((at(STORECFGBASE+sizeof(stKMSysCfg))))*/;
	
int ReadFlashMem(void * pBuf, void * pAddrFlash, int nByteSize)
{
//	memcpy(pBuf,pAddrFlash,nSize);
	for (int i=0;i<nByteSize/4;i++)
	{
		((uint32_t *)pBuf)[i] = ((uint32_t *)pAddrFlash)[i];
	}
	for (int i=nByteSize/4*2;i<nByteSize/2;i++)
	{
		((uint16_t *)pBuf)[i] = ((uint16_t *)pAddrFlash)[i];
	}
	return nByteSize;
}
int EraseFlashMem(void * pAddrFlash, unsigned int Pages)
{
	HAL_StatusTypeDef res;
	res = HAL_FLASH_Unlock();
	uint32_t ErrNo;	
	FLASH_EraseInitTypeDef erase1;
	erase1.NbPages=Pages;
	erase1.PageAddress=(unsigned int)pAddrFlash;
	erase1.TypeErase=FLASH_TYPEERASE_PAGES;
	res = HAL_FLASHEx_Erase(&erase1,&ErrNo);
	res = HAL_FLASH_Lock();
	return res;
}
int WriteToFlashMemNoErase(void * pBuf, void * pAddrFlash, unsigned int nByteSize)
{
		HAL_StatusTypeDef res;
	res = HAL_FLASH_Unlock();
/*	
	for (int i=0;i<nSize/2;i++)
	{
		res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i*2, ((uint16_t *)pBuf)[i]);
	}
*/	
///*	
	for (int i=0;i<nByteSize/4;i++)
	{
		res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, (uint32_t)pAddrFlash + i*4, ((uint32_t *)pBuf)[i]);
	}
	
	for (int i = nByteSize/4 * 2 ; i < nByteSize/2 ; i++)
	{
		res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i*2, ((uint16_t *)pBuf)[i]);
	}
//*/	
	res = HAL_FLASH_Lock();
	
	return res;
}
int EraseAndWriteToFlashMem(void * pBuf, void * pAddrFlash, unsigned int nByteSize)
{
	
	HAL_StatusTypeDef res;
	res = HAL_FLASH_Unlock();
	uint32_t ErrNo;	
	FLASH_EraseInitTypeDef erase1;
	erase1.NbPages=1;
	erase1.PageAddress=(unsigned int)pAddrFlash;
	erase1.TypeErase=FLASH_TYPEERASE_PAGES;
	res = HAL_FLASHEx_Erase(&erase1,&ErrNo);
	
	for (int i=0;i<nByteSize/2;i++)
	{
		res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i*2, ((uint16_t *)pBuf)[i]);
	}
/*	
	for (int i=0;i<nSize/4;i++)
	{
		res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, (uint32_t)pAddrFlash + i*4, ((uint32_t *)pBuf)[i]);
	}
	
	for (int i = nSize/4 * 2 ; i < nSize/2 ; i++)
	{
		res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i*2, ((uint16_t *)pBuf)[i]);
	}
*/	
	res = HAL_FLASH_Lock();
	
	return res;
}

int ReadFactoryData(void * pDatabuf, int nByteCount)
{
	memcpy(pDatabuf,(stFactoryData *)FACTORY_DATA_BASE,nByteCount);
	return 0;
}
int WriteFactoryData(void * pDataBuf, int nByteCount)
{
	EraseAndWriteToFlashMem(pDataBuf, (stFactoryData *)FACTORY_DATA_BASE,nByteCount);
	return 0;
}

int ReadProgram(int nProgByteAddr, void *pBuf, int nByteSize, int nBank)
{
	if (nBank==0)	{
		ReadFlashMem(pBuf, (void *)(STORE_PRG_BASE+nProgByteAddr), nByteSize);
	}else if (nBank ==1) {
		ReadFlashMem(pBuf, (void *)(ALT_PRG_BASE+nProgByteAddr), nByteSize);
	}else if (KMRunStat.nBinProgBank==0) {
		ReadFlashMem(pBuf, (void *)(STORE_PRG_BASE+nProgByteAddr), nByteSize);
	} else {
		ReadFlashMem(pBuf, (void *)(ALT_PRG_BASE+nProgByteAddr), nByteSize);
	}		
	return 0;
}
int WriteProgram(int nProgAddress, void * pBuf, int nByteSize, int nBank)
{
			// Program Save Address;//
		  // Program 2 Save Address; //
	void * progByteAddr;
	if (nBank == 0) {
		progByteAddr=(void *)(STORE_PRG_BASE+nProgAddress);
	}else if (nBank==1) {
		progByteAddr=(void *)(ALT_PRG_BASE+nProgAddress);
	} else if (KMRunStat.nBinProgBank==0) {
		progByteAddr=(void *)(ALT_PRG_BASE+nProgAddress);
	}else{
		progByteAddr=(void *)(STORE_PRG_BASE+nProgAddress);
	}
	if (nProgAddress ==0)	{
		EraseAndWriteToFlashMem(pBuf, progByteAddr, nByteSize);
	}else{
		WriteToFlashMemNoErase(pBuf, progByteAddr, nByteSize);
	}
	return 0;
}

int LoadDefaultSysCfg(pStoredKMSysCfg theStoredKMSysCfg)
{
	memcpy(theStoredKMSysCfg,&KMDefaultSysCfg,sizeof(stKMSysCfg));
	return 0;
}
int ReadSysCfgFromFlash(pStoredKMSysCfg theStoredKMSysCfg)
{
	pStoredKMSysCfg pStoreKMSysCfg = (pStoredKMSysCfg)(STORE_SYSREG_BASE);
	// find latest Store Cfg
	int nIndex=-1;
	int nMaxSeq=-1;
	for (int i=0;i<8;i++)
	{
		if (pStoreKMSysCfg->Sign1 == START_SIGN && pStoreKMSysCfg->EndSign1 == END_SIGN)
		{
			if (pStoreKMSysCfg->Seq1 > nMaxSeq) 
			{
				nIndex=i;nMaxSeq=pStoreKMSysCfg->Seq1;
			}
		}
	}
	if (nIndex>=0 && nIndex <8)
	{
			ReadFlashMem(theStoredKMSysCfg,(void *)(&pStoreKMSysCfg[nIndex]),sizeof(stStoredKMSysCfg));
	}else {
		LoadDefaultSysCfg(theStoredKMSysCfg);
	}
	//memcpy(theKMSysCfg,(void* )STORECFGBASE,sizeof(KMSysCfg));
	return 0;
}

int WriteSysCfgToFlash(pStoredKMSysCfg theStoredKMSysCfg)
{
	theStoredKMSysCfg->Seq1++;
//	theKMSysCfg->cfgvar16++;
	// find the next empty space to write
	int nIndex=-1;
	int s2=128;
	for (int i=0;i<8;i++)
	{
		int skip=0;
		unsigned char * nAddr2=(unsigned char *)(STORE_SYSREG_BASE+i*s2);
		for (int j=0;j<s2;j++)
		{
			if ((nAddr2)[j] != 0xff)	{skip =1;break;}
		}
		if (skip==1) {continue;}
		nIndex=i;
		break;
	}
	if (nIndex >=0 && nIndex <8)	{	
		WriteToFlashMemNoErase(theStoredKMSysCfg,(void *)(STORE_SYSREG_BASE + nIndex*s2),sizeof(theStoredKMSysCfg));
	}
	else 	{
		EraseAndWriteToFlashMem(theStoredKMSysCfg,(void *)STORE_SYSREG_BASE,sizeof(theStoredKMSysCfg));
	}
	return 0;
}

int is_pow_of_2(uint32_t x) {
    return !(x & (x-1));
}

uint32_t next_pow_of_2(uint32_t x) 
{
    if ( is_pow_of_2(x) )
        return x;
    x |= x>>1;
    x |= x>>2;
    x |= x>>4;
    x |= x>>8;
    x |= x>>16;
    return x+1;
}

//uint8_t * pFlash1;
/*
stStoreCfg * GetCurStoreCfgAddr(void )
{
	int s = sizeof(stStoreCfg);
	int s2=next_pow_of_2(s);
	stStoreCfg * p1;
	int nMaxSN=0;
	int nMaxId=0;
	for (int i=0; s2*i < STORECFGPAGESIZE ; i++)
	{
		p1= (stStoreCfg *)(STORECFGBASE + s2 * i );
		if (p1->Sign1 != START_SIGN) continue;
		if (p1->EndSign1 != END_SIGN) continue;
		
		if (p1->Seq1 >= nMaxSN) {nMaxSN = p1->Seq1; nMaxId = i;}
	}
//	nMaxId=nMaxId+1;
	return 	(stStoreCfg *)(STORECFGBASE + s2 * nMaxId);
}

stStoreCfg * GetNextStoreCfgAddr(stStoreCfg * CurCfg )
{
	int s = sizeof(stStoreCfg);
	int s2=next_pow_of_2(s);
	uint32_t nAddr1 = (uint32_t) CurCfg;
	uint32_t nAddr2 = nAddr1 + s2;
	for (int i=1;i<33;i++)
	{
		int skip=0;
		nAddr2 = nAddr1 + s2*i;
		if ((nAddr2 + s) > STORECFGBASE + STORECFGPAGESIZE) 
		{
			nAddr2=STORECFGBASE; break;
		}
		for (int j=0;j<s2;j++)
		{
			if (((unsigned char *)nAddr2)[j] != 0xff)
			{skip =1;}
		}
		if (skip==1) {continue;}
		break;
	}
	stStoreCfg * p1 = (stStoreCfg *)nAddr2;	
	return p1;
}


int SaveStoreCfg(stStoreCfg * CurCfg)
{
	return 0;
}
*/
// stStoreCfg Cfg2;

int LoadFlashDatas()
{
		for (int i=0;i<16;i++)
	{
//			FlashDatas[i]=((uint16_t *)pConfigFlashBase)[i];
	}
	return 0;
}
/*
int LoadAndUpdateStoreCfg()
{
	stStoreCfg * pFCfg = (stStoreCfg *) GetCurStoreCfgAddr();

	Cfg2.Sign1=START_SIGN;
	Cfg2.Seq1=pFCfg[0].Seq1+1;
	Cfg2.CRC1=0x7777;
	Cfg2.PowerCount=pFCfg[0].PowerCount+1;
	Cfg2.UpTime=pFCfg[0].UpTime+1;
	Cfg2.UserData1=pFCfg[0].UserData1;
	Cfg2.EndSign1=END_SIGN;
	stStoreCfg * pFCfg2 = GetNextStoreCfgAddr(pFCfg);	
	

	HAL_StatusTypeDef res;		
	if (pFCfg2 <= pFCfg)
	{
		res = (HAL_StatusTypeDef)EraseAndWriteToFlashMem(&Cfg2,pFCfg2,sizeof(stStoreCfg));
		
	}else
	{
		res = (HAL_StatusTypeDef)WriteToFlashMemNoErase(&Cfg2,pFCfg2,sizeof(stStoreCfg));
	}	
		return res;
}
*/
int CheckSavedData(void * pStartAddr, int PageSize, int Pages, int DataSize)
{
		return 0;
};


int nMaxRunStatIndex=-1;
unsigned int nMaxRunStatSeq=0;
int nNextRunStatSpace=0;
int LoadDefaultRunStat(pRunStat theRunStat)
{
	return 0;
}
int LoadRunStat(pRunStat theRunStat)
{
	uchar * pRunStatStore = (uchar *)STORE_RUNSTAT_BASE;
	pRunStat pStoreRunStats = (pRunStat)pRunStatStore;
//	int s = sizeof(stRunStat);
	
	for (int i=0;i * sizeof(stRunStat) < (STORE_RUNSTAT_PAGESIZE * STORE_RUNSTAT_PAGES) ;i++)
	{
		if (pStoreRunStats[i].Sign1 == START_SIGN )
		{
			if (pStoreRunStats[i].Seq1 > nMaxRunStatSeq)
			{
				nMaxRunStatSeq = pStoreRunStats[i].Seq1;
				nMaxRunStatIndex=i;
				nNextRunStatSpace=i+1;
			}
		}
	}
	if (nMaxRunStatIndex>=0) // && nMaxRunStatIndex <8)
	{
			ReadFlashMem(theRunStat,(void *)(pStoreRunStats+nMaxRunStatIndex),sizeof(stRunStat));
	}else {
		LoadDefaultRunStat(theRunStat);
	}	
	// find Next Space
	// if Same Page with MaxSeq Index, then not erase, skip and skip.
	// if next Page of MaxSeq Index, then earse if not empty;
	if ((nNextRunStatSpace + 1) * sizeof(stRunStat) > STORE_RUNSTAT_PAGESIZE * STORE_RUNSTAT_PAGES)	{
		nNextRunStatSpace=0;
	}
	return 0;
}

int SaveRunStat(pRunStat theRunStat)
{
	nMaxRunStatSeq++;
	theRunStat->Sign1=START_SIGN;
	theRunStat->Seq1 = nMaxRunStatSeq;
	theRunStat->PowerCount=KMem.PwrOnCount;
	theRunStat->UpTime=KMem.TotalRunTime;
	theRunStat->CRC1=0x11;
	theRunStat->EndSign1=END_SIGN;
	
	//check empty
	unsigned char *pFlash = (unsigned char *)(STORE_RUNSTAT_BASE + nNextRunStatSpace*sizeof(stRunStat));
	int Skip=0;
	for (int j=0;j<sizeof(stRunStat);j++)
	{
		if (pFlash[j]!=0xff) {Skip =1 ; break;}
	}
	if (Skip ==0 )
	{
		WriteToFlashMemNoErase(theRunStat,(void *)(STORE_RUNSTAT_BASE + nNextRunStatSpace*sizeof(stRunStat)),sizeof(stRunStat));
	}else
	{
		EraseAndWriteToFlashMem(theRunStat,(void *)(STORE_RUNSTAT_BASE + nNextRunStatSpace*sizeof(stRunStat)),sizeof(stRunStat));
	}
	nMaxRunStatIndex=nNextRunStatSpace;
	nNextRunStatSpace++;
	if ((nNextRunStatSpace+1) * sizeof(stRunStat) > STORE_RUNSTAT_PAGESIZE * STORE_RUNSTAT_PAGES)
	{
		nNextRunStatSpace=0;
	}
	return 0;
}	


int nEventCount=0;
int nEventMinIndex;
int nEventMaxIndex;
unsigned int nEventMaxSeq=0;
int nEventNextSpace;
int nMaxCurTime=0;
volatile int PowerDownEvent=0;
volatile int OldPowerDownEvent=0;
volatile int OldPowerDownEventTime=0;

int CheckEventLog()
{
	unsigned int nMinEventSeq=999999999;
	uchar * pEventStore = (uchar *)STORE_LOG_BASE;
	pEventLog theEventLog = (pEventLog) pEventStore;
//	int s = sizeof(stEventLog);
	nEventCount=0;
	
	for (int i=0;i * sizeof(stEventLog) < (STORE_LOG_PAGESIZE * STORE_LOG_PAGES) ;i++)
	{
		if (theEventLog[i].Sign1 == START_SIGN )
		{
			nEventCount++;
			if (theEventLog[i].Seq1 > nEventMaxSeq)
			{
				nEventMaxSeq = theEventLog[i].Seq1;
				nEventMaxIndex=i;
				nMaxCurTime=theEventLog[i].nTime;
				nEventNextSpace=i+1;
			}
			if (theEventLog[i].Seq1 < nMinEventSeq)
			{
				nMinEventSeq = theEventLog[i].Seq1;
				nEventMinIndex = i;
			}
		}
	}
	// find Next Space
	// if Same Page with MaxSeq Index, then not erase, skip and skip.
	// if next Page of MaxSeq Index, then earse if not empty;
	if ((nEventNextSpace + 1) * sizeof(stEventLog) > STORE_LOG_PAGESIZE * STORE_LOG_PAGES)	{
		nEventNextSpace=0;
	}
	
	return nEventCount;
}

int AddEventLog(uint32_t nTime, USHORT nEvent, USHORT nParam1, UINT nParam2)
{
	nEventMaxSeq++;
	stEventLog thisEventLog={START_SIGN, nEventMaxSeq, nTime,nEvent,nParam1,nParam2};
	//check empty
	unsigned char *pFlash = (unsigned char *)(STORE_LOG_BASE + nEventNextSpace*sizeof(stEventLog));
	int Skip=0;
	for (int j=0;j<sizeof(stEventLog);j++)
	{
		if (pFlash[j]!=0xff) {Skip =1 ; break;}
	}
	if (Skip ==0 )
	{
		WriteToFlashMemNoErase(&thisEventLog,(void *)(STORE_LOG_BASE + nEventNextSpace*sizeof(stEventLog)),sizeof(stEventLog));
	}else
	{
		EraseAndWriteToFlashMem(&thisEventLog,(void *)(STORE_LOG_BASE + nEventNextSpace*sizeof(stEventLog)),sizeof(stEventLog));
		
	}
	nEventMaxIndex=nEventNextSpace;
	nEventNextSpace++;
	if ((nEventNextSpace+1) * sizeof(stEventLog) > STORE_LOG_PAGESIZE * STORE_LOG_PAGES)
	{
		nEventNextSpace=0;
	}
	nEventCount++;
	KMem.nEventCount=nEventCount;
	return 0;
}	

pEventLog GetEventLogAddr(int nIndex)
{
	int nEventIndex=nEventMinIndex + nIndex;
	
	if (nEventIndex * sizeof(stEventLog) >= (STORE_LOG_PAGESIZE * STORE_LOG_PAGES))
	{
		nEventIndex -= (STORE_LOG_PAGESIZE * STORE_LOG_PAGES)/sizeof(stEventLog);
	}
	unsigned char *pFlash = (unsigned char *)(STORE_LOG_BASE + nEventIndex*sizeof(stEventLog));
	
	return (pEventLog)pFlash;	
}
	
int ClearEventLog(void)
{
	EraseFlashMem((void *)STORE_LOG_BASE,STORE_LOG_PAGES);
	nEventMinIndex=0;
	nEventMaxIndex=0;
	nEventMaxSeq=0;
	nEventCount=0;
	nEventNextSpace=0;
	return 0;
}
int KMachineInit(void)
{
//	ClearEventLog();
	CheckEventLog();
	LoadRunStat(&KMRunStat);
	KMem.CurTimeSec=nMaxCurTime;
	KMem.TotalRunTime=KMRunStat.UpTime;
	KMRunStat.PowerCount++;
	KMem.PwrOnCount=KMRunStat.PowerCount;
	SaveRunStat(&KMRunStat);
	KMem.SDD[15]=nMaxRunStatIndex;
	KMem.SDD[16]=nMaxRunStatSeq;
	KMem.SDD[17]=nNextRunStatSpace;

	
	AddEventLog(KMem.CurTimeSec,EventTypePowerUp,1,12345);
	KMem.SDD[19]=nEventCount;
	KMem.SDD[20]=nEventMinIndex;
	KMem.SDD[21]=nEventMaxIndex;
	KMem.SDD[22]=nEventMaxSeq;
	KMem.SDD[23]=nEventNextSpace;
	
	return 0;
}

inline void SetAddrBit(unsigned short * pW, unsigned char bitAddr)
{
	(*pW)|=1<<(bitAddr&0xf);
}

inline void ResetBit(unsigned short * pW, unsigned char bitAddr)
{
	(*pW)&=~(1<<(bitAddr&0xf));
}

static inline void SetBitValue(unsigned short * pW, unsigned char bitAddr, unsigned char Value)
{
	if (Value)	{	SetAddrBit(pW, bitAddr);}
	else {ResetBit(pW, bitAddr);}
}

static inline unsigned char GetBitValue(unsigned short W, unsigned char bitAddr)
{
	if (W&(1<<(bitAddr&0xf))) return 1;
	else return 0;
}


unsigned char GetCoilValue(unsigned char nCoilType, unsigned short nCoilAddr)
{
		unsigned char thisValue=0;
		unsigned short nWordAddr=(nCoilAddr&0xff0)>>4;
		unsigned char nBitAddr=nCoilAddr&0xf;
		switch(nCoilType)
		{
		case KLCoilTypeX:
			if (nCoilAddr >= KLCoilXCount) return 0;
			thisValue = GetBitValue(KMem.WX[nWordAddr], nBitAddr);
			break;
		case KLCoilTypeY:
			if (nCoilAddr >= KLCoilYCount) return 0;
			thisValue = GetBitValue(KMem.WY[nWordAddr], nBitAddr);
			break;
		case KLCoilTypeR:
			if (nCoilAddr >= KLCoilRCount) return 0;
			thisValue = GetBitValue(KMem.WR[nWordAddr], nBitAddr);
			break;
		case KLCoilTypeLX:
			if (nCoilAddr >= KLCoilLXCount) return 0;
			 thisValue = GetBitValue(KMem.WLX[nWordAddr], nBitAddr);
			break;
		case KLCoilTypeLY:
			if (nCoilAddr >= KLCoilLYCount) return 0;
			thisValue = GetBitValue(KMem.WLY[nWordAddr], nBitAddr);
			break;
		case KLCoilTypeT:
			if (nCoilAddr >= KLCoilTCount) return 0;
			thisValue = GetBitValue(KMem.WT[nWordAddr], nBitAddr);
			break;
		case KLCoilTypeC:
			if (nCoilAddr >= KLCoilCCount) return 0;
			thisValue = GetBitValue(KMem.WC[nWordAddr], nBitAddr);
			break;
		case KLCoilTypeLR:
			if (nCoilAddr >= KLCoilLRCount) return 0;
			thisValue = GetBitValue(KMem.WLR[nWordAddr], nBitAddr); 
			break;
		case KLCoilTypeSR:
			if (nCoilAddr >= KLCoilSRCount) return 0;
			thisValue = GetBitValue(KMem.WSR[nWordAddr], nBitAddr);
			break;
			default:
				break;
		}	
		return thisValue;
}
int SetCoilValue(unsigned char nCoilType, unsigned short nCoilAddr, unsigned char nCoilValue)
{
		unsigned short nWordAddr=(nCoilAddr&0xff0)>>4;
		unsigned char nBitAddr=nCoilAddr&0xf;
		switch(nCoilType)
		{
		case KLCoilTypeX:
			if (nCoilAddr >= KLCoilXCount) return 0;
			SetBitValue(&KMem.WX[nWordAddr], nBitAddr, nCoilValue);
			break;
		case KLCoilTypeY:
			if (nCoilAddr >= KLCoilYCount) return 0;
			SetBitValue(&KMem.WY[nWordAddr], nBitAddr, nCoilValue);
			break;
		case KLCoilTypeR:
			if (nCoilAddr >= KLCoilRCount) return 0;
			SetBitValue(&KMem.WR[nWordAddr], nBitAddr, nCoilValue);
			break;
		case KLCoilTypeLX:
			if (nCoilAddr >= KLCoilLXCount) return 0;
			SetBitValue(&KMem.WLX[nWordAddr], nBitAddr, nCoilValue);
			break;
		case KLCoilTypeLY:
			if (nCoilAddr >= KLCoilLYCount) return 0;
			SetBitValue(&KMem.WLY[nWordAddr], nBitAddr, nCoilValue);
			break;
		case KLCoilTypeT:
			if (nCoilAddr >= KLCoilTCount) return 0;
			SetBitValue(&KMem.WT[nWordAddr], nBitAddr, nCoilValue);
			break;
		case KLCoilTypeC:
			if (nCoilAddr >= KLCoilCCount) return 0;
			SetBitValue(&KMem.WC[nWordAddr], nBitAddr, nCoilValue);
			break;
		case KLCoilTypeLR:
			if (nCoilAddr >= KLCoilLRCount) return 0;
			SetBitValue(&KMem.WLR[nWordAddr], nBitAddr, nCoilValue);
			break;
		case KLCoilTypeSR:
			if (nCoilAddr >= KLCoilSRCount) return 0;
			SetBitValue(&KMem.WSR[nWordAddr], nBitAddr, nCoilValue);
			break;
			default:
				break;
		}	
		return 0;
}

int GetVarData(int nDataType, int nDataAddr)
{
	// TODO: ?????????.
	int thisValue = 0;
	
	switch (nDataType)
	{
	case KLDataTypeDEC:
	case KLDataTypeHEX:
		thisValue = nDataAddr;
		break;
	case KLDataTypeWX:
		if (nDataAddr >= KLDataWXCount) return 0;
		thisValue = KMem.WX[nDataAddr];
		break;
	case KLDataTypeWY:
		if (nDataAddr >= KLDataWYCount) return 0;
		thisValue = KMem.WY[nDataAddr];
		break;
	case KLDataTypeWR:
		if (nDataAddr >= KLDataWRCount) return 0;
		thisValue = KMem.WR[nDataAddr];
		break;
	case KLDataTypeWLX:
		if (nDataAddr >= KLDataWLCount) return 0;
		thisValue = KMem.WLX[nDataAddr];
		break;
	case KLDataTypeWLY:
		if (nDataAddr >= KLDataWLCount) return 0;
		thisValue = KMem.WLY[nDataAddr];
		break;
	case KLDataTypeDT:
		if (nDataAddr >= KLDataDTCount) return 0;
		thisValue = (signed short)KMem.DT[nDataAddr];
		break;
	case KLDataTypeSDT:
		if (nDataAddr >= KLDataSDTCount) return 0;
		thisValue = KMem.SDT[nDataAddr];
		break;
	case KLDataTypeWSR:
		if (nDataAddr >= KLCoilLRCount) return 0;
		thisValue = KMem.WSR[nDataAddr];
		break;
	case KLDataTypeSV:
		if (nDataAddr >= KLDataSVCount) return 0;
		thisValue = KMem.SV[nDataAddr];
		break;
	case KLDataTypeEV:
		if (nDataAddr >= KLDataEVCount) return 0;
		thisValue = KMem.EV[nDataAddr];
		break;
	case KLDataTypeLD:
		if (nDataAddr >= KLDataLDCount) return 0;
		thisValue = KMem.DT[nDataAddr];
		break;
	case KLDataSysCfg:
		if (nDataAddr >= KLCoilSRCount) return 0;
		thisValue = KMem.SDT[nDataAddr];
		break;
	case KLDataTypeFlash:
		if (nDataAddr >= KLCoilSRCount) return 0;
		thisValue = KMem.SDT[nDataAddr];
		break;
	case KLDataTypeTest:
		if (nDataAddr >= KLCoilSRCount) return 0;
		thisValue = KMem.SDT[nDataAddr];
		break;
	}
	return thisValue;
}


int SetVarData(int nDataType, int nDataAddr, int nDataValue)
{
	// TODO: ?????????.
	switch (nDataType)
	{
//	case KLDataTypeDEC:
//	case KLDataTypeHEX:
//		break;
	case KLDataTypeWX:
		if (nDataAddr >= KLDataWXCount) return 0;
		KMem.WX[nDataAddr] = nDataValue;
		break;
	case KLDataTypeWY:
		if (nDataAddr >= KLDataWYCount) return 0;
		KMem.WY[nDataAddr] = nDataValue;
		break;
	case KLDataTypeWR:
		if (nDataAddr >= KLDataWRCount) return 0;
		KMem.WR[nDataAddr] = nDataValue;
		break;
	case KLDataTypeWLX:
		if (nDataAddr >= KLDataWLCount) return 0;
		KMem.WLX[nDataAddr] = nDataValue;
		break;
	case KLDataTypeWLY:
		if (nDataAddr >= KLDataWLCount) return 0;
		KMem.WLY[nDataAddr] = nDataValue;
		break;
	case KLDataTypeDT:
		if (nDataAddr >= KLDataDTCount) return 0;
		KMem.DT[nDataAddr] = nDataValue;
		break;
	case KLDataTypeSDT:
		if (nDataAddr >= KLDataSDTCount) return 0;
		KMem.SDT[nDataAddr] = nDataValue;
		break;
	case KLDataTypeWSR:
		if (nDataAddr >= KLCoilLRCount) return 0;
		KMem.WSR[nDataAddr] = nDataValue;
		break;
	case KLDataTypeSV:
		if (nDataAddr >= KLDataSVCount) return 0;
		KMem.SV[nDataAddr] = nDataValue;
		break;
	case KLDataTypeEV:
		if (nDataAddr >= KLDataEVCount) return 0;
		KMem.EV[nDataAddr] = nDataValue;
		break;
	case KLDataTypeLD:
		if (nDataAddr >= KLDataLDCount) return 0;
		KMem.DT[nDataAddr] = nDataValue;
		break;
	case KLDataSysCfg:
		if (nDataAddr >= KLCoilSRCount) return 0;
		KMem.SDT[nDataAddr] = nDataValue;
		break;
	case KLDataTypeFlash:
		if (nDataAddr >= KLCoilSRCount) return 0;
		KMem.SDT[nDataAddr] = nDataValue;
		break;
	case KLDataTypeTest:
		if (nDataAddr >= KLCoilSRCount) return 0;
		KMem.SDT[nDataAddr] = nDataValue;
		break;
	}

	return 0;
}