/**
|
******************************************************************************
|
* @file : KMachine.c
|
* @brief : KMachine program body
|
******************************************************************************
|
*/
|
|
#include "KMachine.h"
|
#include "KBus.h"
|
#include "string.h"
|
#include "Globaldef.h"
|
#include "stm32f0xx.h"
|
#include "stm32f0xx_ll_flash.h"
|
#include "PLCFunctions.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 */
|
|
//#define FLASH_BASE
|
//#define FLASH_PAGE_SIZE 0x00000400U
|
//#define FLASH_BANK1_END ((uint32_t)0x0800FFFFU) /*!< FLASH END address of bank1 */
|
#define ApplicationAddress 0x08001000 //Ó¦ÓóÌÐòÊ×µØÖ·¶¨Òå
|
#if defined(STM32F030x8)
|
#define NEW_APP_INFOBLOCK_ADDR 0x08008000 // ´æ´¢µÄÐÂÓ¦ÓóÌÐòÐÅÏ¢¿éµÄµØÖ·
|
#define NEW_APP_ADDR ((uint32_t)0x08009000U) // ´æ´¢µÄÐÂÓ¦ÓóÌÐòµÄµØÖ·
|
#endif /* STM32F030x6 || STM32F030x8 || STM32F031x6 || STM32F051x8 || STM32F042x6 || STM32F048xx || STM32F058xx || STM32F070x6 */
|
|
#if defined(STM32F030xC)
|
#define NEW_APP_INFOBLOCK_ADDR 0x08020000 // ´æ´¢µÄÐÂÓ¦ÓóÌÐòÐÅÏ¢¿éµÄµØÖ·
|
#define NEW_APP_ADDR ((uint32_t)0x08021000U) // ´æ´¢µÄÐÂÓ¦ÓóÌÐòµÄµØÖ·
|
#endif /* STM32F071xB || STM32F072xB || STM32F078xx || STM32F091xC || STM32F098xx || STM32F030xC */
|
|
|
stStoredKMSysCfg storedKMSysCfg ;
|
stKMem KMem;
|
stRunStat KMRunStat;
|
|
|
extern void SetErrLed(uchar bOn);
|
|
//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(FLASH_BASE + 0X2000))) //__attribute__((at(0X8001000)))
|
= "3.00";
|
*/
|
const stStoredKMSysCfg KMDefaultSysCfg /*__attribute__((at(STORECFGBASE)))*/ =
|
{
|
START_SIGN,
|
0x0000,
|
{
|
CFG_VER,
|
0x0000, //workmode
|
0x0000, //switchfunc
|
4, //nCfgBlockCount;
|
{ //comportparam[2]
|
{
|
PortType_KLink, //PorttType
|
1, //Station
|
1152, //Buadrate = * 100;
|
1, //ByteSize
|
0, //Parity
|
0, //StopBits
|
1, //endType
|
0, //EofChar
|
0, //SofChar
|
9, //endtime
|
0, //recvbuf
|
0, //bufsize
|
},
|
{
|
PortType_KBus, //PorttType
|
0, //Station
|
2304, //Buadrate = * 100;
|
1, //ByteSize
|
0, //Parity
|
0, //StopBits
|
1, //endType
|
0, //EofChar
|
0, //SofChar
|
1, //endtime
|
0, //recvbuf
|
0, //bufsize
|
}
|
},
|
{{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0}}, //inputfilterparam
|
{{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
|
{ //default port mapping
|
0x0010,
|
0x0020,
|
0x0030,
|
0x0040,
|
0x0050,
|
0x0060,
|
0x0070,
|
0x0080,
|
},
|
0,0,0,0,
|
{
|
{0,sizeof(stKMSysCfg)},
|
{1,100},
|
{2,100},
|
{3,32},
|
{4,32},
|
},
|
0x0008, //padding s
|
0x0009,
|
0x000a,
|
},
|
0x0011, //CRC16
|
END_SIGN,
|
};
|
|
int nEventCount=0;
|
int nEventMinIndex;
|
int nEventMaxIndex;
|
unsigned int nEventMaxSeq=0;
|
int nEventNextSpace;
|
int nMaxCurTime=0;
|
volatile int PowerState = 0;
|
|
volatile int PowerDownEvent=0;
|
volatile int OldPowerDownEvent=0;
|
volatile int OldPowerDownEventTime=0;
|
int nMaxRunStatIndex=-1;
|
unsigned int nMaxRunStatSeq=0;
|
int nNextRunStatSpace=0;
|
|
int KMRegisterPort(ushort nType,stPortDef * theParam)
|
{
|
int curPortId = KMem.nTotalPorts;
|
|
KMem.pPorts[curPortId] = theParam;
|
|
KMem.nTotalPorts++;
|
return curPortId;
|
}
|
|
int KMPortReqFunc(int nPortIndex,int nReqId, int nParam1, int nParam2, void ** pData, unsigned short * nlen1)
|
{
|
if (KMem.pPorts[nPortIndex]->ReqCommFunc)
|
return KMem.pPorts[nPortIndex]->ReqCommFunc(KMem.pPorts[nPortIndex]->pInstance, nReqId, nParam1, nParam2, pData, nlen1);
|
else return -1;
|
}
|
|
int KMRunService(int nSvrId, int nParam1, int nParam2, void **pData, unsigned short *nlen1)
|
{
|
int res;
|
switch(nSvrId)
|
{
|
case ReqNone:
|
break;
|
|
case ReqInit:
|
break;
|
case ReqReset:
|
__set_PRIMASK(1); //¹Ø±ÕÈ«¾ÖÖжÏ
|
NVIC_SystemReset();
|
break;
|
case ReqStop:
|
break;
|
case ReqRun:
|
break;
|
case ReqBlinkLED:
|
break;
|
case ReqStartDiag:
|
break;
|
case ReqStopDiag:
|
break;
|
case ReqUpdateFirm:
|
|
res = WriteNewApp(nParam1,*pData,*nlen1);
|
|
break;
|
case ReqUpdateFirmInfo:
|
res = WriteNewAppInfo(nParam1,*pData,*nlen1);
|
break;
|
|
default:
|
res = -1;
|
break;
|
|
}
|
return res;
|
}
|
|
int KMachineInit(void)
|
{
|
// ClearEventLog();
|
KMem.LastScanTime=0;
|
KMem.ScanTimeuS=0;
|
KMem.MinScanTimeuS=99999;
|
KMem.MaxScanTimeuS=0;
|
|
// KMem.SDD[14]=(unsigned int)&KMStoreSysCfg;
|
// KMem.SDD[15]=(unsigned int)&KMStoreSysCfg1;
|
KMem.SDD[12]=((uint32_t *)UID_BASE)[0];
|
// KMem.SDD[13]=((uint32_t *)UID_BASE)[1];
|
// KMem.SDD[14]=((uint32_t *)UID_BASE)[2];
|
KMem.SDD[13]=PendSvCount;
|
KMem.SDD[14]=RCC->CSR;
|
// KMem.SDD[15]=*(uint32_t *)FLASHSIZE_BASE;
|
// KMem.SDD[16]=(unsigned int)&KMSysCfg;
|
|
KMem.nTotalPorts = 0;
|
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;
|
}
|
|
int KMachineLoopProc(void)
|
{
|
|
return 0;
|
}
|
|
|
//const stKMSysCfg KMDefaultSysCfg2[7] /*__attribute__((at(STORECFGBASE+sizeof(stKMSysCfg))))*/;
|
|
int ReadFlashMem(void * pBuf, void * pAddrFlash, int nByteSize)
|
{
|
memcpy(pBuf,pAddrFlash,nByteSize);
|
// for (int i=0;i<nByteSize/4;i++)
|
// {
|
// ((uint32_t *)pBuf)[i] = ((uint32_t *)pAddrFlash)[i];
|
// }
|
// for (int i=nByteSize/4*2;i<nByteSize/2;i++)
|
// {
|
// ((uint16_t *)pBuf)[i] = ((uint16_t *)pAddrFlash)[i];
|
// }
|
|
return nByteSize;
|
}
|
|
int EraseFlashMem(void * pAddrFlash, unsigned int Pages)
|
{
|
ErrorStatus res;
|
res = LL_Flash_Unlock();
|
// uint32_t ErrNo;
|
res = LL_Flash_PageErase(pAddrFlash,Pages);
|
LL_FLASH_Lock(FLASH);
|
return res;
|
}
|
|
int WriteToFlashMemNoErase(void * pBuf, void * pAddrFlash, unsigned int nByteSize)
|
{
|
ErrorStatus res;
|
SetErrLed(1);
|
res = LL_Flash_Unlock();
|
// __disable_irq();
|
///*
|
for (int i=0;i<(nByteSize+1)/2;i++)
|
{
|
unsigned short value = ((uint8_t *)pBuf)[i*2] + (((uint8_t *)pBuf)[i*2 +1] << 8);
|
res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
|
if (res == ERROR) break;
|
}
|
// */
|
// __enable_irq();
|
LL_FLASH_Lock(FLASH);
|
if (res == ERROR) return 1;
|
return 0;
|
}
|
|
int EraseAndWriteToFlashMem(void * pBuf, void * pAddrFlash, unsigned int nByteSize)
|
{
|
|
SetErrLed(1);
|
ErrorStatus res;
|
res = LL_Flash_Unlock();
|
// __disable_irq();
|
int NbPages = (nByteSize-1) / FLASH_PAGE_SIZE + 1;
|
// FLASH_EraseInitTypeDef erase1;
|
// erase1.NbPages=(nByteSize-1) / FLASH_PAGE_SIZE + 1;;
|
// erase1.PageAddress=(unsigned int)pAddrFlash;
|
// erase1.TypeErase=FLASH_TYPEERASE_PAGES;
|
res = LL_Flash_PageErase(pAddrFlash,NbPages);
|
for (int i=0;i<(nByteSize+1)/2;i++)
|
{
|
unsigned short value = ((uint8_t *)pBuf)[i*2] + (((uint8_t *)pBuf)[i*2 +1] << 8);
|
res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
|
if (res == ERROR) break;
|
}
|
|
// __enable_irq();
|
LL_FLASH_Lock(FLASH);
|
if (res == ERROR) return 1;
|
return 0;
|
}
|
|
/* ÉÕ¼Flash£¬²¢×Ô¶¯²Á³ý£¬Ò³ÆðʼºÍ¿çҳʱ×Ô¶¯²Á³ý Ò³ÃæÖв¿·Ö²»²Á³ý */
|
int WriteToFlashAutoErase(void * pBuf, void * pAddrFlash, unsigned int nByteSize)
|
{
|
SetErrLed(1);
|
ErrorStatus res;
|
res = LL_Flash_Unlock();
|
// __disable_irq();
|
|
int StartPage = (int)pAddrFlash / FLASH_PAGE_SIZE;
|
int EndPage = ((int)pAddrFlash + nByteSize) / FLASH_PAGE_SIZE;
|
int StartOffset = (int)pAddrFlash & (FLASH_PAGE_SIZE-1);
|
|
int NbPages = EndPage -StartPage + 1;
|
|
if (StartOffset == 0) { // ´Ó×ʼ , È«²¿²Á³ý,È»ºóÔÙ´æ´¢.
|
res = LL_Flash_PageErase(pAddrFlash,NbPages);
|
for (int i=0;i<(nByteSize+1)/2;i++)
|
{
|
unsigned short value = ((uint8_t *)pBuf)[i*2] + (((uint8_t *)pBuf)[i*2 +1] << 8);
|
res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
|
if (res == ERROR) break;
|
}
|
}else if (NbPages > 1){ // ¿çÒ³´æ´¢
|
// ÏÈÇ°ÃæµÄ²¿·Ö
|
int i;
|
for (i=0;i<(nByteSize+1)/2 && (((int)pAddrFlash + i*2) &(FLASH_PAGE_SIZE -1))!=0 ;i++)
|
{
|
unsigned short value = ((uint8_t *)pBuf)[i*2] + (((uint8_t *)pBuf)[i*2 +1] << 8);
|
res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
|
if (res == ERROR) break;
|
}
|
// ²Á³ýºóÃæµÄ²¿·Ö.
|
res = LL_Flash_PageErase((void *)((int)pAddrFlash + i*2),NbPages - 1);
|
// ¼ÌÐø´æ´¢
|
for ( ;i<(nByteSize+1)/2;i++)
|
{
|
unsigned short value = ((uint8_t *)pBuf)[i*2] + (((uint8_t *)pBuf)[i*2 +1] << 8);
|
res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
|
if (res == ERROR) break;
|
}
|
}else {
|
// Õý³£Ð´Èë,²»ÐèÒª²Á³ý
|
for (int i=0;i<(nByteSize+1)/2;i++)
|
{
|
unsigned short value = ((uint8_t *)pBuf)[i*2] + (((uint8_t *)pBuf)[i*2 +1] << 8);
|
res = LL_FLASH_Program(ProgaraType_DATA16, (uint32_t)pAddrFlash + i*2, value);
|
if (res == ERROR) break;
|
}
|
}
|
// __enable_irq();
|
LL_FLASH_Lock(FLASH);
|
if (res == ERROR) return 1;
|
return 0;
|
}
|
|
int ReadFactoryData(void * pDatabuf, int nByteCount)
|
{
|
memcpy(pDatabuf,(stFactoryData *)FACTORY_DATA_BASE,nByteCount);
|
return 0;
|
}
|
int WriteFactoryData(void * pDataBuf, int nByteCount)
|
{
|
stFactoryData * p1 = (stFactoryData*) pDataBuf;
|
stFactoryData * p2 = (stFactoryData *)FACTORY_DATA_BASE;
|
p1->Seq1= p2->Seq1+1;
|
|
EraseAndWriteToFlashMem(pDataBuf, (stFactoryData *)FACTORY_DATA_BASE,nByteCount);
|
return 0;
|
}
|
#if (ENABLE_PLC)
|
int ReadPLCProgram(int nBank, int nProgByteAddr, void *pBuf, int nByteSize)
|
{
|
stStoredBinProgs * pStoredProg;
|
if (nBank==0) {
|
pStoredProg = (void *)(STORE_PRG_BASE);
|
}else if (nBank ==1) {
|
pStoredProg = (void *)(ALT_PRG_BASE);
|
}else if (storedKMSysCfg.theKMSysCfg.nProgBank==0) {
|
pStoredProg = (void *)(STORE_PRG_BASE);
|
} else {
|
pStoredProg = (void *)(ALT_PRG_BASE);
|
}
|
void * progByteAddr;
|
progByteAddr =(unsigned char *)&pStoredProg->BinInstrcns + nProgByteAddr;
|
|
ReadFlashMem(pBuf, (void *)(progByteAddr), nByteSize);
|
return 0;
|
}
|
|
int StartPLCProgram(int nBank, int nByteSize, int nCRC)
|
{
|
void * progHdrAddr;
|
int nRes = 0;
|
if (nBank == 0) {
|
progHdrAddr=(void *)(STORE_PRG_BASE);
|
}else if (nBank==1) {
|
progHdrAddr=(void *)(ALT_PRG_BASE);
|
} else if (storedKMSysCfg.theKMSysCfg.nProgBank==0) {
|
progHdrAddr=(void *)(ALT_PRG_BASE);
|
}else{
|
progHdrAddr=(void *)(STORE_PRG_BASE);
|
}
|
|
stStoredHdr theHdr;
|
theHdr.nBlockSign = 0xAA55;
|
theHdr.nBlockType = 0;
|
theHdr.nSeq = 1;
|
theHdr.nSize = nByteSize;
|
theHdr.nCRC2 = nCRC;
|
|
WriteToFlashAutoErase(&theHdr,(void *)progHdrAddr,sizeof(stStoredHdr));
|
|
return nRes;
|
}
|
int WritePLCProgram(int nBank, int nProgAddress, void * pBuf, int nByteSize)
|
{
|
// Program Save Address;//
|
// Program 2 Save Address; //
|
stStoredBinProgs * pStoredProg;
|
|
if (nBank == 0) {
|
pStoredProg=(stStoredBinProgs *)(STORE_PRG_BASE);
|
}else if (nBank==1) {
|
pStoredProg=(stStoredBinProgs *)(ALT_PRG_BASE);
|
} else if (storedKMSysCfg.theKMSysCfg.nProgBank==0) {
|
pStoredProg=(stStoredBinProgs *)(ALT_PRG_BASE);
|
}else{
|
pStoredProg=(stStoredBinProgs *)(STORE_PRG_BASE);
|
}
|
void * progByteAddr;
|
progByteAddr =(unsigned char *)&pStoredProg->BinInstrcns + nProgAddress;
|
WriteToFlashAutoErase(pBuf,progByteAddr,nByteSize);
|
|
return 0;
|
}
|
|
int FinishiPLCProgram(int nBank, int nProgSteps,int nCRC )
|
{
|
int nRes = 0;
|
|
if (storedKMSysCfg.theKMSysCfg.nProgBank == 0 ) {
|
storedKMSysCfg.theKMSysCfg.nProgBank = 1;
|
}else {
|
storedKMSysCfg.theKMSysCfg.nProgBank = 0;
|
}
|
storedKMSysCfg.theKMSysCfg.nProgSize = nProgSteps;
|
|
WriteSysCfgToFlash(&storedKMSysCfg);
|
|
KMRunStat.nBinProgSize=nProgSteps;
|
KMRunStat.nBinProgBank=storedKMSysCfg.theKMSysCfg.nProgBank;
|
|
SaveRunStat(&KMRunStat);
|
|
return nRes;
|
}
|
int ReadPLCAnno(int nBank, int nProgByteAddr, void *pBuf, int nByteSize)
|
{
|
stStoredBinProgs * pStoredProg;
|
if (nBank==0) {
|
pStoredProg = (void *)(STORE_PRG_BASE);
|
}else if (nBank ==1) {
|
pStoredProg = (void *)(ALT_PRG_BASE);
|
}else if (storedKMSysCfg.theKMSysCfg.nProgBank==0) {
|
pStoredProg = (void *)(STORE_PRG_BASE);
|
} else {
|
pStoredProg = (void *)(ALT_PRG_BASE);
|
}
|
void * progByteAddr;
|
progByteAddr =(unsigned char *)&pStoredProg->BinInstrcns + nProgByteAddr;
|
|
ReadFlashMem(pBuf, (void *)(progByteAddr), nByteSize);
|
return 0;
|
}
|
|
int StartPLCAnno(int nBank, int nByteSize, int nCRC)
|
{
|
void * StoredAnnoHdrAddr;
|
int nRes = 0;
|
|
StoredAnnoHdrAddr=(void *)(STORE_PLC_ANNO_BASE);
|
|
|
stStoredHdr theHdr;
|
theHdr.nBlockSign = 0xAA55;
|
theHdr.nBlockType = 3;
|
theHdr.nSeq = 1;
|
theHdr.nSize = nByteSize;
|
theHdr.nCRC2 = nCRC;
|
|
WriteToFlashAutoErase(&theHdr,(void *)StoredAnnoHdrAddr,sizeof(stStoredHdr));
|
|
return nRes;
|
}
|
int WritePLCAnno(int nBank, int nByteAddress, void * pBuf, int nByteSize)
|
{
|
// Program Save Address;//
|
// Program 2 Save Address; //
|
stStoredAnno * pStoredAnno;
|
pStoredAnno=(stStoredAnno *)(STORE_PLC_ANNO_BASE);
|
|
void * nByteAddr;
|
nByteAddr =pStoredAnno->Annos + nByteAddress;
|
WriteToFlashAutoErase(pBuf,nByteAddr,nByteSize);
|
|
return 0;
|
}
|
int FinishiPLCAnno(int nBank, int nByteSize,int nCRC )
|
{
|
int nRes = 0;
|
|
storedKMSysCfg.theKMSysCfg.nAnnoSize = nByteSize;
|
WriteSysCfgToFlash(&storedKMSysCfg);
|
/*
|
KMRunStat.nBinProgSize=nProgSteps;
|
KMRunStat.nBinProgBank=storedKMSysCfg.theKMSysCfg.nProgBank;
|
|
SaveRunStat(&KMRunStat);
|
*/
|
return nRes;
|
}
|
|
#endif //ENABLE_PLC
|
int LoadDefaultSysCfg(pStoredKMSysCfg theStoredKMSysCfg)
|
{
|
memcpy(theStoredKMSysCfg,&KMDefaultSysCfg,sizeof(stStoredKMSysCfg));
|
return 0;
|
}
|
int ReadSysCfgFromFlash(pStoredKMSysCfg theStoredKMSysCfg)
|
{
|
pStoredKMSysCfg pSKMSysCfg = (pStoredKMSysCfg)(STORE_SYSREG_BASE);
|
// find latest Store Cfg
|
int s2=128;
|
int nIndex=-1;
|
int nMaxSeq=0;
|
for (int i=0;i<8;i++)
|
{
|
pSKMSysCfg = (pStoredKMSysCfg)(STORE_SYSREG_BASE + s2*i);
|
if (pSKMSysCfg->Sign1 == START_SIGN && pSKMSysCfg->EndSign1 == END_SIGN)
|
{
|
if (pSKMSysCfg->Seq1 > nMaxSeq)
|
{
|
nIndex=i;nMaxSeq=pSKMSysCfg->Seq1;
|
}
|
}
|
}
|
if (nIndex>=0 && nIndex <8)
|
{
|
ReadFlashMem(theStoredKMSysCfg,(void *)(STORE_SYSREG_BASE + nIndex * s2),sizeof(stStoredKMSysCfg));
|
//ReadFlashMem(theStoredKMSysCfg,(void *)(STORE_SYSREG_BASE ),sizeof(stStoredKMSysCfg));
|
//memcpy(theStoredKMSysCfg,(void *)(STORE_SYSREG_BASE ),sizeof(stStoredKMSysCfg));
|
}else {
|
LoadDefaultSysCfg(theStoredKMSysCfg);
|
}
|
//memcpy(theKMSysCfg,(void* )STORECFGBASE,sizeof(KMSysCfg));
|
return 0;
|
}
|
|
int WriteSysCfgToFlash(pStoredKMSysCfg theStoredKMSysCfg)
|
{
|
theStoredKMSysCfg->Seq1++;
|
theStoredKMSysCfg->Sign1 = START_SIGN;
|
theStoredKMSysCfg->EndSign1 = END_SIGN;
|
// EraseAndWriteToFlashMem(theStoredKMSysCfg,(void *)STORE_SYSREG_BASE,sizeof(stStoredKMSysCfg));
|
// return 0;
|
// 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(theStoredKMSysCfg,(void *)(STORE_SYSREG_BASE + nIndex*s2),sizeof(stStoredKMSysCfg));
|
}
|
else {
|
EraseAndWriteToFlashMem(theStoredKMSysCfg,(void *)STORE_SYSREG_BASE,sizeof(stStoredKMSysCfg));
|
}
|
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 LoadDefaultRunStat(pRunStat theRunStat)
|
{
|
theRunStat->PowerCount=1;
|
// theRunStat->UpTime=0;
|
// theRunStat->UserData1=0;
|
// theRunStat->WorkMode=0;
|
// theRunStat->WorkMode2=0;
|
// theRunStat->nBinProgBank=0;
|
// theRunStat->nBinInstrcnSize=0;
|
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) < (FLASH_PAGE_SIZE * 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) > FLASH_PAGE_SIZE * 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) > FLASH_PAGE_SIZE * STORE_RUNSTAT_PAGES)
|
{
|
nNextRunStatSpace=0;
|
}
|
return 0;
|
}
|
|
int WriteNewApp(int nProgByteOffset, void *pBuf, int nByteSize)
|
{
|
|
int res = -1;
|
int FlashSize = *(ushort *)FLASHSIZE_BASE;
|
int NewAppAddress ;
|
if (FlashSize == 64) {
|
NewAppAddress = 0x08009000U;
|
}else if (FlashSize == 256) {
|
NewAppAddress = 0x08021000U;
|
}
|
if ((nProgByteOffset&(FLASH_PAGE_SIZE-1)) ==0){
|
// EraseFlashMem((void *)(NewAppAddress + nProgByteAddr),1);
|
|
res = EraseAndWriteToFlashMem(pBuf,(void *)(NewAppAddress + nProgByteOffset),nByteSize);
|
}else {
|
// if (nByteSize>64) return 0;
|
res = WriteToFlashMemNoErase(pBuf,(void *)(NewAppAddress + nProgByteOffset),nByteSize);
|
}
|
return res;
|
}
|
|
int WriteNewAppInfo(int nProgByteAddr, void *pBuf, int nByteSize)
|
{
|
int FlashSize = *(ushort *)FLASHSIZE_BASE;
|
int NewAppInfoBlockAddress ;
|
if (FlashSize == 64) {
|
NewAppInfoBlockAddress = 0x08008000;
|
}else if (FlashSize == 256) {
|
NewAppInfoBlockAddress = 0x08020000;
|
}
|
|
int res = EraseAndWriteToFlashMem(pBuf,(void *)(NewAppInfoBlockAddress + nProgByteAddr),nByteSize);
|
return res;
|
}
|
|
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) < (FLASH_PAGE_SIZE * 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) > FLASH_PAGE_SIZE * 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) > FLASH_PAGE_SIZE * STORE_LOG_PAGES)
|
{
|
nEventNextSpace=0;
|
}
|
nEventCount++;
|
KMem.nEventCount=nEventCount;
|
return 0;
|
}
|
|
pEventLog GetEventLogAddr(int nIndex)
|
{
|
int nEventIndex=nEventMinIndex + nIndex;
|
|
if (nEventIndex * sizeof(stEventLog) >= (FLASH_PAGE_SIZE * STORE_LOG_PAGES))
|
{
|
nEventIndex -= (FLASH_PAGE_SIZE * 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;
|
}
|
|
inline void SetAddrBit(unsigned short * pW, unsigned char bitPos)
|
{
|
(*pW)|=1<<(bitPos&0xf);
|
}
|
|
inline void ResetBit(unsigned short * pW, unsigned char bitPos)
|
{
|
(*pW)&=~(1<<(bitPos&0xf));
|
}
|
|
static inline void SetBitValue(unsigned short * pW, unsigned char bitPos, unsigned char Value)
|
{
|
if (Value) { SetAddrBit(pW, bitPos);}
|
else {ResetBit(pW, bitPos);}
|
}
|
|
static inline unsigned char GetBitValue(unsigned short W, unsigned char bitPos)
|
{
|
if (W&(1<<(bitPos&0xf))) return 1;
|
else return 0;
|
}
|
|
|
unsigned char GetCoilValue(unsigned char nCoilType, unsigned short nCoilAddr)
|
{
|
unsigned char thisValue=0;
|
unsigned short nWordAddr=(nCoilAddr&0xff0)>>4;
|
unsigned char nBitPos=nCoilAddr&0xf;
|
switch(nCoilType)
|
{
|
case KLCoilTypeX:
|
if (nCoilAddr >= KLCoilXCount) return 0;
|
thisValue = GetBitValue(KMem.WX[nWordAddr], nBitPos);
|
break;
|
case KLCoilTypeY:
|
if (nCoilAddr >= KLCoilYCount) return 0;
|
thisValue = GetBitValue(KMem.WY[nWordAddr], nBitPos);
|
break;
|
case KLCoilTypeR:
|
|
if (nCoilAddr < KLCoilRCount) {
|
thisValue = GetBitValue(KMem.WR[nWordAddr], nBitPos);
|
}else if (nCoilAddr > 9000) {
|
if (nCoilAddr == 9010) thisValue = 1;
|
if (nCoilAddr == 9011) thisValue = 0;
|
if (nCoilAddr == 9013) thisValue = GetBitValue(KMem.WSR[nWordAddr], 13);
|
}
|
// return thisValue;
|
break;
|
case KLCoilTypeLX:
|
if (nCoilAddr >= KLCoilLXCount) return 0;
|
thisValue = GetBitValue(KMem.WLX[nWordAddr], nBitPos);
|
break;
|
case KLCoilTypeLY:
|
if (nCoilAddr >= KLCoilLYCount) return 0;
|
thisValue = GetBitValue(KMem.WLY[nWordAddr], nBitPos);
|
break;
|
#if (ENABLE_PLC)
|
case KLCoilTypeT:
|
if (nCoilAddr >= KLCoilTCount) return 0;
|
thisValue = GetBitValue(PLCMem.WT[nWordAddr], nBitPos);
|
break;
|
case KLCoilTypeC:
|
if (nCoilAddr >= KLCoilCCount) return 0;
|
thisValue = GetBitValue(PLCMem.WC[nWordAddr], nBitPos);
|
break;
|
#endif
|
case KLCoilTypeLR:
|
if (nCoilAddr >= KLCoilLRCount) return 0;
|
thisValue = GetBitValue(KMem.WLR[nWordAddr], nBitPos);
|
break;
|
case KLCoilTypeSR:
|
if (nCoilAddr >= KLCoilSRCount) return 0;
|
thisValue = GetBitValue(KMem.WSR[nWordAddr], nBitPos);
|
break;
|
default:
|
break;
|
}
|
return thisValue;
|
}
|
int SetCoilValue(unsigned char nCoilType, unsigned short nCoilAddr, unsigned char nCoilValue)
|
{
|
unsigned short nWordAddr=(nCoilAddr&0xff0)>>4;
|
unsigned char nBitAddr=nCoilAddr&0xf;
|
switch(nCoilType)
|
{
|
case KLCoilTypeX:
|
if (nCoilAddr >= KLCoilXCount) return 0;
|
SetBitValue(&KMem.WX[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeY:
|
if (nCoilAddr >= KLCoilYCount) return 0;
|
SetBitValue(&KMem.WY[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeR:
|
if (nCoilAddr >= KLCoilRCount) return 0;
|
SetBitValue(&KMem.WR[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeLX:
|
if (nCoilAddr >= KLCoilLXCount) return 0;
|
SetBitValue(&KMem.WLX[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeLY:
|
if (nCoilAddr >= KLCoilLYCount) return 0;
|
SetBitValue(&KMem.WLY[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
#if (ENABLE_PLC)
|
case KLCoilTypeT:
|
if (nCoilAddr >= KLCoilTCount) return 0;
|
SetBitValue(&PLCMem.WT[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeC:
|
if (nCoilAddr >= KLCoilCCount) return 0;
|
SetBitValue(&PLCMem.WC[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
#endif
|
case KLCoilTypeLR:
|
if (nCoilAddr >= KLCoilLRCount) return 0;
|
SetBitValue(&KMem.WLR[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeSR:
|
if (nCoilAddr >= KLCoilSRCount) return 0;
|
SetBitValue(&KMem.WSR[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
default:
|
break;
|
}
|
return 0;
|
}
|
|
int GetVarData(int nDataType, int nDataAddr)
|
{
|
// TODO: ?????????.
|
int thisValue = 0;
|
|
switch (nDataType)
|
{
|
case KLDataTypeDEC:
|
case KLDataTypeHEX:
|
thisValue = nDataAddr;
|
break;
|
case KLDataTypeWX:
|
if (nDataAddr >= KLDataWXCount) return 0;
|
thisValue = KMem.WX[nDataAddr];
|
break;
|
case KLDataTypeWY:
|
if (nDataAddr >= KLDataWYCount) return 0;
|
thisValue = KMem.WY[nDataAddr];
|
break;
|
case KLDataTypeWR:
|
if (nDataAddr >= KLDataWRCount) return 0;
|
thisValue = KMem.WR[nDataAddr];
|
break;
|
case KLDataTypeWLX:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
thisValue = KMem.WLX[nDataAddr];
|
break;
|
case KLDataTypeWLY:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
thisValue = KMem.WLY[nDataAddr];
|
break;
|
case KLDataTypeDT:
|
if (nDataAddr >= KLDataDTCount) return 0;
|
thisValue = (signed short)KMem.DT[nDataAddr];
|
break;
|
case KLDataTypeSDT:
|
if (nDataAddr >= KLDataSDTCount) return 0;
|
thisValue = KMem.SDT[nDataAddr];
|
break;
|
case KLDataTypeWSR:
|
if (nDataAddr >= KLCoilLRCount) return 0;
|
thisValue = KMem.WSR[nDataAddr];
|
break;
|
#if (ENABLE_PLC)
|
case KLDataTypeSV:
|
if (nDataAddr >= KLDataSVCount) return 0;
|
thisValue = PLCMem.SV[nDataAddr];
|
break;
|
case KLDataTypeEV:
|
if (nDataAddr >= KLDataEVCount) return 0;
|
thisValue = PLCMem.EV[nDataAddr];
|
break;
|
#endif
|
case KLDataTypeLD:
|
if (nDataAddr >= KLDataLDCount) return 0;
|
thisValue = KMem.DT[nDataAddr];
|
break;
|
case KLDataSysCfg:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
thisValue = KMem.SDT[nDataAddr];
|
break;
|
case KLDataTypeFlash:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
thisValue = KMem.SDT[nDataAddr];
|
break;
|
case KLDataTypeTest:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
thisValue = KMem.SDT[nDataAddr];
|
break;
|
}
|
return thisValue;
|
}
|
|
|
int SetVarData(int nDataType, int nDataAddr, int nDataValue)
|
{
|
// TODO: ?????????.
|
switch (nDataType)
|
{
|
// case KLDataTypeDEC:
|
// case KLDataTypeHEX:
|
// break;
|
case KLDataTypeWX:
|
if (nDataAddr >= KLDataWXCount) return 0;
|
KMem.WX[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWY:
|
if (nDataAddr >= KLDataWYCount) return 0;
|
KMem.WY[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWR:
|
if (nDataAddr >= KLDataWRCount) return 0;
|
KMem.WR[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWLX:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
KMem.WLX[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWLY:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
KMem.WLY[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeDT:
|
if (nDataAddr >= KLDataDTCount) return 0;
|
KMem.DT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeSDT:
|
if (nDataAddr >= KLDataSDTCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWSR:
|
if (nDataAddr >= KLCoilLRCount) return 0;
|
KMem.WSR[nDataAddr] = nDataValue;
|
break;
|
#if (ENABLE_PLC)
|
case KLDataTypeSV:
|
if (nDataAddr >= KLDataSVCount) return 0;
|
PLCMem.SV[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeEV:
|
if (nDataAddr >= KLDataEVCount) return 0;
|
PLCMem.EV[nDataAddr] = nDataValue;
|
break;
|
#endif
|
case KLDataTypeLD:
|
if (nDataAddr >= KLDataLDCount) return 0;
|
KMem.DT[nDataAddr] = nDataValue;
|
break;
|
case KLDataSysCfg:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeFlash:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeTest:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
}
|
|
return 0;
|
}
|
|
|
int KMachineSvFunc (int nChn, int nSvType, int nParam,void * pBuf, int nLen1)
|
{
|
int iRet =0;
|
switch (nSvType){
|
case ReqNone:
|
break;
|
case ReqInit:
|
break;
|
case ReqReset:
|
break;
|
case ReqStop:
|
break;
|
case ReqRun:
|
break;
|
case ReqBlinkLED:
|
KMRunStat.bLEDFlick=nParam;
|
break;
|
case ReqStartDiag:
|
break;
|
case ReqStopDiag:
|
break;
|
case ReqTransFirmware:
|
break;
|
case ReqTransCfg:
|
break;
|
case ReqTransProg:
|
break;
|
case ReqTransData:
|
break;
|
case ReqTransBlink:
|
break;
|
case ReqTransChild:
|
break;
|
case ReqTransInfo:
|
break;
|
case ReqTransOutBandData:
|
break;
|
case ReqRead1Bit:
|
break;
|
case ReqWrite1Bit:
|
break;
|
case ReqReadBits:
|
break;
|
case ReqWriteBits:
|
break;
|
case ReqReadData:
|
break;
|
case ReqWriteData:
|
break;
|
case ReqRemoteTran:
|
break;
|
|
default:
|
iRet = -1;
|
break;
|
}
|
return iRet;
|
}
|
