F030C8T6_Kbus_MIX.git

QuakeGod

2024-07-27 842bb64195f958b050867c50db66fc0aa413dafb

提交 \| 用户 \| age
483170	1	/**
Q	2	******************************************************************************
	3	* @file : KMachine.c
	4	* @brief : KMachine program body
	5	******************************************************************************
	6	*/
	7
	8	#include "KMachine.h"
5dd1b7	9	#include "KBus.h"
483170	10	#include "string.h"
Q	11	#include "Globaldef.h"
5dd1b7	12	#include "stm32f0xx.h"
Q	13	#include "stm32f0xx_ll_flash.h"
842bb6	14	#include "PLCFunctions.h"
5dd1b7	15
Q	16	//#include "stm32f0xx_hal.h"
483170	17
Q	18	//#define OB_BASE ((uint32_t)0x1FFFF800U) /!< FLASH Option Bytes base address /
	19	//#define FLASHSIZE_BASE ((uint32_t)0x1FFFF7CCU) /!< FLASH Size register base address /
	20	//#define UID_BASE ((uint32_t)0x1FFFF7ACU) /!< Unique device ID register base address /
5dd1b7	21
Q	22	//#define FLASH_BASE
	23	//#define FLASH_PAGE_SIZE 0x00000400U
	24	//#define FLASH_BANK1_END ((uint32_t)0x0800FFFFU) /!< FLASH END address of bank1 /
	25	#define ApplicationAddress 0x08001000 //应用程序首地址定义
	26	#if defined(STM32F030x8)
842bb6	27	#define NEW_APP_INFOBLOCK_ADDR 0x08008000 // 存储的新应用程序信息块的地址
Q	28	#define NEW_APP_ADDR ((uint32_t)0x08009000U) // 存储的新应用程序的地址
5dd1b7	29	#endif /* STM32F030x6 \|\| STM32F030x8 \|\| STM32F031x6 \|\| STM32F051x8 \|\| STM32F042x6 \|\| STM32F048xx \|\| STM32F058xx \|\| STM32F070x6 */
Q	30
	31	#if defined(STM32F030xC)
842bb6	32	#define NEW_APP_INFOBLOCK_ADDR 0x08020000 // 存储的新应用程序信息块的地址
Q	33	#define NEW_APP_ADDR ((uint32_t)0x08021000U) // 存储的新应用程序的地址
5dd1b7	34	#endif /* STM32F071xB \|\| STM32F072xB \|\| STM32F078xx \|\| STM32F091xC \|\| STM32F098xx \|\| STM32F030xC */
483170	35
Q	36
	37	stStoredKMSysCfg storedKMSysCfg ;
	38	stKMem KMem;
	39	stRunStat KMRunStat;
842bb6	40
Q	41
	42	extern void SetErrLed(uchar bOn);
483170	43
Q	44	//uint8_t * pFlash1 = (uint8_t *)(STORECFGBASE);
	45
	46	//void * pConfigFlashBase = (uint8_t *)(STORECFGBASE);
	47
	48	//uint16_t FlashDatas[16];
	49
	50	//uint32_t * pUID = (uint32_t *)(UID_BASE);
842bb6	51
8b51c7	52	/*
Q	53	const char VersionStr[] __attribute__((at(FLASH_BASE + 0X2000))) //__attribute__((at(0X8001000)))
483170	54	= "3.00";
8b51c7	55	*/
483170	56	const stStoredKMSysCfg KMDefaultSysCfg /__attribute__((at(STORECFGBASE)))/ =
Q	57	{
	58	START_SIGN,
	59	0x0000,
	60	{
	61	CFG_VER,
	62	0x0000, //workmode
	63	0x0000, //switchfunc
842bb6	64	4, //nCfgBlockCount;
483170	65	{ //comportparam[2]
Q	66	{
	67	PortType_KLink, //PorttType
	68	1, //Station
842bb6	69	1152, //Buadrate = * 100;
Q	70	1, //ByteSize
483170	71	0, //Parity
Q	72	0, //StopBits
842bb6	73	1, //endType
483170	74	0, //EofChar
Q	75	0, //SofChar
842bb6	76	9, //endtime
483170	77	0, //recvbuf
Q	78	0, //bufsize
	79	},
	80	{
	81	PortType_KBus, //PorttType
	82	0, //Station
	83	2304, //Buadrate = * 100;
842bb6	84	1, //ByteSize
483170	85	0, //Parity
Q	86	0, //StopBits
842bb6	87	1, //endType
483170	88	0, //EofChar
Q	89	0, //SofChar
842bb6	90	1, //endtime
483170	91	0, //recvbuf
Q	92	0, //bufsize
	93	}
	94	},
	95	{{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0}}, //inputfilterparam
	96	{{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}}, //outputholdparam
	97	{ //default port mapping
	98	0x0010,
	99	0x0020,
	100	0x0030,
	101	0x0040,
	102	0x0050,
842bb6	103	0x0060,
Q	104	0x0070,
	105	0x0080,
483170	106	},
842bb6	107	0,0,0,0,
Q	108	{
	109	{0,sizeof(stKMSysCfg)},
	110	{1,100},
	111	{2,100},
	112	{3,32},
	113	{4,32},
	114	},
	115	0x0008, //padding s
483170	116	0x0009,
Q	117	0x000a,
	118	},
	119	0x0011, //CRC16
	120	END_SIGN,
	121	};
