/**
|
******************************************************************************
|
* @file : KMachine.c
|
* @brief : KMachine program body
|
******************************************************************************
|
*/
|
|
#include "KMachine.h"
|
#include "string.h"
|
#include "Globaldef.h"
|
#include "stm32f0xx_hal.h"
|
|
//#define OB_BASE ((uint32_t)0x1FFFF800U) /*!< FLASH Option Bytes base address */
|
//#define FLASHSIZE_BASE ((uint32_t)0x1FFFF7CCU) /*!< FLASH Size register base address */
|
//#define UID_BASE ((uint32_t)0x1FFFF7ACU) /*!< Unique device ID register base address */
|
|
|
stKMSysCfg KMSysCfg ;
|
stKMem KMem;
|
stRunStat KMRunStat;
|
|
//uint8_t * pFlash1 = (uint8_t *)(STORECFGBASE);
|
|
//void * pConfigFlashBase = (uint8_t *)(STORECFGBASE);
|
|
//uint16_t FlashDatas[16];
|
|
//uint32_t * pUID = (uint32_t *)(UID_BASE);
|
|
const char VersionStr[] __attribute__((at(0X8001000)))
|
= "3.00";
|
|
const stKMSysCfg KMStoreSysCfg /*__attribute__((at(STORECFGBASE)))*/ =
|
{
|
0x55aa,
|
0x0000,
|
0x00000000,
|
{
|
{
|
PortType_KLink, //PorttType
|
1, //ByteSize
|
0, //Parity
|
0, //StopBits
|
0, //EofChar
|
0, //SofChar
|
2304, //Buadrate * 100;
|
},
|
{
|
PortType_KBus, //PorttType
|
1, //ByteSize
|
0, //Parity
|
0, //StopBits
|
0, //EofChar
|
0, //SofChar
|
2304, //Buadrate * 100;
|
}
|
},
|
{{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0}},
|
{{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1}},
|
0x0003,
|
0x0004,
|
0x0005,
|
0x0006,
|
0x0007,
|
0x0008,
|
0x0009,
|
0x000a,
|
0x000b,
|
0x000c,
|
0x000d,
|
0x000e,
|
0x000f,
|
0x0010,
|
{0},
|
0x0011,
|
0x5aa5,
|
};
|
|
const stKMSysCfg KMStoreSysCfg2[7] /*__attribute__((at(STORECFGBASE+sizeof(stKMSysCfg))))*/;
|
|
int ReadFlashMem(void * pBuf, void * pAddrFlash, int nSize)
|
{
|
// memcpy(pBuf,pAddrFlash,nSize);
|
for (int i=0;i<nSize/4;i++)
|
{
|
((uint32_t *)pBuf)[i] = ((uint32_t *)pAddrFlash)[i];
|
}
|
for (int i=nSize/4*2;i<nSize/2;i++)
|
{
|
((uint16_t *)pBuf)[i] = ((uint16_t *)pAddrFlash)[i];
|
}
|
return nSize;
|
}
|
int EraseFlashMem(void * pAddrFlash, unsigned int Pages)
|
{
|
HAL_StatusTypeDef res;
|
res = HAL_FLASH_Unlock();
|
uint32_t ErrNo;
|
FLASH_EraseInitTypeDef erase1;
|
erase1.NbPages=Pages;
|
erase1.PageAddress=(unsigned int)pAddrFlash;
|
erase1.TypeErase=FLASH_TYPEERASE_PAGES;
|
res = HAL_FLASHEx_Erase(&erase1,&ErrNo);
|
res = HAL_FLASH_Lock();
|
return res;
|
}
|
int WriteToFlashMemNoErase(void * pBuf, void * pAddrFlash, unsigned int nSize)
|
{
|
HAL_StatusTypeDef res;
|
res = HAL_FLASH_Unlock();
|
/*
|
for (int i=0;i<nSize/2;i++)
|
{
|
res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i*2, ((uint16_t *)pBuf)[i]);
|
}
|
*/
|
///*
|
for (int i=0;i<nSize/4;i++)
|
{
|
res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, (uint32_t)pAddrFlash + i*4, ((uint32_t *)pBuf)[i]);
|
}
|
|
for (int i = nSize/4 * 2 ; i < nSize/2 ; i++)
|
{
|
res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i*2, ((uint16_t *)pBuf)[i]);
|
}
|
//*/
|
res = HAL_FLASH_Lock();
|
|
return res;
|
}
|
int EraseAndWriteToFlashMem(void * pBuf, void * pAddrFlash, unsigned int nSize)
|
{
|
|
HAL_StatusTypeDef res;
|
res = HAL_FLASH_Unlock();
|
uint32_t ErrNo;
|
FLASH_EraseInitTypeDef erase1;
|
erase1.NbPages=1;
|
erase1.PageAddress=(unsigned int)pAddrFlash;
|
erase1.TypeErase=FLASH_TYPEERASE_PAGES;
|
res = HAL_FLASHEx_Erase(&erase1,&ErrNo);
|
|
for (int i=0;i<nSize/2;i++)
|
{
|
res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i*2, ((uint16_t *)pBuf)[i]);
|
}
|
/*
|
for (int i=0;i<nSize/4;i++)
|
{
|
res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, (uint32_t)pAddrFlash + i*4, ((uint32_t *)pBuf)[i]);
|
}
|
|
for (int i = nSize/4 * 2 ; i < nSize/2 ; i++)
|
{
|
res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)pAddrFlash + i*2, ((uint16_t *)pBuf)[i]);
|
}
|
*/
|
res = HAL_FLASH_Lock();
|
|
return res;
|
}
|
|
int LoadDefaultSysCfg(pKMSysCfg theKMSysCfg)
|
{
|
memcpy(theKMSysCfg,&KMStoreSysCfg,sizeof(stKMSysCfg));
|
return 0;
|
}
|
int ReadSysCfgFromFlash(pKMSysCfg theKMSysCfg)
|
{
|
pKMSysCfg pStoreKMSysCfg = (pKMSysCfg)(STORE_SYSREG_BASE);
|
// find latest Store Cfg
|
int nIndex=-1;
|
int nMaxSeq=-1;
|
for (int i=0;i<8;i++)
|
{
|
if (pStoreKMSysCfg->Sign1 == 0x55aa && pStoreKMSysCfg->EndSign1 == 0x5aa5)
|
{
|
if (pStoreKMSysCfg->Seq1 > nMaxSeq)
|
{
|
nIndex=i;nMaxSeq=pStoreKMSysCfg->Seq1;
|
}
|
}
|
}
|
if (nIndex>=0 && nIndex <8)
|
{
|
ReadFlashMem(theKMSysCfg,(void *)(pStoreKMSysCfg+nIndex),sizeof(stKMSysCfg));
|
}else {
|
LoadDefaultSysCfg(theKMSysCfg);
|
}
|
//memcpy(theKMSysCfg,(void* )STORECFGBASE,sizeof(KMSysCfg));
|
return 0;
|
}
|
|
int WriteSysCfgToFlash(pKMSysCfg theKMSysCfg)
|
{
|
theKMSysCfg->Seq1++;
|
theKMSysCfg->cfgvar16++;
|
// find the next empty space to write
|
int nIndex=-1;
|
int s2=128;
|
for (int i=0;i<8;i++)
|
{
|
int skip=0;
|
unsigned char * nAddr2=(unsigned char *)(STORE_SYSREG_BASE+i*s2);
|
for (int j=0;j<s2;j++)
|
{
|
if ((nAddr2)[j] != 0xff) {skip =1;break;}
|
}
|
if (skip==1) {continue;}
|
nIndex=i;
|
break;
|
}
|
if (nIndex >=0 && nIndex <8) {
|
WriteToFlashMemNoErase(theKMSysCfg,(void *)(STORE_SYSREG_BASE + nIndex*s2),sizeof(KMSysCfg));
|
}
|
else {
|
EraseAndWriteToFlashMem(theKMSysCfg,(void *)STORE_SYSREG_BASE,sizeof(KMSysCfg));
|
}
|
return 0;
|
}
|
|
int is_pow_of_2(uint32_t x) {
|
return !(x & (x-1));
|
}
|
|
uint32_t next_pow_of_2(uint32_t x)
|
{
|
if ( is_pow_of_2(x) )
|
return x;
|
x |= x>>1;
|
x |= x>>2;
|
x |= x>>4;
|
x |= x>>8;
|
x |= x>>16;
|
return x+1;
|
}
|
|
//uint8_t * pFlash1;
|
/*
|
stStoreCfg * GetCurStoreCfgAddr(void )
|
{
|
int s = sizeof(stStoreCfg);
|
int s2=next_pow_of_2(s);
|
stStoreCfg * p1;
|
int nMaxSN=0;
|
int nMaxId=0;
|
for (int i=0; s2*i < STORECFGPAGESIZE ; i++)
|
{
|
p1= (stStoreCfg *)(STORECFGBASE + s2 * i );
|
if (p1->Sign1 != START_SIGN) continue;
|
if (p1->EndSign1 != END_SIGN) continue;
|
|
if (p1->Seq1 >= nMaxSN) {nMaxSN = p1->Seq1; nMaxId = i;}
|
}
|
// nMaxId=nMaxId+1;
|
return (stStoreCfg *)(STORECFGBASE + s2 * nMaxId);
|
}
|
|
stStoreCfg * GetNextStoreCfgAddr(stStoreCfg * CurCfg )
|
{
|
int s = sizeof(stStoreCfg);
|
int s2=next_pow_of_2(s);
|
uint32_t nAddr1 = (uint32_t) CurCfg;
|
uint32_t nAddr2 = nAddr1 + s2;
|
for (int i=1;i<33;i++)
|
{
|
int skip=0;
|
nAddr2 = nAddr1 + s2*i;
|
if ((nAddr2 + s) > STORECFGBASE + STORECFGPAGESIZE)
|
{
|
nAddr2=STORECFGBASE; break;
|
}
|
for (int j=0;j<s2;j++)
|
{
|
if (((unsigned char *)nAddr2)[j] != 0xff)
|
{skip =1;}
|
}
|
if (skip==1) {continue;}
|
break;
|
}
|
stStoreCfg * p1 = (stStoreCfg *)nAddr2;
|
return p1;
|
}
|
|
|
int SaveStoreCfg(stStoreCfg * CurCfg)
|
{
|
return 0;
|
}
|
*/
|
// stStoreCfg Cfg2;
|
|
int LoadFlashDatas()
|
{
|
for (int i=0;i<16;i++)
|
{
|
// FlashDatas[i]=((uint16_t *)pConfigFlashBase)[i];
|
}
|
return 0;
|
}
|
/*
|
int LoadAndUpdateStoreCfg()
|
{
|
stStoreCfg * pFCfg = (stStoreCfg *) GetCurStoreCfgAddr();
|
|
Cfg2.Sign1=START_SIGN;
|
Cfg2.Seq1=pFCfg[0].Seq1+1;
|
Cfg2.CRC1=0x7777;
|
Cfg2.PowerCount=pFCfg[0].PowerCount+1;
|
Cfg2.UpTime=pFCfg[0].UpTime+1;
|
Cfg2.UserData1=pFCfg[0].UserData1;
|
Cfg2.EndSign1=END_SIGN;
|
stStoreCfg * pFCfg2 = GetNextStoreCfgAddr(pFCfg);
|
|
|
HAL_StatusTypeDef res;
|
if (pFCfg2 <= pFCfg)
|
{
|
res = (HAL_StatusTypeDef)EraseAndWriteToFlashMem(&Cfg2,pFCfg2,sizeof(stStoreCfg));
|
|
}else
|
{
|
res = (HAL_StatusTypeDef)WriteToFlashMemNoErase(&Cfg2,pFCfg2,sizeof(stStoreCfg));
|
}
|
return res;
|
}
|
*/
|
int CheckSavedData(void * pStartAddr, int PageSize, int Pages, int DataSize)
|
{
|
return 0;
|
};
|
|
|
int nMaxRunStatIndex=-1;
|
unsigned int nMaxRunStatSeq=0;
|
int nNextRunStatSpace=0;
|
int LoadDefaultRunStat(pRunStat theRunStat)
|
{
|
return 0;
|
}
|
int LoadRunStat(pRunStat theRunStat)
|
{
|
uchar * pRunStatStore = (uchar *)STORE_RUNSTAT_BASE;
|
pRunStat pStoreRunStats = (pRunStat)pRunStatStore;
|
// int s = sizeof(stRunStat);
|
|
for (int i=0;i * sizeof(stRunStat) < (STORE_RUNSTAT_PAGESIZE * STORE_RUNSTAT_PAGES) ;i++)
|
{
|
if (pStoreRunStats[i].Sign1 == START_SIGN )
|
{
|
if (pStoreRunStats[i].Seq1 > nMaxRunStatSeq)
|
{
|
nMaxRunStatSeq = pStoreRunStats[i].Seq1;
|
nMaxRunStatIndex=i;
|
nNextRunStatSpace=i+1;
|
}
|
}
|
}
|
if (nMaxRunStatIndex>=0) // && nMaxRunStatIndex <8)
|
{
|
ReadFlashMem(theRunStat,(void *)(pStoreRunStats+nMaxRunStatIndex),sizeof(stRunStat));
|
}else {
|
LoadDefaultRunStat(theRunStat);
|
}
|
// find Next Space
|
// if Same Page with MaxSeq Index, then not erase, skip and skip.
|
// if next Page of MaxSeq Index, then earse if not empty;
|
if ((nNextRunStatSpace + 1) * sizeof(stRunStat) > STORE_RUNSTAT_PAGESIZE * STORE_RUNSTAT_PAGES) {
|
nNextRunStatSpace=0;
|
}
|
return 0;
|
}
|
|
int SaveRunStat(pRunStat theRunStat)
|
{
|
nMaxRunStatSeq++;
|
theRunStat->Sign1=START_SIGN;
|
theRunStat->Seq1 = nMaxRunStatSeq;
|
theRunStat->PowerCount=KMem.PwrOnCount;
|
theRunStat->UpTime=KMem.TotalRunTime;
|
theRunStat->CRC1=0x11;
|
theRunStat->EndSign1=END_SIGN;
|
|
//check empty
|
unsigned char *pFlash = (unsigned char *)(STORE_RUNSTAT_BASE + nNextRunStatSpace*sizeof(stRunStat));
|
int Skip=0;
|
for (int j=0;j<sizeof(stRunStat);j++)
|
{
|
if (pFlash[j]!=0xff) {Skip =1 ; break;}
|
}
|
if (Skip ==0 )
|
{
|
WriteToFlashMemNoErase(theRunStat,(void *)(STORE_RUNSTAT_BASE + nNextRunStatSpace*sizeof(stRunStat)),sizeof(stRunStat));
|
}else
|
{
|
EraseAndWriteToFlashMem(theRunStat,(void *)(STORE_RUNSTAT_BASE + nNextRunStatSpace*sizeof(stRunStat)),sizeof(stRunStat));
|
}
|
nMaxRunStatIndex=nNextRunStatSpace;
|
nNextRunStatSpace++;
|
if ((nNextRunStatSpace+1) * sizeof(stRunStat) > STORE_RUNSTAT_PAGESIZE * STORE_RUNSTAT_PAGES)
|
{
|
nNextRunStatSpace=0;
|
}
|
return 0;
|
}
|
|
|
int nEventCount=0;
|
int nEventMinIndex;
|
int nEventMaxIndex;
|
unsigned int nEventMaxSeq=0;
|
int nEventNextSpace;
|
int nMaxCurTime=0;
|
int CheckEventLog()
|
{
|
unsigned int nMinEventSeq=999999999;
|
uchar * pEventStore = (uchar *)STORE_LOG_BASE;
|
pEventLog theEventLog = (pEventLog) pEventStore;
|
// int s = sizeof(stEventLog);
|
nEventCount=0;
|
|
for (int i=0;i * sizeof(stEventLog) < (STORE_LOG_PAGESIZE * STORE_LOG_PAGES) ;i++)
|
{
|
if (theEventLog[i].Sign1 == START_SIGN )
|
{
|
nEventCount++;
|
if (theEventLog[i].Seq1 > nEventMaxSeq)
|
{
|
nEventMaxSeq = theEventLog[i].Seq1;
|
nEventMaxIndex=i;
|
nMaxCurTime=theEventLog[i].nTime;
|
nEventNextSpace=i+1;
|
}
|
if (theEventLog[i].Seq1 < nMinEventSeq)
|
{
|
nMinEventSeq = theEventLog[i].Seq1;
|
nEventMinIndex = i;
|
}
|
}
|
}
|
// find Next Space
|
// if Same Page with MaxSeq Index, then not erase, skip and skip.
|
// if next Page of MaxSeq Index, then earse if not empty;
|
if ((nEventNextSpace + 1) * sizeof(stEventLog) > STORE_LOG_PAGESIZE * STORE_LOG_PAGES) {
|
nEventNextSpace=0;
|
}
|
|
return nEventCount;
|
}
|
|
int AddEventLog(uint32_t nTime, USHORT nEvent, USHORT nParam1, UINT nParam2)
|
{
|
nEventMaxSeq++;
|
stEventLog thisEventLog={START_SIGN, nEventMaxSeq, nTime,nEvent,nParam1,nParam2};
|
//check empty
|
unsigned char *pFlash = (unsigned char *)(STORE_LOG_BASE + nEventNextSpace*sizeof(stEventLog));
|
int Skip=0;
|
for (int j=0;j<sizeof(stEventLog);j++)
|
{
|
if (pFlash[j]!=0xff) {Skip =1 ; break;}
|
}
|
if (Skip ==0 )
|
{
|
WriteToFlashMemNoErase(&thisEventLog,(void *)(STORE_LOG_BASE + nEventNextSpace*sizeof(stEventLog)),sizeof(stEventLog));
|
}else
|
{
|
EraseAndWriteToFlashMem(&thisEventLog,(void *)(STORE_LOG_BASE + nEventNextSpace*sizeof(stEventLog)),sizeof(stEventLog));
|
|
}
|
nEventMaxIndex=nEventNextSpace;
|
nEventNextSpace++;
|
if ((nEventNextSpace+1) * sizeof(stEventLog) > STORE_LOG_PAGESIZE * STORE_LOG_PAGES)
|
{
|
nEventNextSpace=0;
|
}
|
nEventCount++;
|
KMem.nEventCount=nEventCount;
|
return 0;
|
}
|
|
pEventLog GetEventLogAddr(int nIndex)
|
{
|
int nEventIndex=nEventMinIndex + nIndex;
|
|
if (nEventIndex * sizeof(stEventLog) >= (STORE_LOG_PAGESIZE * STORE_LOG_PAGES))
|
{
|
nEventIndex -= (STORE_LOG_PAGESIZE * STORE_LOG_PAGES)/sizeof(stEventLog);
|
}
|
unsigned char *pFlash = (unsigned char *)(STORE_LOG_BASE + nEventIndex*sizeof(stEventLog));
|
|
return (pEventLog)pFlash;
|
}
|
|
int ClearEventLog(void)
|
{
|
EraseFlashMem((void *)STORE_LOG_BASE,STORE_LOG_PAGES);
|
nEventMinIndex=0;
|
nEventMaxIndex=0;
|
nEventMaxSeq=0;
|
nEventCount=0;
|
nEventNextSpace=0;
|
return 0;
|
}
|
int KMachineInit(void)
|
{
|
// ClearEventLog();
|
CheckEventLog();
|
LoadRunStat(&KMRunStat);
|
KMem.CurTimeSec=nMaxCurTime;
|
KMem.TotalRunTime=KMRunStat.UpTime;
|
KMRunStat.PowerCount++;
|
KMem.PwrOnCount=KMRunStat.PowerCount;
|
SaveRunStat(&KMRunStat);
|
KMem.SDD[15]=nMaxRunStatIndex;
|
KMem.SDD[16]=nMaxRunStatSeq;
|
KMem.SDD[17]=nNextRunStatSpace;
|
|
|
AddEventLog(KMem.CurTimeSec,EventTypePowerUp,1,12345);
|
KMem.SDD[19]=nEventCount;
|
KMem.SDD[20]=nEventMinIndex;
|
KMem.SDD[21]=nEventMaxIndex;
|
KMem.SDD[22]=nEventMaxSeq;
|
KMem.SDD[23]=nEventNextSpace;
|
|
return 0;
|
}
|
