F030C8xx_KBus.git

QuakeGod

2023-02-01 2364f06313efb8eb97d4ae741a31cdd2efc175d2

提交 \| 用户 \| age
bfc108	1	/**
Q	2	******************************************************************************
	3	* @file : KMachine.c
	4	* @brief : KMachine program body
	5	******************************************************************************
	6	*/
	7
	8	#include "KMachine.h"
	9	#include "string.h"
	10	#include "Globaldef.h"
	11	#include "stm32f0xx_hal.h"
	12
	13	//#define OB_BASE ((uint32_t)0x1FFFF800U) /!< FLASH Option Bytes base address /
	14	//#define FLASHSIZE_BASE ((uint32_t)0x1FFFF7CCU) /!< FLASH Size register base address /
	15	//#define UID_BASE ((uint32_t)0x1FFFF7ACU) /!< Unique device ID register base address /
	16
	17
a7db3c	18	stStoredKMSysCfg storedKMSysCfg ;
bfc108	19	stKMem KMem;
Q	20	stRunStat KMRunStat;
	21
	22	//uint8_t * pFlash1 = (uint8_t *)(STORECFGBASE);
	23
	24	//void * pConfigFlashBase = (uint8_t *)(STORECFGBASE);
	25
	26	//uint16_t FlashDatas[16];
	27
	28	//uint32_t * pUID = (uint32_t *)(UID_BASE);
a7db3c	29	const stKMInfoBlock KMInfoBlock =
Q	30	{
0fe6b0	31	(BOARD_TYPE<<8) + BOARD_VER, //nDeviceType BOARD_VER, //nDevieVer
a7db3c	32	0x0100, //ProgVer
Q	33	0x0100, //KLinkVer
0fe6b0	34	0x0100, //KBusVer
7a2ff3	35	// 0x0100, //KNetVer
Q	36	// 0x0100, //KWLVer
0fe6b0	37
Q	38	4, //nCapacity1 ?K
	39	1, //nCapacity2 ?k
7a2ff3	40
Q	41	DINPUT, //nDInput;
	42	DOUTPUT, //nDOutput
	43
a7db3c	44	0, //nAInput
Q	45	0, //nAOutput
	46	0, //nHInput
	47	0, //nHOutput
	48	0, //nExt1;
	49	0, //nExt2;
0fe6b0	50	0, //nLogSize;
Q	51	0, //nPorts;
	52	0, //nManSize;
	53	0, //nAbility;
	54	6, //nSwitchBits;
a7db3c	55	};
Q	56	const char VersionStr[] __attribute__((at(FLASH_BASE + 0X1000))) //__attribute__((at(0X8001000)))
bfc108	57	= "3.00";
Q	58
a7db3c	59	const stStoredKMSysCfg KMDefaultSysCfg /__attribute__((at(STORECFGBASE)))/ =
bfc108	60	{
a7db3c	61	START_SIGN,
bfc108	62	0x0000,
a7db3c	63
Q	64	CFG_VER,
	65	0x0000,
	66	0x0000,
0fe6b0	67	0x0000,
bfc108	68	{
Q	69	{
	70	PortType_KLink, //PorttType
0fe6b0	71	1, //Station
Q	72	2304, //Buadrate = * 100;
	73	0, //ByteSize
bfc108	74	0, //Parity
Q	75	0, //StopBits
0fe6b0	76	0, //endType
bfc108	77	0, //EofChar
Q	78	0, //SofChar
0fe6b0	79	0, //endtime
Q	80	0, //recvbuf
	81	0, //bufsize
bfc108	82	},
Q	83	{
	84	PortType_KBus, //PorttType
0fe6b0	85	0, //Station
Q	86	2304, //Buadrate = * 100;
	87	0, //ByteSize
bfc108	88	0, //Parity
Q	89	0, //StopBits
0fe6b0	90	0, //endType
bfc108	91	0, //EofChar
Q	92	0, //SofChar
0fe6b0	93	0, //endtime
Q	94	0, //recvbuf
	95	0, //bufsize
bfc108	96	}
Q	97	},
	98	{{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0}},
	99	{{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}},
0fe6b0	100	{ //default port mapping
Q	101	0,0,0,0,0,0
	102	},
bfc108	103	0x0003,
Q	104	0x0004,
	105	0x0005,
	106	0x0006,
	107	0x0007,
	108	0x0008,
	109	0x0009,
	110	0x000a,
	111	0x000b,
	112	0x000c,
0fe6b0	113
bfc108	114	0x0011,
a7db3c	115	END_SIGN,
bfc108	116	};
Q	117
a7db3c	118	const stKMSysCfg KMDefaultSysCfg2[7] /__attribute__((at(STORECFGBASE+sizeof(stKMSysCfg))))/;
bfc108	119
a7db3c	120	int ReadFlashMem(void * pBuf, void * pAddrFlash, int nByteSize)
bfc108	121	{
Q	122	// memcpy(pBuf,pAddrFlash,nSize);
a7db3c	123	for (int i=0;i<nByteSize/4;i++)
bfc108	124	{
Q	125	((uint32_t )pBuf)[i] = ((uint32_t )pAddrFlash)[i];
	126	}
a7db3c	127	for (int i=nByteSize/4*2;i<nByteSize/2;i++)
bfc108	128	{
Q	129	((uint16_t )pBuf)[i] = ((uint16_t )pAddrFlash)[i];
	130	}
a7db3c	131	return nByteSize;
bfc108	132	}
Q	133	int EraseFlashMem(void * pAddrFlash, unsigned int Pages)
	134	{
	135	HAL_StatusTypeDef res;
	136	res = HAL_FLASH_Unlock();
	137	uint32_t ErrNo;
	138	FLASH_EraseInitTypeDef erase1;
	139	erase1.NbPages=Pages;
	140	erase1.PageAddress=(unsigned int)pAddrFlash;
	141	erase1.TypeErase=FLASH_TYPEERASE_PAGES;
	142	res = HAL_FLASHEx_Erase(&erase1,&ErrNo);
	143	res = HAL_FLASH_Lock();
	144	return res;
	145	}