842bb6	122
Q	123	int nEventCount=0;
	124	int nEventMinIndex;
	125	int nEventMaxIndex;
	126	unsigned int nEventMaxSeq=0;
	127	int nEventNextSpace;
	128	int nMaxCurTime=0;
	129	volatile int PowerState = 0;
	130
	131	volatile int PowerDownEvent=0;
	132	volatile int OldPowerDownEvent=0;
	133	volatile int OldPowerDownEventTime=0;
	134	int nMaxRunStatIndex=-1;
	135	unsigned int nMaxRunStatSeq=0;
	136	int nNextRunStatSpace=0;
	137
	138	int KMRegisterPort(ushort nType,stPortDef * theParam)
	139	{
	140	int curPortId = KMem.nTotalPorts;
	141
	142	KMem.pPorts[curPortId] = theParam;
	143
	144	KMem.nTotalPorts++;
	145	return curPortId;
	146	}
	147
	148	int KMPortReqFunc(int nPortIndex,int nReqId, int nParam1, int nParam2, void ** pData, unsigned short * nlen1)
	149	{
	150	if (KMem.pPorts[nPortIndex]->ReqCommFunc)
	151	return KMem.pPorts[nPortIndex]->ReqCommFunc(KMem.pPorts[nPortIndex]->pInstance, nReqId, nParam1, nParam2, pData, nlen1);
	152	else return -1;
	153	}
	154
	155	int KMRunService(int nSvrId, int nParam1, int nParam2, void *pData, unsigned short nlen1)
	156	{
	157	int res;
	158	switch(nSvrId)
	159	{
	160	case ReqNone:
	161	break;
	162
	163	case ReqInit:
	164	break;
	165	case ReqReset:
	166	__set_PRIMASK(1); //关闭全局中断
	167	NVIC_SystemReset();
	168	break;
	169	case ReqStop:
	170	break;
	171	case ReqRun:
	172	break;
	173	case ReqBlinkLED:
	174	break;
	175	case ReqStartDiag:
	176	break;
	177	case ReqStopDiag:
	178	break;
	179	case ReqUpdateFirm:
	180
	181	res = WriteNewApp(nParam1,pData,nlen1);
	182
	183	break;
	184	case ReqUpdateFirmInfo:
	185	res = WriteNewAppInfo(nParam1,pData,nlen1);
	186	break;
	187
	188	default:
	189	res = -1;
	190	break;
	191
	192	}
	193	return res;
	194	}
	195
	196	int KMachineInit(void)
	197	{
	198	// ClearEventLog();
	199	KMem.LastScanTime=0;
	200	KMem.ScanTimeuS=0;
	201	KMem.MinScanTimeuS=99999;
	202	KMem.MaxScanTimeuS=0;
	203
	204	// KMem.SDD[14]=(unsigned int)&KMStoreSysCfg;
	205	// KMem.SDD[15]=(unsigned int)&KMStoreSysCfg1;
	206	KMem.SDD[12]=((uint32_t *)UID_BASE)[0];
	207	// KMem.SDD[13]=((uint32_t *)UID_BASE)[1];
	208	// KMem.SDD[14]=((uint32_t *)UID_BASE)[2];
	209	KMem.SDD[13]=PendSvCount;
	210	KMem.SDD[14]=RCC->CSR;
	211	// KMem.SDD[15]=(uint32_t )FLASHSIZE_BASE;
	212	// KMem.SDD[16]=(unsigned int)&KMSysCfg;
	213
	214	KMem.nTotalPorts = 0;
	215	CheckEventLog();
	216	LoadRunStat(&KMRunStat);
	217	KMem.CurTimeSec=nMaxCurTime;
	218	KMem.TotalRunTime=KMRunStat.UpTime;
	219	KMRunStat.PowerCount++;
	220	KMem.PwrOnCount=KMRunStat.PowerCount;
	221	SaveRunStat(&KMRunStat);
	222	KMem.SDD[15]=nMaxRunStatIndex;
	223	KMem.SDD[16]=nMaxRunStatSeq;
	224	KMem.SDD[17]=nNextRunStatSpace;
	225
	226
	227	AddEventLog(KMem.CurTimeSec,EventTypePowerUp,1,12345);
	228	KMem.SDD[19]=nEventCount;
	229	KMem.SDD[20]=nEventMinIndex;
	230	KMem.SDD[21]=nEventMaxIndex;
	231	KMem.SDD[22]=nEventMaxSeq;
	232	KMem.SDD[23]=nEventNextSpace;
	233
	234	return 0;
	235	}
	236
	237	int KMachineLoopProc(void)
	238	{
	239
	240	return 0;
	241	}
	242
483170	243
Q	244	//const stKMSysCfg KMDefaultSysCfg2[7] /__attribute__((at(STORECFGBASE+sizeof(stKMSysCfg))))/;
	245
	246	int ReadFlashMem(void * pBuf, void * pAddrFlash, int nByteSize)
	247	{
	248	// memcpy(pBuf,pAddrFlash,nSize);
	249	for (int i=0;i<nByteSize/4;i++)
	250	{
	251	((uint32_t )pBuf)[i] = ((uint32_t )pAddrFlash)[i];
	252	}
	253	for (int i=nByteSize/4*2;i<nByteSize/2;i++)
	254	{
	255	((uint16_t )pBuf)[i] = ((uint16_t )pAddrFlash)[i];
	256	}
	257	return nByteSize;
	258	}
842bb6	259
483170	260	int EraseFlashMem(void * pAddrFlash, unsigned int Pages)
Q	261	{
5dd1b7	262	ErrorStatus res;
Q	263	res = LL_Flash_Unlock();
	264	// uint32_t ErrNo;
	265	res = LL_Flash_PageErase(pAddrFlash,Pages);
	266	LL_FLASH_Lock(FLASH);
842bb6	267	return res;
483170	268	}
842bb6	269
483170	270	int WriteToFlashMemNoErase(void * pBuf, void * pAddrFlash, unsigned int nByteSize)
Q	271	{
5dd1b7	272	ErrorStatus res;
842bb6	273	SetErrLed(1);
5dd1b7	274	res = LL_Flash_Unlock();
Q	275	// __disable_irq();
483170	276	///*
5dd1b7	277	for (int i=0;i<(nByteSize+1)/2;i++)
483170	278	{
5dd1b7	279	unsigned short value = ((uint8_t )pBuf)[i2] + (((uint8_t )pBuf)[i2 +1] << 8);
Q	280	res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
	281	if (res == ERROR) break;
483170	282	}
5dd1b7	283	// */
Q	284	// __enable_irq();
	285	LL_FLASH_Lock(FLASH);
	286	if (res == ERROR) return 1;
	287	return 0;
483170	288	}
842bb6	289
483170	290	int EraseAndWriteToFlashMem(void * pBuf, void * pAddrFlash, unsigned int nByteSize)
Q	291	{
	292
842bb6	293	SetErrLed(1);
5dd1b7	294	ErrorStatus res;
Q	295	res = LL_Flash_Unlock();
	296	// __disable_irq();
	297	int NbPages = (nByteSize-1) / FLASH_PAGE_SIZE + 1;
	298	// FLASH_EraseInitTypeDef erase1;
	299	// erase1.NbPages=(nByteSize-1) / FLASH_PAGE_SIZE + 1;;
	300	// erase1.PageAddress=(unsigned int)pAddrFlash;
	301	// erase1.TypeErase=FLASH_TYPEERASE_PAGES;
	302	res = LL_Flash_PageErase(pAddrFlash,NbPages);
	303	for (int i=0;i<(nByteSize+1)/2;i++)
483170	304	{
5dd1b7	305	unsigned short value = ((uint8_t )pBuf)[i2] + (((uint8_t )pBuf)[i2 +1] << 8);
Q	306	res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
	307	if (res == ERROR) break;
483170	308	}
5dd1b7	309
Q	310	// __enable_irq();
	311	LL_FLASH_Lock(FLASH);
	312	if (res == ERROR) return 1;
	313	return 0;
483170	314	}
Q	315
842bb6	316	/* 烧录Flash，并自动擦除，页起始和跨页时自动擦除页面中部分不擦除 */
Q	317	int WriteToFlashAutoErase(void * pBuf, void * pAddrFlash, unsigned int nByteSize)
	318	{
	319	SetErrLed(1);
	320	ErrorStatus res;
	321	res = LL_Flash_Unlock();
	322	// __disable_irq();
	323
	324	int StartPage = (int)pAddrFlash / FLASH_PAGE_SIZE;
	325	int EndPage = ((int)pAddrFlash + nByteSize) / FLASH_PAGE_SIZE;
	326	int StartOffset = (int)pAddrFlash & (FLASH_PAGE_SIZE-1);
	327
	328	int NbPages = EndPage -StartPage + 1;
	329
	330	if (StartOffset == 0) { // 从最开始 , 全部擦除,然后再存储.
	331	res = LL_Flash_PageErase(pAddrFlash,NbPages);
	332	for (int i=0;i<(nByteSize+1)/2;i++)
	333	{
	334	unsigned short value = ((uint8_t )pBuf)[i2] + (((uint8_t )pBuf)[i2 +1] << 8);
	335	res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
	336	if (res == ERROR) break;
	337	}
	338	}else if (NbPages > 1){ // 跨页存储
	339	// 先前面的部分
	340	int i;
	341	for (i=0;i<(nByteSize+1)/2 && (((int)pAddrFlash + i*2) &(FLASH_PAGE_SIZE -1))!=0 ;i++)
	342	{
	343	unsigned short value = ((uint8_t )pBuf)[i2] + (((uint8_t )pBuf)[i2 +1] << 8);
	344	res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
	345	if (res == ERROR) break;
	346	}
	347	// 擦除后面的部分.
	348	res = LL_Flash_PageErase((void )((int)pAddrFlash + i2),NbPages - 1);
	349	// 继续存储
	350	for ( ;i<(nByteSize+1)/2;i++)
	351	{
	352	unsigned short value = ((uint8_t )pBuf)[i2] + (((uint8_t )pBuf)[i2 +1] << 8);
	353	res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
	354	if (res == ERROR) break;
	355	}
	356	}else {
	357	// 正常写入,不需要擦除
	358	for (int i=0;i<(nByteSize+1)/2;i++)
	359	{
	360	unsigned short value = ((uint8_t )pBuf)[i2] + (((uint8_t )pBuf)[i2 +1] << 8);
	361	res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
	362	if (res == ERROR) break;
	363	}
	364	}
	365	// __enable_irq();
	366	LL_FLASH_Lock(FLASH);
	367	if (res == ERROR) return 1;
	368	return 0;
	369	}
	370
