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