a7db3c	146	int WriteToFlashMemNoErase(void * pBuf, void * pAddrFlash, unsigned int nByteSize)
bfc108	147	{
Q	148	HAL_StatusTypeDef res;
	149	res = HAL_FLASH_Unlock();
	150	/*
	151	for (int i=0;i<nSize/2;i++)
	152	{
	153	res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i2, ((uint16_t )pBuf)[i]);
	154	}
	155	*/
	156	///*
a7db3c	157	for (int i=0;i<nByteSize/4;i++)
bfc108	158	{
Q	159	res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, (uint32_t)pAddrFlash + i4, ((uint32_t )pBuf)[i]);
	160	}
	161
a7db3c	162	for (int i = nByteSize/4 * 2 ; i < nByteSize/2 ; i++)
bfc108	163	{
Q	164	res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i2, ((uint16_t )pBuf)[i]);
	165	}
	166	//*/
	167	res = HAL_FLASH_Lock();
	168
	169	return res;
	170	}
a7db3c	171	int EraseAndWriteToFlashMem(void * pBuf, void * pAddrFlash, unsigned int nByteSize)
bfc108	172	{
Q	173
	174	HAL_StatusTypeDef res;
	175	res = HAL_FLASH_Unlock();
	176	uint32_t ErrNo;
	177	FLASH_EraseInitTypeDef erase1;
	178	erase1.NbPages=1;
	179	erase1.PageAddress=(unsigned int)pAddrFlash;
	180	erase1.TypeErase=FLASH_TYPEERASE_PAGES;
	181	res = HAL_FLASHEx_Erase(&erase1,&ErrNo);
	182
a7db3c	183	for (int i=0;i<nByteSize/2;i++)
bfc108	184	{
Q	185	res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i2, ((uint16_t )pBuf)[i]);
	186	}
	187	/*
	188	for (int i=0;i<nSize/4;i++)
	189	{
	190	res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, (uint32_t)pAddrFlash + i4, ((uint32_t )pBuf)[i]);
	191	}
	192
	193	for (int i = nSize/4 * 2 ; i < nSize/2 ; i++)
	194	{
	195	res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i2, ((uint16_t )pBuf)[i]);
	196	}
	197	*/
	198	res = HAL_FLASH_Lock();
	199
	200	return res;
	201	}
	202