483170	371	int ReadFactoryData(void * pDatabuf, int nByteCount)
Q	372	{
	373	memcpy(pDatabuf,(stFactoryData *)FACTORY_DATA_BASE,nByteCount);
	374	return 0;
	375	}
	376	int WriteFactoryData(void * pDataBuf, int nByteCount)
	377	{
	378	stFactoryData * p1 = (stFactoryData*) pDataBuf;
	379	stFactoryData * p2 = (stFactoryData *)FACTORY_DATA_BASE;
	380	p1->Seq1= p2->Seq1+1;
	381
	382	EraseAndWriteToFlashMem(pDataBuf, (stFactoryData *)FACTORY_DATA_BASE,nByteCount);
	383	return 0;
	384	}
842bb6	385	#if (ENABLE_PLC)
Q	386	int ReadPLCProgram(int nBank, int nProgByteAddr, void *pBuf, int nByteSize)
483170	387	{
842bb6	388	stStoredBinProgs * pStoredProg;
483170	389	if (nBank==0) {
842bb6	390	pStoredProg = (void *)(STORE_PRG_BASE);
483170	391	}else if (nBank ==1) {
842bb6	392	pStoredProg = (void *)(ALT_PRG_BASE);
Q	393	}else if (storedKMSysCfg.theKMSysCfg.nProgBank==0) {
	394	pStoredProg = (void *)(STORE_PRG_BASE);
483170	395	} else {
842bb6	396	pStoredProg = (void *)(ALT_PRG_BASE);
483170	397	}
842bb6	398	void * progByteAddr;
Q	399	progByteAddr =(unsigned char *)&pStoredProg->BinInstrcns + nProgByteAddr;
	400
	401	ReadFlashMem(pBuf, (void *)(progByteAddr), nByteSize);
483170	402	return 0;
Q	403	}
842bb6	404
Q	405	int StartPLCProgram(int nBank, int nByteSize, int nCRC)
	406	{
	407	void * progHdrAddr;
	408	int nRes = 0;
	409	if (nBank == 0) {
	410	progHdrAddr=(void *)(STORE_PRG_BASE);
	411	}else if (nBank==1) {
	412	progHdrAddr=(void *)(ALT_PRG_BASE);
	413	} else if (storedKMSysCfg.theKMSysCfg.nProgBank==0) {
	414	progHdrAddr=(void *)(ALT_PRG_BASE);
	415	}else{
	416	progHdrAddr=(void *)(STORE_PRG_BASE);
	417	}
	418
	419	stStoredHdr theHdr;
	420	theHdr.nBlockSign = 0xAA55;
	421	theHdr.nBlockType = 0;
	422	theHdr.nSeq = 1;
	423	theHdr.nSize = nByteSize;
	424	theHdr.nCRC2 = nCRC;
	425
	426	WriteToFlashAutoErase(&theHdr,(void *)progHdrAddr,sizeof(stStoredHdr));
	427
	428	return nRes;
	429	}
	430	int WritePLCProgram(int nBank, int nProgAddress, void * pBuf, int nByteSize)
483170	431	{
Q	432	// Program Save Address;//
	433	// Program 2 Save Address; //
842bb6	434	stStoredBinProgs * pStoredProg;
Q	435
483170	436	if (nBank == 0) {
842bb6	437	pStoredProg=(stStoredBinProgs *)(STORE_PRG_BASE);
483170	438	}else if (nBank==1) {
842bb6	439	pStoredProg=(stStoredBinProgs *)(ALT_PRG_BASE);
Q	440	} else if (storedKMSysCfg.theKMSysCfg.nProgBank==0) {
	441	pStoredProg=(stStoredBinProgs *)(ALT_PRG_BASE);
483170	442	}else{
842bb6	443	pStoredProg=(stStoredBinProgs *)(STORE_PRG_BASE);
483170	444	}
842bb6	445	void * progByteAddr;
Q	446	progByteAddr =(unsigned char *)&pStoredProg->BinInstrcns + nProgAddress;
	447	WriteToFlashAutoErase(pBuf,progByteAddr,nByteSize);
	448
483170	449	return 0;
Q	450	}
	451
