F030C8xx_KLink - Gitblit

QuakeGod

2023-02-01 7a2ff321965f1f24f3047fedd44a83f451f1f793

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