a7db3c	203	int ReadFactoryData(void * pDatabuf, int nByteCount)
bfc108	204	{
a7db3c	205	memcpy(pDatabuf,(stFactoryData *)FACTORY_DATA_BASE,nByteCount);
bfc108	206	return 0;
Q	207	}
a7db3c	208	int WriteFactoryData(void * pDataBuf, int nByteCount)
bfc108	209	{
0fe6b0	210	stFactoryData * p1 = (stFactoryData*) pDataBuf;
Q	211	stFactoryData * p2 = (stFactoryData *)FACTORY_DATA_BASE;
	212	p1->Seq1= p2->Seq1+1;
	213
a7db3c	214	EraseAndWriteToFlashMem(pDataBuf, (stFactoryData *)FACTORY_DATA_BASE,nByteCount);
Q	215	return 0;
	216	}
	217
	218	int ReadProgram(int nProgByteAddr, void *pBuf, int nByteSize, int nBank)
	219	{
	220	if (nBank==0) {
	221	ReadFlashMem(pBuf, (void *)(STORE_PRG_BASE+nProgByteAddr), nByteSize);
	222	}else if (nBank ==1) {
	223	ReadFlashMem(pBuf, (void *)(ALT_PRG_BASE+nProgByteAddr), nByteSize);
	224	}else if (KMRunStat.nBinProgBank==0) {
	225	ReadFlashMem(pBuf, (void *)(STORE_PRG_BASE+nProgByteAddr), nByteSize);
	226	} else {
	227	ReadFlashMem(pBuf, (void *)(ALT_PRG_BASE+nProgByteAddr), nByteSize);
	228	}
	229	return 0;
	230	}
	231	int WriteProgram(int nProgAddress, void * pBuf, int nByteSize, int nBank)
	232	{
	233	// Program Save Address;//
	234	// Program 2 Save Address; //
	235	void * progByteAddr;
	236	if (nBank == 0) {
	237	progByteAddr=(void *)(STORE_PRG_BASE+nProgAddress);
	238	}else if (nBank==1) {
	239	progByteAddr=(void *)(ALT_PRG_BASE+nProgAddress);
	240	} else if (KMRunStat.nBinProgBank==0) {
	241	progByteAddr=(void *)(ALT_PRG_BASE+nProgAddress);
	242	}else{
	243	progByteAddr=(void *)(STORE_PRG_BASE+nProgAddress);
	244	}
	245	if (nProgAddress ==0) {
	246	EraseAndWriteToFlashMem(pBuf, progByteAddr, nByteSize);
	247	}else{
	248	WriteToFlashMemNoErase(pBuf, progByteAddr, nByteSize);
	249	}
	250	return 0;
	251	}
	252
	253	int LoadDefaultSysCfg(pStoredKMSysCfg theStoredKMSysCfg)
	254	{
	255	memcpy(theStoredKMSysCfg,&KMDefaultSysCfg,sizeof(stKMSysCfg));
	256	return 0;
	257	}
	258	int ReadSysCfgFromFlash(pStoredKMSysCfg theStoredKMSysCfg)
	259	{
	260	pStoredKMSysCfg pStoreKMSysCfg = (pStoredKMSysCfg)(STORE_SYSREG_BASE);
bfc108	261	// find latest Store Cfg
Q	262	int nIndex=-1;
	263	int nMaxSeq=-1;
	264	for (int i=0;i<8;i++)
	265	{
a7db3c	266	if (pStoreKMSysCfg->Sign1 == START_SIGN && pStoreKMSysCfg->EndSign1 == END_SIGN)
bfc108	267	{
Q	268	if (pStoreKMSysCfg->Seq1 > nMaxSeq)
	269	{
	270	nIndex=i;nMaxSeq=pStoreKMSysCfg->Seq1;
	271	}
	272	}
	273	}
	274	if (nIndex>=0 && nIndex <8)
	275	{
a7db3c	276	ReadFlashMem(theStoredKMSysCfg,(void *)(&pStoreKMSysCfg[nIndex]),sizeof(stStoredKMSysCfg));
bfc108	277	}else {
a7db3c	278	LoadDefaultSysCfg(theStoredKMSysCfg);
bfc108	279	}
Q	280	//memcpy(theKMSysCfg,(void* )STORECFGBASE,sizeof(KMSysCfg));
	281	return 0;
	282	}
	283