842bb6	452	int FinishiPLCProgram(int nBank, int nProgSteps,int nCRC )
Q	453	{
	454	int nRes = 0;
	455
	456	if (storedKMSysCfg.theKMSysCfg.nProgBank == 0 ) {
	457	storedKMSysCfg.theKMSysCfg.nProgBank = 1;
	458	}else {
	459	storedKMSysCfg.theKMSysCfg.nProgBank = 0;
	460	}
	461	storedKMSysCfg.theKMSysCfg.nProgSize = nProgSteps;
	462
	463	WriteSysCfgToFlash(&storedKMSysCfg);
	464
	465	KMRunStat.nBinProgSize=nProgSteps;
	466	KMRunStat.nBinProgBank=storedKMSysCfg.theKMSysCfg.nProgBank;
	467
	468	SaveRunStat(&KMRunStat);
	469
	470	return nRes;
	471	}
	472	int ReadPLCAnno(int nBank, int nProgByteAddr, void *pBuf, int nByteSize)
	473	{
	474	stStoredBinProgs * pStoredProg;
	475	if (nBank==0) {
	476	pStoredProg = (void *)(STORE_PRG_BASE);
	477	}else if (nBank ==1) {
	478	pStoredProg = (void *)(ALT_PRG_BASE);
	479	}else if (storedKMSysCfg.theKMSysCfg.nProgBank==0) {
	480	pStoredProg = (void *)(STORE_PRG_BASE);
	481	} else {
	482	pStoredProg = (void *)(ALT_PRG_BASE);
	483	}
	484	void * progByteAddr;
	485	progByteAddr =(unsigned char *)&pStoredProg->BinInstrcns + nProgByteAddr;
	486
	487	ReadFlashMem(pBuf, (void *)(progByteAddr), nByteSize);
	488	return 0;
	489	}
	490
	491	int StartPLCAnno(int nBank, int nByteSize, int nCRC)
	492	{
	493	void * StoredAnnoHdrAddr;
	494	int nRes = 0;
	495
	496	StoredAnnoHdrAddr=(void *)(STORE_PLC_ANNO_BASE);
	497
	498
	499	stStoredHdr theHdr;
	500	theHdr.nBlockSign = 0xAA55;
	501	theHdr.nBlockType = 3;
	502	theHdr.nSeq = 1;
	503	theHdr.nSize = nByteSize;
	504	theHdr.nCRC2 = nCRC;
	505
	506	WriteToFlashAutoErase(&theHdr,(void *)StoredAnnoHdrAddr,sizeof(stStoredHdr));
	507
	508	return nRes;
	509	}
	510	int WritePLCAnno(int nBank, int nByteAddress, void * pBuf, int nByteSize)
	511	{
	512	// Program Save Address;//
	513	// Program 2 Save Address; //
	514	stStoredAnno * pStoredAnno;
	515	pStoredAnno=(stStoredAnno *)(STORE_PLC_ANNO_BASE);
	516
	517	void * nByteAddr;
	518	nByteAddr =pStoredAnno->Annos + nByteAddress;
	519	WriteToFlashAutoErase(pBuf,nByteAddr,nByteSize);
	520
	521	return 0;
	522	}
	523	int FinishiPLCAnno(int nBank, int nByteSize,int nCRC )
	524	{
	525	int nRes = 0;
	526
	527	storedKMSysCfg.theKMSysCfg.nAnnoSize = nByteSize;
	528	WriteSysCfgToFlash(&storedKMSysCfg);
	529	/*
	530	KMRunStat.nBinProgSize=nProgSteps;
	531	KMRunStat.nBinProgBank=storedKMSysCfg.theKMSysCfg.nProgBank;
	532
	533	SaveRunStat(&KMRunStat);
	534	*/
	535	return nRes;
	536	}
	537
	538	#endif //ENABLE_PLC
