/**
|
******************************************************************************
|
* @file : KLink.c
|
* @brief : K-Link Protocol program body
|
******************************************************************************
|
*/
|
#include "KLink.h"
|
#include "functions.h"
|
#include "string.h"
|
#include "PLCFunctions.h"
|
#include "stm32f0xx_hal.h"
|
|
unsigned char KLPacketBuf1[256];
|
unsigned char KLPacketBuf2[256];
|
|
unsigned char KLBufferIn[16]={0};
|
unsigned char KLBufferOut[16]={0};
|
|
unsigned char nKLAddr=1;
|
unsigned char nKLSeq=0;
|
|
unKLStat nKLStatus ={0};
|
|
int KLThisuS=0;
|
int KLRecvTimeuS=0;
|
|
unsigned char KLBCC(void * pData, int nSize)
|
{
|
unsigned char k;
|
k=0;
|
for (int i=0;i<nSize;i++)
|
{
|
k^=((unsigned char *)pData)[i];
|
}
|
return k;
|
}
|
int KLMakeRplyPacket(void * pBuf, uchar dst, uchar Status, uchar nCmd, uchar DataLen,void * pData )
|
{
|
pKLRplyPktHdr p1 = (pKLRplyPktHdr)pBuf;
|
int PacketLenth=0;
|
p1->RplyStSgn=KLSignReply;
|
p1->DstAddr=dst;
|
p1->nStatus=Status;
|
p1->nRplyCMD=nCmd;
|
p1->nSize1=DataLen;
|
memcpy(p1->Datas,pData,DataLen);
|
p1->Datas[DataLen]=BCC(p1,sizeof(stKLRplyPktHdr)+DataLen-1);
|
PacketLenth=sizeof(stKLRplyPktHdr)+DataLen;
|
|
|
switch (nCmd)
|
{
|
case KLCmdNone:
|
PacketLenth=0;
|
break;
|
case KLCmdPing:
|
// case KLCmdPingReply:
|
//p1->data[DataLen+1]=KLEndSign;
|
//PacketLenth=sizeof(stKLPacket)+DataLen+1;
|
break;
|
case KLCmdRead:
|
// case KLCmdReadReply:
|
//p1->data[DataLen+1]=KLEndSign;
|
//PacketLenth=sizeof(stPacket)+DataLen+1;
|
break;
|
case KLCmdWrite:
|
// case KLCmdWriteReply:
|
break;
|
case KLCmdErrRply:
|
|
break;
|
default:
|
break;
|
}
|
|
return PacketLenth;
|
}
|
|
int KLCheckPacket(void * pBuf,int nLen1)
|
{
|
pKLReqPktHdr p1 = (pKLReqPktHdr) pBuf;
|
if (p1->ReqStSgn != KLSignStart)
|
{
|
return 1;
|
}
|
|
int DataLen=0; //p1->LoadLen;
|
if (DataLen>KLMaxPacketLength)
|
{
|
return 2;
|
}
|
if (nLen1<DataLen+sizeof(stKLReqPktHdr))
|
{
|
//len4=sprintf(str3,"%d < %d + %d \r\n",len2,DataLen,sizeof(stPacket));
|
//PutStr(str3,len4);
|
return 3; //not long enough
|
}
|
// if (p1->data[DataLen+1] != EndSign)
|
// {
|
// ChnStats[nCurPollId].NoEndErr++;
|
// Uart2Stat.LengthErr++;
|
// return -2;
|
// }
|
unsigned char thisBCC=KLBCC(p1,nLen1-1);
|
if (thisBCC != ((uchar *)pBuf)[nLen1-1])
|
{//BCC Error;
|
return 4;
|
}
|
return 0;
|
}
|
|
inline void SetAddrBit(unsigned short * pW, unsigned char bitAddr)
|
{
|
(*pW)|=bitMasks[bitAddr&0xf];
|
}
|
|
inline void ResetBit(unsigned short * pW, unsigned char bitAddr)
|
{
|
(*pW)&=~bitMasks[bitAddr&0xf];
|
}
|
|
static inline void SetBitValue(unsigned short * pW, unsigned char bitAddr, unsigned char Value)
|
{
|
if (Value) { SetAddrBit(pW, bitAddr);}
|
else {ResetBit(pW, bitAddr);}
|
}
|
int KLParseReqPacket(void * pBuf,int Len1)
|
{
|
pKLReqPktHdr p1 = (pKLReqPktHdr)pBuf;
|
|
int nDstAddr=p1->DstAddr;
|
KLRecvTimeuS=KLThisuS;
|
int nDataType=p1->nType1;
|
int nAddr=0;
|
int DataLen=0; //p1->LoadLen;
|
//int nSrcAddr=p1->SrcAddr;
|
|
nKLStatus.nSEQ = ((pKLStat)(&(p1->Stat)))->nSEQ;;
|
|
void * pData=0;
|
pKLRplyPktHdr p2=(pKLRplyPktHdr)KLPacketBuf2;
|
char rData[4];
|
|
int PacketLen=0;
|
KLRecvTimeuS=KLThisuS;
|
if (nDstAddr==nKLAddr || nDstAddr==0xff)
|
{
|
switch (p1->nCMD)
|
{
|
case KLCmdNone:
|
break;
|
case KLCmdPing:
|
DataLen=nDataType;
|
// KLBufferIn[0]=p1->Params[0];
|
// p1->Params[0]=KLBufferOut[0];
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,KLCmdPing,DataLen,p1->Params);
|
SendPacket1(p2,PacketLen);
|
break;
|
// case KLCmdPingReply:
|
// break;
|
case KLCmdInfo:
|
//if (nDataType == KLDataTypeDT)
|
DataLen= 4;
|
pData=&KMem.nEventCount;
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,p1->nCMD,DataLen,pData);
|
SendPacket1(p2,PacketLen);
|
break;
|
case KLCmdRead:
|
case KLCmdReadDataByte:
|
nAddr=p1->Params[0]+ (p1->Params[1]<<8);
|
DataLen= p1->Params[2];
|
if (nDataType ==KLDataTypeDT) { pData=KMem.DT+nAddr; }
|
else if (nDataType == KLDataTypeSDT) { pData=KMem.SDT+nAddr; }
|
else if (nDataType == KLDataTypeWX) { pData=KMem.WX+nAddr; }
|
else if (nDataType == KLDataTypeWY) { pData=KMem.WY+nAddr; }
|
else if (nDataType == KLDataTypeWR) { pData=KMem.WR+nAddr; }
|
else if (nDataType == KLDataTypeWLX) { pData=KMem.WLX+nAddr; }
|
else if (nDataType == KLDataTypeWLY) { pData=KMem.WLY+nAddr; }
|
else if (nDataType == KLDataTypeSV) { pData=KMem.SDT+nAddr; }
|
else if (nDataType == KLDataTypeEV) { pData=KMem.SDT+nAddr; }
|
else if (nDataType == KLDataTypeTest) { pData=KMem.SDT+nAddr; }
|
else if (nDataType == KLDataSysCfg) { pData = (unsigned short *)&KMSysCfg + nAddr;}
|
else if (nDataType == KLDataTypeFlash) { pData = (unsigned short *)FLASH_BASE + nAddr;}
|
else { pData=KLBufferOut+nAddr; }
|
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,p1->nCMD,DataLen,pData);
|
SendPacket1(p2,PacketLen);
|
|
break;
|
// case KLCmdReadReply:
|
// break;
|
case KLCmdWrite:
|
case KLCmdWriteDataByte:
|
|
//memcpy(DispBuf,p1->data,DataLen);
|
nAddr=p1->Params[0]+ (p1->Params[1]<<8);
|
DataLen= p1->Params[2];
|
if (nDataType ==KLDataTypeDT) { pData=KMem.DT+nAddr; }
|
else if (nDataType == KLDataTypeSDT) { pData=KMem.SDT+nAddr; }
|
else if (nDataType == KLDataTypeWX) { pData=KMem.WX+nAddr; }
|
else if (nDataType == KLDataTypeWY) { pData=KMem.WY+nAddr; }
|
else if (nDataType == KLDataTypeWR) { pData=KMem.WR+nAddr; }
|
else if (nDataType == KLDataTypeWLX) { pData=KMem.WLX+nAddr; }
|
else if (nDataType == KLDataTypeWLY) { pData=KMem.WLY+nAddr; }
|
else if (nDataType == KLDataTypeSV) { pData=KMem.SDT+nAddr; DataLen=0;}
|
else if (nDataType == KLDataTypeEV) { pData=KMem.SDT+nAddr; DataLen=0;}
|
else if (nDataType == KLDataTypeTest) { pData=KMem.SDT+nAddr; DataLen=0;}
|
else if (nDataType == KLDataSysCfg) { pData = (unsigned short *)&KMSysCfg + nAddr;}
|
else if (nDataType == KLDataTypeFlash) { pData = (unsigned short *)FLASH_BASE + nAddr;}
|
else { pData=KLBufferOut+nAddr; DataLen=0; }
|
|
memcpy(pData,p1->Params+4,DataLen);
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,p1->nCMD,0,0);
|
SendPacket1(p2,PacketLen);
|
break;
|
// case KLCmdWriteReply:
|
// break;
|
|
case KLCmdRead1Bit:
|
nAddr=p1->Params[0]+ (p1->Params[1]<<8);
|
DataLen = 1;
|
if (nDataType == KLCoilTypeX) { rData[0] = ((KMem.WX[nAddr>>4]&bitMasks[nAddr&0x0f])>0);}
|
else if (nDataType == KLCoilTypeY) { rData[0] = ((KMem.WY[nAddr>>4]&bitMasks[nAddr&0x0f])>0);}
|
else if (nDataType == KLCoilTypeR) { rData[0] = ((KMem.WR[nAddr>>4]&bitMasks[nAddr&0x0f])>0);}
|
else if (nDataType == KLCoilTypeLX) { rData[0] = ((KMem.WLX[nAddr>>4]&bitMasks[nAddr&0x0f])>0);}
|
else if (nDataType == KLCoilTypeLY) { rData[0] = ((KMem.WLY[nAddr>>4]&bitMasks[nAddr&0x0f])>0);}
|
else if (nDataType == KLCoilTypeT) { rData[0] = PLCMem.Timers[nAddr].bTon;}
|
else if (nDataType == KLCoilTypeC) { rData[0] = PLCMem.Timers[nAddr].bTon;}
|
else if (nDataType == KLCoilTypeLR) { rData[0] = 0;}
|
else {rData[0]=0;}
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,KLCmdRead1Bit,DataLen,rData);
|
SendPacket1(p2,PacketLen);
|
break;
|
case KLCmdWrite1Bit:
|
nAddr=p1->Params[0]+ (p1->Params[1]<<8);
|
if (nDataType == KLCoilTypeX) { SetBitValue( &KMem.WX[nAddr>>4],nAddr&0x0f,p1->Params[2]);}
|
else if (nDataType == KLCoilTypeY) { SetBitValue( &KMem.WY[nAddr>>4],nAddr&0x0f,p1->Params[2]);}
|
else if (nDataType == KLCoilTypeR) { SetBitValue( &KMem.WR[nAddr>>4],nAddr&0x0f,p1->Params[2]);}
|
else if (nDataType == KLCoilTypeLX) {SetBitValue( &KMem.WLX[nAddr>>4],nAddr&0x0f,p1->Params[2]);}
|
else if (nDataType == KLCoilTypeLY) {SetBitValue( &KMem.WLY[nAddr>>4],nAddr&0x0f,p1->Params[2]);}
|
else if (nDataType == KLCoilTypeT) { PLCMem.Timers[nAddr].bTon = p1->Params[2];}
|
else if (nDataType == KLCoilTypeC) { PLCMem.Timers[nAddr].bTon = p1->Params[2];}
|
else if (nDataType == KLCoilTypeLR) { ;}
|
else {rData[0]=0;}
|
DataLen=0;
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,KLCmdWrite1Bit,DataLen,rData);
|
SendPacket1(p2,PacketLen);
|
break;
|
case KLCmdReadBits:
|
break;
|
case KLCmdWriteBits:
|
break;
|
case KLCmdSaveSysCfg:
|
WriteSysCfgToFlash(&KMSysCfg);
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,KLCmdSaveSysCfg,0,0);
|
SendPacket1(p2,PacketLen);
|
break;
|
case KLCmdSaveRunStat:
|
SaveRunStat(&KMRunStat);
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,KLCmdSaveRunStat,0,0);
|
SendPacket1(p2,PacketLen);
|
break;
|
case KLCmdGetEventLogCount:
|
DataLen= 4;
|
pData=&KMem.nEventCount;
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,p1->nCMD,DataLen,pData);
|
SendPacket1(p2,PacketLen);
|
break;
|
case KLCmdGetEventLog:
|
nAddr=p1->Params[0]+ (p1->Params[1]<<8);
|
DataLen= p1->Params[2] * sizeof(stEventLog);
|
pData=GetEventLogAddr(nAddr);
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,p1->nCMD,DataLen,pData);
|
SendPacket1(p2,PacketLen);
|
break;
|
case KLCmdClearEventLog:
|
ClearEventLog();
|
PacketLen=KLMakeRplyPacket(p2,nDstAddr,nKLStatus.StatByte,KLCmdClearEventLog,0,0);
|
SendPacket1(p2,PacketLen);
|
break;
|
default:
|
DataLen=1;
|
rData[0]=KL_UNKNOWN;
|
PacketLen=KLMakeRplyPacket(p2,nKLAddr,nKLStatus.StatByte,KLCmdErrRply,DataLen,rData);
|
SendPacket1(p2,PacketLen);
|
break;
|
}
|
}
|
return 0;
|
}
|
int KLParsePacket(void * pBuf,int Len1)
|
{
|
pKLReqPktHdr p1 = (pKLReqPktHdr)pBuf;
|
KLThisuS=GetuS();
|
pKLRplyPktHdr p2=(pKLRplyPktHdr)KLPacketBuf2;
|
int PacketLen=Len1;
|
int Result=KLCheckPacket(p1,Len1);
|
if (Result != KL_OK)
|
{
|
int DataLen=4;
|
char rData[4];
|
rData[0]=Result;
|
|
PacketLen=KLMakeRplyPacket(p2,nKLAddr,nKLStatus.StatByte,KLCmdErrRply,DataLen,rData);
|
// PacketLen=KLMakePacket(p2,0,nAddr,cmdKLPing,p1->nSEQ,DataLen,rData);
|
SendPacket1(p2,PacketLen);
|
return Result;
|
}
|
// if (bMaster) Result=ParseMasterPacket(p1,Len1);
|
// memcpy(KLPacketBuf2,pBuf,Len1);
|
// SendPacket1(p2,PacketLen);
|
|
Result=KLParseReqPacket(p1,Len1);
|
|
//int len1=p1->PacketLen;
|
// if (p1->DstAddr!=255&&p1->DstAddr!=2) return -3;
|
// pPacket p2=(pPacket)PacketBuf2;
|
// Uart2Stat.OKPacket++;
|
|
return Result;
|
}
|
|