a7db3c	284	int WriteSysCfgToFlash(pStoredKMSysCfg theStoredKMSysCfg)
bfc108	285	{
a7db3c	286	theStoredKMSysCfg->Seq1++;
Q	287	// theKMSysCfg->cfgvar16++;
bfc108	288	// find the next empty space to write
Q	289	int nIndex=-1;
	290	int s2=128;
	291	for (int i=0;i<8;i++)
	292	{
	293	int skip=0;
	294	unsigned char * nAddr2=(unsigned char )(STORE_SYSREG_BASE+is2);
	295	for (int j=0;j<s2;j++)
	296	{
	297	if ((nAddr2)[j] != 0xff) {skip =1;break;}
	298	}
	299	if (skip==1) {continue;}
	300	nIndex=i;
	301	break;
	302	}
	303	if (nIndex >=0 && nIndex <8) {
a7db3c	304	WriteToFlashMemNoErase(theStoredKMSysCfg,(void )(STORE_SYSREG_BASE + nIndexs2),sizeof(theStoredKMSysCfg));
bfc108	305	}
Q	306	else {
a7db3c	307	EraseAndWriteToFlashMem(theStoredKMSysCfg,(void *)STORE_SYSREG_BASE,sizeof(theStoredKMSysCfg));
bfc108	308	}
Q	309	return 0;
	310	}
	311
	312	int is_pow_of_2(uint32_t x) {
	313	return !(x & (x-1));
	314	}
	315
	316	uint32_t next_pow_of_2(uint32_t x)
	317	{
	318	if ( is_pow_of_2(x) )
	319	return x;
	320	x \|= x>>1;
	321	x \|= x>>2;
	322	x \|= x>>4;
	323	x \|= x>>8;
	324	x \|= x>>16;
	325	return x+1;
	326	}
	327
	328	//uint8_t * pFlash1;
	329	/*
	330	stStoreCfg * GetCurStoreCfgAddr(void )
	331	{
	332	int s = sizeof(stStoreCfg);
	333	int s2=next_pow_of_2(s);
	334	stStoreCfg * p1;
	335	int nMaxSN=0;
	336	int nMaxId=0;
	337	for (int i=0; s2*i < STORECFGPAGESIZE ; i++)
	338	{
	339	p1= (stStoreCfg )(STORECFGBASE + s2 i );
	340	if (p1->Sign1 != START_SIGN) continue;
	341	if (p1->EndSign1 != END_SIGN) continue;
	342
	343	if (p1->Seq1 >= nMaxSN) {nMaxSN = p1->Seq1; nMaxId = i;}
	344	}
	345	// nMaxId=nMaxId+1;
	346	return (stStoreCfg )(STORECFGBASE + s2 nMaxId);
	347	}
	348
	349	stStoreCfg * GetNextStoreCfgAddr(stStoreCfg * CurCfg )
	350	{
	351	int s = sizeof(stStoreCfg);
	352	int s2=next_pow_of_2(s);
	353	uint32_t nAddr1 = (uint32_t) CurCfg;
	354	uint32_t nAddr2 = nAddr1 + s2;
	355	for (int i=1;i<33;i++)
	356	{
	357	int skip=0;
	358	nAddr2 = nAddr1 + s2*i;
	359	if ((nAddr2 + s) > STORECFGBASE + STORECFGPAGESIZE)
	360	{
	361	nAddr2=STORECFGBASE; break;
	362	}
	363	for (int j=0;j<s2;j++)
	364	{
	365	if (((unsigned char *)nAddr2)[j] != 0xff)
	366	{skip =1;}
	367	}
	368	if (skip==1) {continue;}
	369	break;
	370	}
	371	stStoreCfg * p1 = (stStoreCfg *)nAddr2;
	372	return p1;
	373	}
	374
	375
	376	int SaveStoreCfg(stStoreCfg * CurCfg)
	377	{
	378	return 0;
	379	}
	380	*/
	381	// stStoreCfg Cfg2;
	382
	383	int LoadFlashDatas()
	384	{
	385	for (int i=0;i<16;i++)
	386	{
	387	// FlashDatas[i]=((uint16_t *)pConfigFlashBase)[i];
	388	}
	389	return 0;
	390	}
	391	/*
	392	int LoadAndUpdateStoreCfg()
	393	{
	394	stStoreCfg * pFCfg = (stStoreCfg *) GetCurStoreCfgAddr();
	395
	396	Cfg2.Sign1=START_SIGN;
	397	Cfg2.Seq1=pFCfg[0].Seq1+1;
	398	Cfg2.CRC1=0x7777;
	399	Cfg2.PowerCount=pFCfg[0].PowerCount+1;
	400	Cfg2.UpTime=pFCfg[0].UpTime+1;
	401	Cfg2.UserData1=pFCfg[0].UserData1;
	402	Cfg2.EndSign1=END_SIGN;
	403	stStoreCfg * pFCfg2 = GetNextStoreCfgAddr(pFCfg);
	404
	405
	406	HAL_StatusTypeDef res;
	407	if (pFCfg2 <= pFCfg)
	408	{
	409	res = (HAL_StatusTypeDef)EraseAndWriteToFlashMem(&Cfg2,pFCfg2,sizeof(stStoreCfg));
	410
	411	}else
	412	{
	413	res = (HAL_StatusTypeDef)WriteToFlashMemNoErase(&Cfg2,pFCfg2,sizeof(stStoreCfg));
	414	}
	415	return res;
	416	}
	417	*/
	418	int CheckSavedData(void * pStartAddr, int PageSize, int Pages, int DataSize)
	419	{
	420	return 0;
	421	};
	422
	423
	424	int nMaxRunStatIndex=-1;
	425	unsigned int nMaxRunStatSeq=0;
	426	int nNextRunStatSpace=0;
	427	int LoadDefaultRunStat(pRunStat theRunStat)
	428	{
	429	return 0;
	430	}
	431	int LoadRunStat(pRunStat theRunStat)
	432	{
	433	uchar * pRunStatStore = (uchar *)STORE_RUNSTAT_BASE;
	434	pRunStat pStoreRunStats = (pRunStat)pRunStatStore;
	435	// int s = sizeof(stRunStat);
	436
	437	for (int i=0;i * sizeof(stRunStat) < (STORE_RUNSTAT_PAGESIZE * STORE_RUNSTAT_PAGES) ;i++)
	438	{
	439	if (pStoreRunStats[i].Sign1 == START_SIGN )
	440	{
	441	if (pStoreRunStats[i].Seq1 > nMaxRunStatSeq)
	442	{
	443	nMaxRunStatSeq = pStoreRunStats[i].Seq1;
	444	nMaxRunStatIndex=i;
	445	nNextRunStatSpace=i+1;
	446	}
	447	}
	448	}
	449	if (nMaxRunStatIndex>=0) // && nMaxRunStatIndex <8)
	450	{
	451	ReadFlashMem(theRunStat,(void *)(pStoreRunStats+nMaxRunStatIndex),sizeof(stRunStat));
	452	}else {
	453	LoadDefaultRunStat(theRunStat);
	454	}
	455	// find Next Space
	456	// if Same Page with MaxSeq Index, then not erase, skip and skip.
	457	// if next Page of MaxSeq Index, then earse if not empty;
	458	if ((nNextRunStatSpace + 1) * sizeof(stRunStat) > STORE_RUNSTAT_PAGESIZE * STORE_RUNSTAT_PAGES) {
	459	nNextRunStatSpace=0;
	460	}
	461	return 0;
	462	}
	463
	464	int SaveRunStat(pRunStat theRunStat)
	465	{
	466	nMaxRunStatSeq++;
	467	theRunStat->Sign1=START_SIGN;
	468	theRunStat->Seq1 = nMaxRunStatSeq;
	469	theRunStat->PowerCount=KMem.PwrOnCount;
	470	theRunStat->UpTime=KMem.TotalRunTime;
	471	theRunStat->CRC1=0x11;
	472	theRunStat->EndSign1=END_SIGN;
	473
	474	//check empty
	475	unsigned char pFlash = (unsigned char )(STORE_RUNSTAT_BASE + nNextRunStatSpace*sizeof(stRunStat));
	476	int Skip=0;
	477	for (int j=0;j<sizeof(stRunStat);j++)
	478	{
	479	if (pFlash[j]!=0xff) {Skip =1 ; break;}
	480	}
	481	if (Skip ==0 )
	482	{
	483	WriteToFlashMemNoErase(theRunStat,(void )(STORE_RUNSTAT_BASE + nNextRunStatSpacesizeof(stRunStat)),sizeof(stRunStat));
	484	}else
	485	{
	486	EraseAndWriteToFlashMem(theRunStat,(void )(STORE_RUNSTAT_BASE + nNextRunStatSpacesizeof(stRunStat)),sizeof(stRunStat));
	487	}
	488	nMaxRunStatIndex=nNextRunStatSpace;
	489	nNextRunStatSpace++;
	490	if ((nNextRunStatSpace+1) * sizeof(stRunStat) > STORE_RUNSTAT_PAGESIZE * STORE_RUNSTAT_PAGES)
	491	{
	492	nNextRunStatSpace=0;
	493	}
	494	return 0;
	495	}
	496
	497
	498	int nEventCount=0;
	499	int nEventMinIndex;
	500	int nEventMaxIndex;
	501	unsigned int nEventMaxSeq=0;
	502	int nEventNextSpace;
	503	int nMaxCurTime=0;