483170	539	int LoadDefaultSysCfg(pStoredKMSysCfg theStoredKMSysCfg)
Q	540	{
	541	memcpy(theStoredKMSysCfg,&KMDefaultSysCfg,sizeof(stStoredKMSysCfg));
	542	return 0;
	543	}
	544	int ReadSysCfgFromFlash(pStoredKMSysCfg theStoredKMSysCfg)
	545	{
	546	pStoredKMSysCfg pSKMSysCfg = (pStoredKMSysCfg)(STORE_SYSREG_BASE);
	547	// find latest Store Cfg
	548	int s2=128;
	549	int nIndex=-1;
	550	int nMaxSeq=0;
	551	for (int i=0;i<8;i++)
	552	{
	553	pSKMSysCfg = (pStoredKMSysCfg)(STORE_SYSREG_BASE + s2*i);
	554	if (pSKMSysCfg->Sign1 == START_SIGN && pSKMSysCfg->EndSign1 == END_SIGN)
	555	{
	556	if (pSKMSysCfg->Seq1 > nMaxSeq)
	557	{
	558	nIndex=i;nMaxSeq=pSKMSysCfg->Seq1;
	559	}
	560	}
	561	}
	562	if (nIndex>=0 && nIndex <8)
	563	{
	564	ReadFlashMem(theStoredKMSysCfg,(void )(STORE_SYSREG_BASE + nIndex s2),sizeof(stStoredKMSysCfg));
	565	//ReadFlashMem(theStoredKMSysCfg,(void *)(STORE_SYSREG_BASE ),sizeof(stStoredKMSysCfg));
	566	//memcpy(theStoredKMSysCfg,(void *)(STORE_SYSREG_BASE ),sizeof(stStoredKMSysCfg));
	567	}else {
	568	LoadDefaultSysCfg(theStoredKMSysCfg);
	569	}
	570	//memcpy(theKMSysCfg,(void* )STORECFGBASE,sizeof(KMSysCfg));
	571	return 0;
	572	}
	573
	574	int WriteSysCfgToFlash(pStoredKMSysCfg theStoredKMSysCfg)
	575	{
	576	theStoredKMSysCfg->Seq1++;
	577	theStoredKMSysCfg->Sign1 = START_SIGN;
	578	theStoredKMSysCfg->EndSign1 = END_SIGN;
	579	// EraseAndWriteToFlashMem(theStoredKMSysCfg,(void *)STORE_SYSREG_BASE,sizeof(stStoredKMSysCfg));
	580	// return 0;
	581	// theKMSysCfg->cfgvar16++;
	582	// find the next empty space to write
	583	int nIndex=-1;
	584	int s2=128;
	585	for (int i=0;i<8;i++)
	586	{
	587	int skip=0;
	588	unsigned char * nAddr2=(unsigned char )(STORE_SYSREG_BASE + i s2);
	589	for (int j=0;j<s2;j++)
	590	{
	591	if ((nAddr2)[j] != 0xff) {skip =1;break;}
	592	}
	593	if (skip==1) {continue;}
	594	nIndex=i;
	595	break;
	596	}
	597	if (nIndex >=0 && nIndex <8) {
	598	WriteToFlashMemNoErase(theStoredKMSysCfg,(void )(STORE_SYSREG_BASE + nIndexs2),sizeof(stStoredKMSysCfg));
	599	}
	600	else {
	601	EraseAndWriteToFlashMem(theStoredKMSysCfg,(void *)STORE_SYSREG_BASE,sizeof(stStoredKMSysCfg));
	602	}
	603	return 0;
	604	}
	605
	606	int is_pow_of_2(uint32_t x) {
	607	return !(x & (x-1));
	608	}
	609
	610	uint32_t next_pow_of_2(uint32_t x)
	611	{
	612	if ( is_pow_of_2(x) )
	613	return x;
	614	x \|= x>>1;
	615	x \|= x>>2;
	616	x \|= x>>4;
	617	x \|= x>>8;
	618	x \|= x>>16;
	619	return x+1;
	620	}
	621
	622	//uint8_t * pFlash1;
	623	/*
	624	stStoreCfg * GetCurStoreCfgAddr(void )
	625	{
	626	int s = sizeof(stStoreCfg);
	627	int s2=next_pow_of_2(s);
	628	stStoreCfg * p1;
	629	int nMaxSN=0;
	630	int nMaxId=0;
	631	for (int i=0; s2*i < STORECFGPAGESIZE ; i++)
	632	{
	633	p1= (stStoreCfg )(STORECFGBASE + s2 i );
	634	if (p1->Sign1 != START_SIGN) continue;
	635	if (p1->EndSign1 != END_SIGN) continue;
	636
	637	if (p1->Seq1 >= nMaxSN) {nMaxSN = p1->Seq1; nMaxId = i;}
	638	}
	639	// nMaxId=nMaxId+1;
	640	return (stStoreCfg )(STORECFGBASE + s2 nMaxId);
	641	}
	642
	643	stStoreCfg * GetNextStoreCfgAddr(stStoreCfg * CurCfg )
	644	{
	645	int s = sizeof(stStoreCfg);
	646	int s2=next_pow_of_2(s);
	647	uint32_t nAddr1 = (uint32_t) CurCfg;
	648	uint32_t nAddr2 = nAddr1 + s2;
	649	for (int i=1;i<33;i++)
	650	{
	651	int skip=0;
	652	nAddr2 = nAddr1 + s2*i;
	653	if ((nAddr2 + s) > STORECFGBASE + STORECFGPAGESIZE)
	654	{
	655	nAddr2=STORECFGBASE; break;
	656	}
	657	for (int j=0;j<s2;j++)
	658	{
	659	if (((unsigned char *)nAddr2)[j] != 0xff)
	660	{skip =1;}
	661	}
	662	if (skip==1) {continue;}
	663	break;
	664	}
	665	stStoreCfg * p1 = (stStoreCfg *)nAddr2;
	666	return p1;
	667	}
	668
	669
	670	int SaveStoreCfg(stStoreCfg * CurCfg)
	671	{
	672	return 0;
	673	}
	674	*/
	675	// stStoreCfg Cfg2;
	676
	677	int LoadFlashDatas()
	678	{
	679	for (int i=0;i<16;i++)
	680	{
	681	// FlashDatas[i]=((uint16_t *)pConfigFlashBase)[i];
	682	}
	683	return 0;
	684	}
	685	/*
	686	int LoadAndUpdateStoreCfg()
	687	{
	688	stStoreCfg * pFCfg = (stStoreCfg *) GetCurStoreCfgAddr();
	689
	690	Cfg2.Sign1=START_SIGN;
	691	Cfg2.Seq1=pFCfg[0].Seq1+1;
	692	Cfg2.CRC1=0x7777;
	693	Cfg2.PowerCount=pFCfg[0].PowerCount+1;
	694	Cfg2.UpTime=pFCfg[0].UpTime+1;
	695	Cfg2.UserData1=pFCfg[0].UserData1;
	696	Cfg2.EndSign1=END_SIGN;
	697	stStoreCfg * pFCfg2 = GetNextStoreCfgAddr(pFCfg);
	698
	699
	700	HAL_StatusTypeDef res;
	701	if (pFCfg2 <= pFCfg)
	702	{
	703	res = (HAL_StatusTypeDef)EraseAndWriteToFlashMem(&Cfg2,pFCfg2,sizeof(stStoreCfg));
	704
	705	}else
	706	{
	707	res = (HAL_StatusTypeDef)WriteToFlashMemNoErase(&Cfg2,pFCfg2,sizeof(stStoreCfg));
	708	}
	709	return res;
	710	}
	711	*/
	712	int CheckSavedData(void * pStartAddr, int PageSize, int Pages, int DataSize)
	713	{
	714	return 0;
	715	};
	716
	717	int LoadDefaultRunStat(pRunStat theRunStat)
	718	{
	719	theRunStat->PowerCount=1;
	720	// theRunStat->UpTime=0;
	721	// theRunStat->UserData1=0;
	722	// theRunStat->WorkMode=0;
	723	// theRunStat->WorkMode2=0;
	724	// theRunStat->nBinProgBank=0;
842bb6	725	// theRunStat->nBinInstrcnSize=0;
483170	726	return 0;
Q	727	}
	728	int LoadRunStat(pRunStat theRunStat)
	729	{
	730	uchar * pRunStatStore = (uchar *)STORE_RUNSTAT_BASE;
	731	pRunStat pStoreRunStats = (pRunStat)pRunStatStore;
	732	// int s = sizeof(stRunStat);
	733
5dd1b7	734	for (int i=0;i * sizeof(stRunStat) < (FLASH_PAGE_SIZE * STORE_RUNSTAT_PAGES) ;i++)
483170	735	{
Q	736	if (pStoreRunStats[i].Sign1 == START_SIGN )
	737	{
	738	if (pStoreRunStats[i].Seq1 > nMaxRunStatSeq)
	739	{
	740	nMaxRunStatSeq = pStoreRunStats[i].Seq1;
	741	nMaxRunStatIndex=i;
	742	nNextRunStatSpace=i+1;
	743	}
	744	}
	745	}
	746	if (nMaxRunStatIndex>=0) // && nMaxRunStatIndex <8)
	747	{
	748	ReadFlashMem(theRunStat,(void *)(pStoreRunStats+nMaxRunStatIndex),sizeof(stRunStat));
	749	}else {
	750	LoadDefaultRunStat(theRunStat);
	751	}
	752	// find Next Space
	753	// if Same Page with MaxSeq Index, then not erase, skip and skip.
	754	// if next Page of MaxSeq Index, then earse if not empty;
5dd1b7	755	if ((nNextRunStatSpace + 1) * sizeof(stRunStat) > FLASH_PAGE_SIZE * STORE_RUNSTAT_PAGES) {
483170	756	nNextRunStatSpace=0;
Q	757	}
	758	return 0;
	759	}
	760
	761	int SaveRunStat(pRunStat theRunStat)
	762	{
	763	nMaxRunStatSeq++;
	764	theRunStat->Sign1=START_SIGN;
	765	theRunStat->Seq1 = nMaxRunStatSeq;
	766	theRunStat->PowerCount=KMem.PwrOnCount;
	767	theRunStat->UpTime=KMem.TotalRunTime;
	768	theRunStat->CRC1=0x11;
	769	theRunStat->EndSign1=END_SIGN;
	770
	771	//check empty
	772	unsigned char pFlash = (unsigned char )(STORE_RUNSTAT_BASE + nNextRunStatSpace*sizeof(stRunStat));
	773	int Skip=0;
	774	for (int j=0;j<sizeof(stRunStat);j++)
	775	{
	776	if (pFlash[j]!=0xff) {Skip =1 ; break;}
	777	}
	778	if (Skip ==0 )
	779	{
	780	WriteToFlashMemNoErase(theRunStat,(void )(STORE_RUNSTAT_BASE + nNextRunStatSpacesizeof(stRunStat)),sizeof(stRunStat));
	781	}else
	782	{
	783	EraseAndWriteToFlashMem(theRunStat,(void )(STORE_RUNSTAT_BASE + nNextRunStatSpacesizeof(stRunStat)),sizeof(stRunStat));
	784	}
	785	nMaxRunStatIndex=nNextRunStatSpace;
	786	nNextRunStatSpace++;
5dd1b7	787	if ((nNextRunStatSpace+1) * sizeof(stRunStat) > FLASH_PAGE_SIZE * STORE_RUNSTAT_PAGES)
483170	788	{
Q	789	nNextRunStatSpace=0;
	790	}
	791	return 0;
	792	}
	793