a7db3c	504	volatile int PowerDownEvent=0;
Q	505	volatile int OldPowerDownEvent=0;
	506	volatile int OldPowerDownEventTime=0;
	507
bfc108	508	int CheckEventLog()
Q	509	{
	510	unsigned int nMinEventSeq=999999999;
	511	uchar * pEventStore = (uchar *)STORE_LOG_BASE;
	512	pEventLog theEventLog = (pEventLog) pEventStore;
	513	// int s = sizeof(stEventLog);
	514	nEventCount=0;
	515
	516	for (int i=0;i * sizeof(stEventLog) < (STORE_LOG_PAGESIZE * STORE_LOG_PAGES) ;i++)
	517	{
	518	if (theEventLog[i].Sign1 == START_SIGN )
	519	{
	520	nEventCount++;
	521	if (theEventLog[i].Seq1 > nEventMaxSeq)
	522	{
	523	nEventMaxSeq = theEventLog[i].Seq1;
	524	nEventMaxIndex=i;
	525	nMaxCurTime=theEventLog[i].nTime;
	526	nEventNextSpace=i+1;
	527	}
	528	if (theEventLog[i].Seq1 < nMinEventSeq)
	529	{
	530	nMinEventSeq = theEventLog[i].Seq1;
	531	nEventMinIndex = i;
	532	}
	533	}
	534	}
	535	// find Next Space
	536	// if Same Page with MaxSeq Index, then not erase, skip and skip.
	537	// if next Page of MaxSeq Index, then earse if not empty;
	538	if ((nEventNextSpace + 1) * sizeof(stEventLog) > STORE_LOG_PAGESIZE * STORE_LOG_PAGES) {
	539	nEventNextSpace=0;
	540	}
	541
	542	return nEventCount;
	543	}
	544
	545	int AddEventLog(uint32_t nTime, USHORT nEvent, USHORT nParam1, UINT nParam2)
	546	{
	547	nEventMaxSeq++;
	548	stEventLog thisEventLog={START_SIGN, nEventMaxSeq, nTime,nEvent,nParam1,nParam2};
	549	//check empty
	550	unsigned char pFlash = (unsigned char )(STORE_LOG_BASE + nEventNextSpace*sizeof(stEventLog));
	551	int Skip=0;
	552	for (int j=0;j<sizeof(stEventLog);j++)
	553	{
	554	if (pFlash[j]!=0xff) {Skip =1 ; break;}
	555	}
	556	if (Skip ==0 )
	557	{
	558	WriteToFlashMemNoErase(&thisEventLog,(void )(STORE_LOG_BASE + nEventNextSpacesizeof(stEventLog)),sizeof(stEventLog));
	559	}else
	560	{
	561	EraseAndWriteToFlashMem(&thisEventLog,(void )(STORE_LOG_BASE + nEventNextSpacesizeof(stEventLog)),sizeof(stEventLog));
	562
	563	}
	564	nEventMaxIndex=nEventNextSpace;
	565	nEventNextSpace++;
	566	if ((nEventNextSpace+1) * sizeof(stEventLog) > STORE_LOG_PAGESIZE * STORE_LOG_PAGES)
	567	{
	568	nEventNextSpace=0;
	569	}
	570	nEventCount++;
	571	KMem.nEventCount=nEventCount;
	572	return 0;
	573	}
	574
	575	pEventLog GetEventLogAddr(int nIndex)
	576	{
	577	int nEventIndex=nEventMinIndex + nIndex;
	578
	579	if (nEventIndex * sizeof(stEventLog) >= (STORE_LOG_PAGESIZE * STORE_LOG_PAGES))
	580	{
	581	nEventIndex -= (STORE_LOG_PAGESIZE * STORE_LOG_PAGES)/sizeof(stEventLog);
	582	}
	583	unsigned char pFlash = (unsigned char )(STORE_LOG_BASE + nEventIndex*sizeof(stEventLog));
	584
	585	return (pEventLog)pFlash;
	586	}
	587
	588	int ClearEventLog(void)
	589	{
	590	EraseFlashMem((void *)STORE_LOG_BASE,STORE_LOG_PAGES);
	591	nEventMinIndex=0;
	592	nEventMaxIndex=0;
	593	nEventMaxSeq=0;
	594	nEventCount=0;
	595	nEventNextSpace=0;
	596	return 0;
	597	}
	598	int KMachineInit(void)
	599	{
	600	// ClearEventLog();
	601	CheckEventLog();
	602	LoadRunStat(&KMRunStat);
	603	KMem.CurTimeSec=nMaxCurTime;
	604	KMem.TotalRunTime=KMRunStat.UpTime;
	605	KMRunStat.PowerCount++;
	606	KMem.PwrOnCount=KMRunStat.PowerCount;
	607	SaveRunStat(&KMRunStat);
	608	KMem.SDD[15]=nMaxRunStatIndex;
	609	KMem.SDD[16]=nMaxRunStatSeq;
	610	KMem.SDD[17]=nNextRunStatSpace;
	611
	612
	613	AddEventLog(KMem.CurTimeSec,EventTypePowerUp,1,12345);
	614	KMem.SDD[19]=nEventCount;
	615	KMem.SDD[20]=nEventMinIndex;
	616	KMem.SDD[21]=nEventMaxIndex;
	617	KMem.SDD[22]=nEventMaxSeq;
	618	KMem.SDD[23]=nEventNextSpace;
	619
	620	return 0;
	621	}