842bb6	794	int WriteNewApp(int nProgByteOffset, void *pBuf, int nByteSize)
5dd1b7	795	{
842bb6	796
5dd1b7	797	int res = -1;
842bb6	798	int FlashSize = (ushort )FLASHSIZE_BASE;
Q	799	int NewAppAddress ;
	800	if (FlashSize == 64) {
	801	NewAppAddress = 0x08009000U;
	802	}else if (FlashSize == 256) {
	803	NewAppAddress = 0x08021000U;
	804	}
	805	if ((nProgByteOffset&(FLASH_PAGE_SIZE-1)) ==0){
5dd1b7	806	// EraseFlashMem((void *)(NewAppAddress + nProgByteAddr),1);
842bb6	807
Q	808	res = EraseAndWriteToFlashMem(pBuf,(void *)(NewAppAddress + nProgByteOffset),nByteSize);
5dd1b7	809	}else {
Q	810	// if (nByteSize>64) return 0;
842bb6	811	res = WriteToFlashMemNoErase(pBuf,(void *)(NewAppAddress + nProgByteOffset),nByteSize);
5dd1b7	812	}
Q	813	return res;
	814	}
	815
	816	int WriteNewAppInfo(int nProgByteAddr, void *pBuf, int nByteSize)
	817	{
842bb6	818	int FlashSize = (ushort )FLASHSIZE_BASE;
Q	819	int NewAppInfoBlockAddress ;
	820	if (FlashSize == 64) {
	821	NewAppInfoBlockAddress = 0x08008000;
	822	}else if (FlashSize == 256) {
	823	NewAppInfoBlockAddress = 0x08020000;
	824	}
	825
5dd1b7	826	int res = EraseAndWriteToFlashMem(pBuf,(void *)(NewAppInfoBlockAddress + nProgByteAddr),nByteSize);
Q	827	return res;
	828	}
483170	829
Q	830	int CheckEventLog()
	831	{
	832	unsigned int nMinEventSeq=999999999;
	833	uchar * pEventStore = (uchar *)STORE_LOG_BASE;
	834	pEventLog theEventLog = (pEventLog) pEventStore;
	835	// int s = sizeof(stEventLog);
	836	nEventCount=0;
	837
5dd1b7	838	for (int i=0;i * sizeof(stEventLog) < (FLASH_PAGE_SIZE * STORE_LOG_PAGES) ;i++)
483170	839	{
Q	840	if (theEventLog[i].Sign1 == START_SIGN )
	841	{
	842	nEventCount++;
	843	if (theEventLog[i].Seq1 > nEventMaxSeq)
	844	{
	845	nEventMaxSeq = theEventLog[i].Seq1;
	846	nEventMaxIndex=i;
	847	nMaxCurTime=theEventLog[i].nTime;
	848	nEventNextSpace=i+1;
	849	}
	850	if (theEventLog[i].Seq1 < nMinEventSeq)
	851	{
	852	nMinEventSeq = theEventLog[i].Seq1;
	853	nEventMinIndex = i;
	854	}
	855	}
	856	}
	857	// find Next Space
	858	// if Same Page with MaxSeq Index, then not erase, skip and skip.
	859	// if next Page of MaxSeq Index, then earse if not empty;
5dd1b7	860	if ((nEventNextSpace + 1) * sizeof(stEventLog) > FLASH_PAGE_SIZE * STORE_LOG_PAGES) {
483170	861	nEventNextSpace=0;
Q	862	}
	863
	864	return nEventCount;
	865	}
	866
	867	int AddEventLog(uint32_t nTime, USHORT nEvent, USHORT nParam1, UINT nParam2)
	868	{
	869	nEventMaxSeq++;
	870	stEventLog thisEventLog={START_SIGN, nEventMaxSeq, nTime,nEvent,nParam1,nParam2};
	871	//check empty
	872	unsigned char pFlash = (unsigned char )(STORE_LOG_BASE + nEventNextSpace*sizeof(stEventLog));
	873	int Skip=0;
	874	for (int j=0;j<sizeof(stEventLog);j++)
	875	{
	876	if (pFlash[j]!=0xff) {Skip =1 ; break;}
	877	}
	878	if (Skip ==0 )
	879	{
	880	WriteToFlashMemNoErase(&thisEventLog,(void )(STORE_LOG_BASE + nEventNextSpacesizeof(stEventLog)),sizeof(stEventLog));
	881	}else
	882	{
	883	EraseAndWriteToFlashMem(&thisEventLog,(void )(STORE_LOG_BASE + nEventNextSpacesizeof(stEventLog)),sizeof(stEventLog));
	884
	885	}
	886	nEventMaxIndex=nEventNextSpace;
	887	nEventNextSpace++;
5dd1b7	888	if ((nEventNextSpace+1) * sizeof(stEventLog) > FLASH_PAGE_SIZE * STORE_LOG_PAGES)
483170	889	{
Q	890	nEventNextSpace=0;
	891	}
	892	nEventCount++;
	893	KMem.nEventCount=nEventCount;
	894	return 0;
	895	}
	896
	897	pEventLog GetEventLogAddr(int nIndex)
	898	{
	899	int nEventIndex=nEventMinIndex + nIndex;
	900
5dd1b7	901	if (nEventIndex * sizeof(stEventLog) >= (FLASH_PAGE_SIZE * STORE_LOG_PAGES))
483170	902	{
5dd1b7	903	nEventIndex -= (FLASH_PAGE_SIZE * STORE_LOG_PAGES)/sizeof(stEventLog);
483170	904	}
Q	905	unsigned char pFlash = (unsigned char )(STORE_LOG_BASE + nEventIndex*sizeof(stEventLog));
	906
	907	return (pEventLog)pFlash;
	908	}
	909
	910	int ClearEventLog(void)
	911	{
	912	EraseFlashMem((void *)STORE_LOG_BASE,STORE_LOG_PAGES);
	913	nEventMinIndex=0;
	914	nEventMaxIndex=0;
	915	nEventMaxSeq=0;
	916	nEventCount=0;
	917	nEventNextSpace=0;
	918	return 0;
	919	}
	920