a7db3c	622
Q	623	inline void SetAddrBit(unsigned short * pW, unsigned char bitAddr)
	624	{
	625	(*pW)\|=1<<(bitAddr&0xf);
	626	}
	627
	628	inline void ResetBit(unsigned short * pW, unsigned char bitAddr)
	629	{
	630	(*pW)&=~(1<<(bitAddr&0xf));
	631	}
	632
	633	static inline void SetBitValue(unsigned short * pW, unsigned char bitAddr, unsigned char Value)
	634	{
	635	if (Value) { SetAddrBit(pW, bitAddr);}
	636	else {ResetBit(pW, bitAddr);}
	637	}
	638
	639	static inline unsigned char GetBitValue(unsigned short W, unsigned char bitAddr)
	640	{
	641	if (W&(1<<(bitAddr&0xf))) return 1;
	642	else return 0;
	643	}
	644
	645
	646	unsigned char GetCoilValue(unsigned char nCoilType, unsigned short nCoilAddr)
	647	{
	648	unsigned char thisValue=0;
	649	unsigned short nWordAddr=(nCoilAddr&0xff0)>>4;
	650	unsigned char nBitAddr=nCoilAddr&0xf;
	651	switch(nCoilType)
	652	{
	653	case KLCoilTypeX:
	654	if (nCoilAddr >= KLCoilXCount) return 0;
	655	thisValue = GetBitValue(KMem.WX[nWordAddr], nBitAddr);
	656	break;
	657	case KLCoilTypeY:
	658	if (nCoilAddr >= KLCoilYCount) return 0;
	659	thisValue = GetBitValue(KMem.WY[nWordAddr], nBitAddr);
	660	break;
	661	case KLCoilTypeR:
	662	if (nCoilAddr >= KLCoilRCount) return 0;
	663	thisValue = GetBitValue(KMem.WR[nWordAddr], nBitAddr);
	664	break;
	665	case KLCoilTypeLX:
	666	if (nCoilAddr >= KLCoilLXCount) return 0;
	667	thisValue = GetBitValue(KMem.WLX[nWordAddr], nBitAddr);
	668	break;
	669	case KLCoilTypeLY:
	670	if (nCoilAddr >= KLCoilLYCount) return 0;
	671	thisValue = GetBitValue(KMem.WLY[nWordAddr], nBitAddr);
	672	break;
	673	case KLCoilTypeT:
	674	if (nCoilAddr >= KLCoilTCount) return 0;
	675	thisValue = GetBitValue(KMem.WT[nWordAddr], nBitAddr);
	676	break;
	677	case KLCoilTypeC:
	678	if (nCoilAddr >= KLCoilCCount) return 0;
	679	thisValue = GetBitValue(KMem.WC[nWordAddr], nBitAddr);
	680	break;
	681	case KLCoilTypeLR:
	682	if (nCoilAddr >= KLCoilLRCount) return 0;
	683	thisValue = GetBitValue(KMem.WLR[nWordAddr], nBitAddr);
	684	break;
	685	case KLCoilTypeSR:
	686	if (nCoilAddr >= KLCoilSRCount) return 0;
	687	thisValue = GetBitValue(KMem.WSR[nWordAddr], nBitAddr);
	688	break;
	689	default:
	690	break;
	691	}
	692	return thisValue;
	693	}
	694	int SetCoilValue(unsigned char nCoilType, unsigned short nCoilAddr, unsigned char nCoilValue)
	695	{
	696	unsigned short nWordAddr=(nCoilAddr&0xff0)>>4;
	697	unsigned char nBitAddr=nCoilAddr&0xf;
	698	switch(nCoilType)
	699	{
	700	case KLCoilTypeX:
	701	if (nCoilAddr >= KLCoilXCount) return 0;
	702	SetBitValue(&KMem.WX[nWordAddr], nBitAddr, nCoilValue);
	703	break;
	704	case KLCoilTypeY:
	705	if (nCoilAddr >= KLCoilYCount) return 0;
	706	SetBitValue(&KMem.WY[nWordAddr], nBitAddr, nCoilValue);
	707	break;
	708	case KLCoilTypeR:
	709	if (nCoilAddr >= KLCoilRCount) return 0;
	710	SetBitValue(&KMem.WR[nWordAddr], nBitAddr, nCoilValue);
	711	break;
	712	case KLCoilTypeLX:
	713	if (nCoilAddr >= KLCoilLXCount) return 0;
	714	SetBitValue(&KMem.WLX[nWordAddr], nBitAddr, nCoilValue);
	715	break;
	716	case KLCoilTypeLY:
	717	if (nCoilAddr >= KLCoilLYCount) return 0;
	718	SetBitValue(&KMem.WLY[nWordAddr], nBitAddr, nCoilValue);
	719	break;
	720	case KLCoilTypeT:
	721	if (nCoilAddr >= KLCoilTCount) return 0;
	722	SetBitValue(&KMem.WT[nWordAddr], nBitAddr, nCoilValue);
	723	break;
	724	case KLCoilTypeC:
	725	if (nCoilAddr >= KLCoilCCount) return 0;
	726	SetBitValue(&KMem.WC[nWordAddr], nBitAddr, nCoilValue);
	727	break;
	728	case KLCoilTypeLR:
	729	if (nCoilAddr >= KLCoilLRCount) return 0;
	730	SetBitValue(&KMem.WLR[nWordAddr], nBitAddr, nCoilValue);
	731	break;
	732	case KLCoilTypeSR:
	733	if (nCoilAddr >= KLCoilSRCount) return 0;
	734	SetBitValue(&KMem.WSR[nWordAddr], nBitAddr, nCoilValue);
	735	break;
	736	default:
	737	break;
	738	}
	739	return 0;
	740	}
	741
	742	int GetVarData(int nDataType, int nDataAddr)
	743	{
	744	// TODO: ?????????.
	745	int thisValue = 0;
	746
	747	switch (nDataType)
	748	{
	749	case KLDataTypeDEC:
	750	case KLDataTypeHEX:
	751	thisValue = nDataAddr;
	752	break;
	753	case KLDataTypeWX:
	754	if (nDataAddr >= KLDataWXCount) return 0;
	755	thisValue = KMem.WX[nDataAddr];
	756	break;
	757	case KLDataTypeWY:
	758	if (nDataAddr >= KLDataWYCount) return 0;
	759	thisValue = KMem.WY[nDataAddr];
	760	break;
	761	case KLDataTypeWR:
	762	if (nDataAddr >= KLDataWRCount) return 0;
	763	thisValue = KMem.WR[nDataAddr];
	764	break;
	765	case KLDataTypeWLX:
	766	if (nDataAddr >= KLDataWLCount) return 0;
	767	thisValue = KMem.WLX[nDataAddr];
	768	break;
	769	case KLDataTypeWLY:
	770	if (nDataAddr >= KLDataWLCount) return 0;
	771	thisValue = KMem.WLY[nDataAddr];
	772	break;
	773	case KLDataTypeDT:
	774	if (nDataAddr >= KLDataDTCount) return 0;
	775	thisValue = (signed short)KMem.DT[nDataAddr];
	776	break;
	777	case KLDataTypeSDT:
	778	if (nDataAddr >= KLDataSDTCount) return 0;
	779	thisValue = KMem.SDT[nDataAddr];
	780	break;
	781	case KLDataTypeWSR:
	782	if (nDataAddr >= KLCoilLRCount) return 0;
	783	thisValue = KMem.WSR[nDataAddr];
	784	break;
	785	case KLDataTypeSV:
	786	if (nDataAddr >= KLDataSVCount) return 0;
	787	thisValue = KMem.SV[nDataAddr];
	788	break;
	789	case KLDataTypeEV:
	790	if (nDataAddr >= KLDataEVCount) return 0;
	791	thisValue = KMem.EV[nDataAddr];
	792	break;
	793	case KLDataTypeLD:
	794	if (nDataAddr >= KLDataLDCount) return 0;
	795	thisValue = KMem.DT[nDataAddr];
	796	break;
	797	case KLDataSysCfg:
	798	if (nDataAddr >= KLCoilSRCount) return 0;
	799	thisValue = KMem.SDT[nDataAddr];
	800	break;
	801	case KLDataTypeFlash:
	802	if (nDataAddr >= KLCoilSRCount) return 0;
	803	thisValue = KMem.SDT[nDataAddr];
	804	break;
	805	case KLDataTypeTest:
	806	if (nDataAddr >= KLCoilSRCount) return 0;
	807	thisValue = KMem.SDT[nDataAddr];
	808	break;
	809	}
	810	return thisValue;
	811	}
	812
	813
	814	int SetVarData(int nDataType, int nDataAddr, int nDataValue)
	815	{
	816	// TODO: ?????????.
	817	switch (nDataType)
	818	{
	819	// case KLDataTypeDEC:
	820	// case KLDataTypeHEX:
	821	// break;
	822	case KLDataTypeWX:
	823	if (nDataAddr >= KLDataWXCount) return 0;
	824	KMem.WX[nDataAddr] = nDataValue;
	825	break;
	826	case KLDataTypeWY:
	827	if (nDataAddr >= KLDataWYCount) return 0;
	828	KMem.WY[nDataAddr] = nDataValue;
	829	break;
	830	case KLDataTypeWR:
	831	if (nDataAddr >= KLDataWRCount) return 0;
	832	KMem.WR[nDataAddr] = nDataValue;
	833	break;
	834	case KLDataTypeWLX:
	835	if (nDataAddr >= KLDataWLCount) return 0;
	836	KMem.WLX[nDataAddr] = nDataValue;
	837	break;
	838	case KLDataTypeWLY:
	839	if (nDataAddr >= KLDataWLCount) return 0;
	840	KMem.WLY[nDataAddr] = nDataValue;
	841	break;
	842	case KLDataTypeDT:
	843	if (nDataAddr >= KLDataDTCount) return 0;
	844	KMem.DT[nDataAddr] = nDataValue;
	845	break;
	846	case KLDataTypeSDT:
	847	if (nDataAddr >= KLDataSDTCount) return 0;
	848	KMem.SDT[nDataAddr] = nDataValue;
	849	break;
	850	case KLDataTypeWSR:
	851	if (nDataAddr >= KLCoilLRCount) return 0;
	852	KMem.WSR[nDataAddr] = nDataValue;
	853	break;
	854	case KLDataTypeSV:
	855	if (nDataAddr >= KLDataSVCount) return 0;
	856	KMem.SV[nDataAddr] = nDataValue;
	857	break;
	858	case KLDataTypeEV:
	859	if (nDataAddr >= KLDataEVCount) return 0;
	860	KMem.EV[nDataAddr] = nDataValue;
	861	break;
	862	case KLDataTypeLD:
	863	if (nDataAddr >= KLDataLDCount) return 0;
	864	KMem.DT[nDataAddr] = nDataValue;
	865	break;
	866	case KLDataSysCfg:
	867	if (nDataAddr >= KLCoilSRCount) return 0;
	868	KMem.SDT[nDataAddr] = nDataValue;
	869	break;
	870	case KLDataTypeFlash:
	871	if (nDataAddr >= KLCoilSRCount) return 0;
	872	KMem.SDT[nDataAddr] = nDataValue;
	873	break;
	874	case KLDataTypeTest:
	875	if (nDataAddr >= KLCoilSRCount) return 0;
	876	KMem.SDT[nDataAddr] = nDataValue;
	877	break;
	878	}
	879
	880	return 0;
	881	}
	882