842bb6	921	inline void SetAddrBit(unsigned short * pW, unsigned char bitPos)
Q	922	{
	923	(*pW)\|=1<<(bitPos&0xf);
483170	924	}
Q	925
842bb6	926	inline void ResetBit(unsigned short * pW, unsigned char bitPos)
483170	927	{
842bb6	928	(*pW)&=~(1<<(bitPos&0xf));
483170	929	}
Q	930
842bb6	931	static inline void SetBitValue(unsigned short * pW, unsigned char bitPos, unsigned char Value)
483170	932	{
842bb6	933	if (Value) { SetAddrBit(pW, bitPos);}
Q	934	else {ResetBit(pW, bitPos);}
483170	935	}
Q	936
842bb6	937	static inline unsigned char GetBitValue(unsigned short W, unsigned char bitPos)
483170	938	{
842bb6	939	if (W&(1<<(bitPos&0xf))) return 1;
483170	940	else return 0;
Q	941	}
	942
	943
	944	unsigned char GetCoilValue(unsigned char nCoilType, unsigned short nCoilAddr)
	945	{
	946	unsigned char thisValue=0;
	947	unsigned short nWordAddr=(nCoilAddr&0xff0)>>4;
842bb6	948	unsigned char nBitPos=nCoilAddr&0xf;
483170	949	switch(nCoilType)
Q	950	{
	951	case KLCoilTypeX:
	952	if (nCoilAddr >= KLCoilXCount) return 0;
842bb6	953	thisValue = GetBitValue(KMem.WX[nWordAddr], nBitPos);
483170	954	break;
Q	955	case KLCoilTypeY:
	956	if (nCoilAddr >= KLCoilYCount) return 0;
842bb6	957	thisValue = GetBitValue(KMem.WY[nWordAddr], nBitPos);
483170	958	break;
Q	959	case KLCoilTypeR:
842bb6	960
Q	961	if (nCoilAddr < KLCoilRCount) {
	962	thisValue = GetBitValue(KMem.WR[nWordAddr], nBitPos);
	963	}else if (nCoilAddr > 9000) {
	964	if (nCoilAddr == 9010) thisValue = 1;
	965	if (nCoilAddr == 9011) thisValue = 0;
	966	if (nCoilAddr == 9013) thisValue = GetBitValue(KMem.WSR[nWordAddr], 13);
	967	}
	968	// return thisValue;
483170	969	break;
Q	970	case KLCoilTypeLX:
	971	if (nCoilAddr >= KLCoilLXCount) return 0;
842bb6	972	thisValue = GetBitValue(KMem.WLX[nWordAddr], nBitPos);
483170	973	break;
Q	974	case KLCoilTypeLY:
	975	if (nCoilAddr >= KLCoilLYCount) return 0;
842bb6	976	thisValue = GetBitValue(KMem.WLY[nWordAddr], nBitPos);
483170	977	break;
842bb6	978	#if (ENABLE_PLC)
483170	979	case KLCoilTypeT:
Q	980	if (nCoilAddr >= KLCoilTCount) return 0;
842bb6	981	thisValue = GetBitValue(PLCMem.WT[nWordAddr], nBitPos);
483170	982	break;
Q	983	case KLCoilTypeC:
	984	if (nCoilAddr >= KLCoilCCount) return 0;
842bb6	985	thisValue = GetBitValue(PLCMem.WC[nWordAddr], nBitPos);
483170	986	break;
842bb6	987	#endif
483170	988	case KLCoilTypeLR:
Q	989	if (nCoilAddr >= KLCoilLRCount) return 0;
842bb6	990	thisValue = GetBitValue(KMem.WLR[nWordAddr], nBitPos);
483170	991	break;
Q	992	case KLCoilTypeSR:
	993	if (nCoilAddr >= KLCoilSRCount) return 0;
842bb6	994	thisValue = GetBitValue(KMem.WSR[nWordAddr], nBitPos);
483170	995	break;
Q	996	default:
	997	break;
	998	}
	999	return thisValue;
	1000	}
	1001	int SetCoilValue(unsigned char nCoilType, unsigned short nCoilAddr, unsigned char nCoilValue)
	1002	{
	1003	unsigned short nWordAddr=(nCoilAddr&0xff0)>>4;
	1004	unsigned char nBitAddr=nCoilAddr&0xf;
	1005	switch(nCoilType)
	1006	{
	1007	case KLCoilTypeX:
	1008	if (nCoilAddr >= KLCoilXCount) return 0;
	1009	SetBitValue(&KMem.WX[nWordAddr], nBitAddr, nCoilValue);
	1010	break;
	1011	case KLCoilTypeY:
	1012	if (nCoilAddr >= KLCoilYCount) return 0;
	1013	SetBitValue(&KMem.WY[nWordAddr], nBitAddr, nCoilValue);
	1014	break;
	1015	case KLCoilTypeR:
	1016	if (nCoilAddr >= KLCoilRCount) return 0;
	1017	SetBitValue(&KMem.WR[nWordAddr], nBitAddr, nCoilValue);
	1018	break;
	1019	case KLCoilTypeLX:
	1020	if (nCoilAddr >= KLCoilLXCount) return 0;
	1021	SetBitValue(&KMem.WLX[nWordAddr], nBitAddr, nCoilValue);
	1022	break;
	1023	case KLCoilTypeLY:
	1024	if (nCoilAddr >= KLCoilLYCount) return 0;
	1025	SetBitValue(&KMem.WLY[nWordAddr], nBitAddr, nCoilValue);
	1026	break;
842bb6	1027	#if (ENABLE_PLC)
483170	1028	case KLCoilTypeT:
Q	1029	if (nCoilAddr >= KLCoilTCount) return 0;
842bb6	1030	SetBitValue(&PLCMem.WT[nWordAddr], nBitAddr, nCoilValue);
483170	1031	break;
Q	1032	case KLCoilTypeC:
	1033	if (nCoilAddr >= KLCoilCCount) return 0;
842bb6	1034	SetBitValue(&PLCMem.WC[nWordAddr], nBitAddr, nCoilValue);
483170	1035	break;
842bb6	1036	#endif
483170	1037	case KLCoilTypeLR:
Q	1038	if (nCoilAddr >= KLCoilLRCount) return 0;
	1039	SetBitValue(&KMem.WLR[nWordAddr], nBitAddr, nCoilValue);
	1040	break;
	1041	case KLCoilTypeSR:
	1042	if (nCoilAddr >= KLCoilSRCount) return 0;
	1043	SetBitValue(&KMem.WSR[nWordAddr], nBitAddr, nCoilValue);
	1044	break;
	1045	default:
	1046	break;
	1047	}
	1048	return 0;
	1049	}
	1050
	1051	int GetVarData(int nDataType, int nDataAddr)
	1052	{
	1053	// TODO: ?????????.
	1054	int thisValue = 0;
	1055
	1056	switch (nDataType)
	1057	{
	1058	case KLDataTypeDEC:
	1059	case KLDataTypeHEX:
	1060	thisValue = nDataAddr;
	1061	break;
	1062	case KLDataTypeWX:
	1063	if (nDataAddr >= KLDataWXCount) return 0;
	1064	thisValue = KMem.WX[nDataAddr];
	1065	break;
	1066	case KLDataTypeWY:
	1067	if (nDataAddr >= KLDataWYCount) return 0;
	1068	thisValue = KMem.WY[nDataAddr];
	1069	break;
	1070	case KLDataTypeWR:
	1071	if (nDataAddr >= KLDataWRCount) return 0;
	1072	thisValue = KMem.WR[nDataAddr];
	1073	break;
	1074	case KLDataTypeWLX:
	1075	if (nDataAddr >= KLDataWLCount) return 0;
	1076	thisValue = KMem.WLX[nDataAddr];
	1077	break;
	1078	case KLDataTypeWLY:
	1079	if (nDataAddr >= KLDataWLCount) return 0;
	1080	thisValue = KMem.WLY[nDataAddr];
	1081	break;
	1082	case KLDataTypeDT:
	1083	if (nDataAddr >= KLDataDTCount) return 0;
	1084	thisValue = (signed short)KMem.DT[nDataAddr];
	1085	break;
	1086	case KLDataTypeSDT:
	1087	if (nDataAddr >= KLDataSDTCount) return 0;
	1088	thisValue = KMem.SDT[nDataAddr];
	1089	break;
	1090	case KLDataTypeWSR:
	1091	if (nDataAddr >= KLCoilLRCount) return 0;
	1092	thisValue = KMem.WSR[nDataAddr];
	1093	break;
842bb6	1094	#if (ENABLE_PLC)
483170	1095	case KLDataTypeSV:
Q	1096	if (nDataAddr >= KLDataSVCount) return 0;
842bb6	1097	thisValue = PLCMem.SV[nDataAddr];
483170	1098	break;
Q	1099	case KLDataTypeEV:
	1100	if (nDataAddr >= KLDataEVCount) return 0;
842bb6	1101	thisValue = PLCMem.EV[nDataAddr];
483170	1102	break;
842bb6	1103	#endif
483170	1104	case KLDataTypeLD:
Q	1105	if (nDataAddr >= KLDataLDCount) return 0;
	1106	thisValue = KMem.DT[nDataAddr];
	1107	break;
	1108	case KLDataSysCfg:
	1109	if (nDataAddr >= KLCoilSRCount) return 0;
	1110	thisValue = KMem.SDT[nDataAddr];
	1111	break;
	1112	case KLDataTypeFlash:
	1113	if (nDataAddr >= KLCoilSRCount) return 0;
	1114	thisValue = KMem.SDT[nDataAddr];
	1115	break;
	1116	case KLDataTypeTest:
	1117	if (nDataAddr >= KLCoilSRCount) return 0;
	1118	thisValue = KMem.SDT[nDataAddr];
	1119	break;
	1120	}
	1121	return thisValue;
	1122	}
	1123
	1124
	1125	int SetVarData(int nDataType, int nDataAddr, int nDataValue)
	1126	{
	1127	// TODO: ?????????.
	1128	switch (nDataType)
	1129	{
	1130	// case KLDataTypeDEC:
	1131	// case KLDataTypeHEX:
	1132	// break;
	1133	case KLDataTypeWX:
	1134	if (nDataAddr >= KLDataWXCount) return 0;
	1135	KMem.WX[nDataAddr] = nDataValue;
	1136	break;
	1137	case KLDataTypeWY:
	1138	if (nDataAddr >= KLDataWYCount) return 0;
	1139	KMem.WY[nDataAddr] = nDataValue;
	1140	break;
	1141	case KLDataTypeWR:
	1142	if (nDataAddr >= KLDataWRCount) return 0;
	1143	KMem.WR[nDataAddr] = nDataValue;
	1144	break;
	1145	case KLDataTypeWLX:
	1146	if (nDataAddr >= KLDataWLCount) return 0;
	1147	KMem.WLX[nDataAddr] = nDataValue;
	1148	break;
	1149	case KLDataTypeWLY:
	1150	if (nDataAddr >= KLDataWLCount) return 0;
	1151	KMem.WLY[nDataAddr] = nDataValue;
	1152	break;
	1153	case KLDataTypeDT:
	1154	if (nDataAddr >= KLDataDTCount) return 0;
	1155	KMem.DT[nDataAddr] = nDataValue;
	1156	break;
	1157	case KLDataTypeSDT:
	1158	if (nDataAddr >= KLDataSDTCount) return 0;
	1159	KMem.SDT[nDataAddr] = nDataValue;
	1160	break;
	1161	case KLDataTypeWSR:
	1162	if (nDataAddr >= KLCoilLRCount) return 0;
	1163	KMem.WSR[nDataAddr] = nDataValue;
	1164	break;
842bb6	1165	#if (ENABLE_PLC)
483170	1166	case KLDataTypeSV:
Q	1167	if (nDataAddr >= KLDataSVCount) return 0;
842bb6	1168	PLCMem.SV[nDataAddr] = nDataValue;
483170	1169	break;
Q	1170	case KLDataTypeEV:
	1171	if (nDataAddr >= KLDataEVCount) return 0;
842bb6	1172	PLCMem.EV[nDataAddr] = nDataValue;
483170	1173	break;
842bb6	1174	#endif
483170	1175	case KLDataTypeLD:
Q	1176	if (nDataAddr >= KLDataLDCount) return 0;
	1177	KMem.DT[nDataAddr] = nDataValue;
	1178	break;
	1179	case KLDataSysCfg:
	1180	if (nDataAddr >= KLCoilSRCount) return 0;
	1181	KMem.SDT[nDataAddr] = nDataValue;
	1182	break;
	1183	case KLDataTypeFlash:
	1184	if (nDataAddr >= KLCoilSRCount) return 0;
	1185	KMem.SDT[nDataAddr] = nDataValue;
	1186	break;
	1187	case KLDataTypeTest:
	1188	if (nDataAddr >= KLCoilSRCount) return 0;
	1189	KMem.SDT[nDataAddr] = nDataValue;
	1190	break;
	1191	}
	1192
	1193	return 0;
	1194	}
	1195
5dd1b7	1196
Q	1197	int KMachineSvFunc (int nChn, int nSvType, int nParam,void * pBuf, int nLen1)
	1198	{
	1199	int iRet =0;
	1200	switch (nSvType){
	1201	case ReqNone:
	1202	break;
	1203	case ReqInit:
	1204	break;
	1205	case ReqReset:
	1206	break;
	1207	case ReqStop:
	1208	break;
	1209	case ReqRun:
	1210	break;
842bb6	1211	case ReqBlinkLED:
Q	1212	KMRunStat.bLEDFlick=nParam;
5dd1b7	1213	break;
Q	1214	case ReqStartDiag:
	1215	break;
	1216	case ReqStopDiag:
	1217	break;
	1218	case ReqTransFirmware:
	1219	break;
	1220	case ReqTransCfg:
	1221	break;
	1222	case ReqTransProg:
	1223	break;
	1224	case ReqTransData:
	1225	break;
	1226	case ReqTransBlink:
	1227	break;
	1228	case ReqTransChild:
	1229	break;
	1230	case ReqTransInfo:
	1231	break;
	1232	case ReqTransOutBandData:
	1233	break;
	1234	case ReqRead1Bit:
	1235	break;
	1236	case ReqWrite1Bit:
	1237	break;
	1238	case ReqReadBits:
	1239	break;
	1240	case ReqWriteBits:
	1241	break;
	1242	case ReqReadData:
	1243	break;
	1244	case ReqWriteData:
	1245	break;
	1246	case ReqRemoteTran:
	1247	break;
	1248
	1249	default:
	1250	iRet = -1;
	1251	break;
	1252	}
	1253	return iRet;
	1254	}