/**
|
******************************************************************************
|
* @file : KBus.c
|
* @brief : K-Bus Protocol program body
|
******************************************************************************
|
*/
|
#include "KBus.h"
|
#include "functions.h"
|
#include "string.h"
|
#include "stm32f0xx.h"
|
|
//unsigned char bKBusMaster=0,bKBusSlave=0,bKBusRepeater=0;;
|
|
stKBusMem KBusMem;
|
|
int KBusLoadSavedConfig(stKBusDef * pKBus)
|
{
|
int iRet=0;
|
|
|
return iRet;
|
}
|
|
int KBusSaveConfig(int nChn)
|
{
|
int iRet=0;
|
|
return iRet;
|
|
}
|
|
int KBusInitMaster(stKBusDef * pKBus,KBusSendPktFuncDef KBusSendPacket, int nChildCount)
|
{
|
int iRet =0;
|
pKBus->MyStat = KBusStatInited;
|
pKBus->bMaster = 1;
|
pKBus->bSlave = 0;
|
pKBus->bRepeater =0;
|
pKBus->nChildCount = nChildCount;
|
pKBus->nStationId = 0;
|
pKBus->KBusEvCBFunc=0;
|
memset(pKBus->KBusChnStats,0,sizeof(pKBus->KBusChnStats));
|
pKBus->KBusEvCBFunc=NULL;
|
pKBus->KBusSvCBFunc=NULL;
|
pKBus->KBusSendPacket = KBusSendPacket;
|
pKBus->nCurPollId = 1;
|
|
for (int i=0;i<MAX_CLIENT;i++)
|
{
|
memset(&pKBus->KBusChnStats[i],0,sizeof(stChnStat));
|
}
|
for (int i=0;i<MAX_CLIENT;i++)
|
{
|
KBusMakeDefaultClildInfo(pKBus, i);
|
}
|
/*
|
stDeviceInfo * pDeviceInfo = &pKBus->DeviceInfos[1];
|
|
pDeviceInfo->DeviceType = 0;
|
pDeviceInfo->DeviceVer = 0;
|
pDeviceInfo->InBitCount = 16;
|
pDeviceInfo->OutBitCount = 16;
|
pDeviceInfo->AIWCount = 0;
|
pDeviceInfo->AQWCount = 0;
|
pDeviceInfo->DWStartAddr = 0;
|
pDeviceInfo->OutDWCount = 0;
|
*/
|
pKBus->KBusPort = (stPortDef){.nPortHardType = 4, .nPortUseType = 3, .bEnable = 1, .bRunning =1, .StationId = 0, .bMaster = 1, .nMaxStations = nChildCount,
|
.pInstance=pKBus , .ReqCommFunc = (CommFuncDef)KBusReqService};
|
|
KMRegisterPort(1,&pKBus->KBusPort);
|
return iRet;
|
};
|
|
int KBusInitSlave(stKBusDef * pKBus,KBusSendPktFuncDef KBusSendPacket, int nStationId, stDeviceInfo * pDeviceInfo)
|
{
|
int iRet =0;
|
pKBus->MyStat = KBusStatInited;
|
pKBus->bMaster = 0;
|
pKBus->bSlave = 1;
|
pKBus->bRepeater = 0;
|
pKBus->nChildCount = 0;
|
pKBus->nStationId = nStationId;
|
pKBus->pMyDeviceInfo = pDeviceInfo;
|
pKBus->KBusEvCBFunc = NULL;
|
pKBus->KBusSvCBFunc=NULL;
|
pKBus->KBusSendPacket = KBusSendPacket;
|
/*
|
for (int i=0;i<MAX_CLIENT;i++)
|
{
|
memset(&pKBus->KBusChnStats[i],0,sizeof(stChnStat));
|
}
|
*/
|
|
pKBus->KBusPort = (stPortDef){.nPortHardType = 4, .nPortUseType = 3, .bEnable = 1, .bRunning =1, .StationId = nStationId, .bMaster = 0, .pInstance = pKBus};
|
KMRegisterPort(1,&pKBus->KBusPort);
|
|
return iRet;
|
}
|
|
|
int KBusInit(stKBusDef * pKBus,KBusSendPktFuncDef KBusSendPacket, int bMaster, int nChildCount)
|
{
|
int iRet =0;
|
pKBus->MyStat = KBusStatInited;
|
if (bMaster ) {
|
KBusInitMaster(pKBus,KBusSendPacket,nChildCount);
|
}else {
|
KBusInitSlave(pKBus,KBusSendPacket,nChildCount,0);
|
}
|
// memset(pKBus->KBusChnStats,0,sizeof(pKBus->KBusChnStats));
|
return iRet;
|
|
}
|
|
int KBusSetEvCallBackFunc(stKBusDef * pKBus, KBusEvCBFuncDef CBFunc)
|
{
|
|
pKBus->KBusEvCBFunc = CBFunc;
|
// pKBus->bKBusEvCBFuncSet=1;
|
return 0;
|
}
|
|
//unsigned char tempdata [8] = {11,12,13,14,25,26,27,28};
|
int KBusReqService (stKBusDef * pKBus, int ReqId, int nParam1, int nParam2, void **pData, unsigned short * len1)
|
{
|
|
switch (ReqId) {
|
case ReqStartDiag:
|
break;
|
case ReqStopDiag:
|
break;
|
case ReqPortChnInfo:
|
*pData = &pKBus->KBusChnStats[nParam1];
|
*len1 = sizeof(stChnStat);
|
break;
|
case ReqPortChildInfo:
|
*pData = &pKBus->DeviceInfos[nParam1];
|
*len1 = sizeof(stDeviceInfo);
|
|
// *pData = tempdata;
|
// *len1 = sizeof(tempdata);
|
break;
|
case ReqBlinkLED:
|
if (pKBus->bReq == 1) return -1;
|
if (nParam1 != 0xff && nParam1> pKBus->nChildCount) return -2;
|
if (pKBus->bReq != 1 ) {
|
pKBus->bReq=1;
|
pKBus->nReqSvrId = ReqId;
|
pKBus->nReqChildId = nParam1;
|
pKBus->nReqParam = nParam2;
|
pKBus->nReqReCount = 0;
|
}
|
break;
|
|
case ReqTransBlink:
|
if (pKBus->bReq == 1) return -1;
|
if (nParam1 != 0xff && nParam1> pKBus->nChildCount) return -2;
|
if (pKBus->bReq != 1 ) {
|
pKBus->bReq=1;
|
pKBus->nReqSvrId = ReqId;
|
pKBus->nReqChildId = nParam1;
|
pKBus->nReqParam = nParam2;
|
pKBus->nReqReCount = 0;
|
}
|
break;
|
|
case ReqTransCfg:
|
break;
|
case ReqUpdateFirm:
|
if (pKBus->bReq == 1) return -1;
|
if (nParam1> pKBus->nChildCount) return -2;
|
if (pKBus->bReq != 1 ) {
|
pKBus->bReq=1;
|
pKBus->nReqSvrId = ReqId;
|
pKBus->nReqChildId = nParam1;
|
pKBus->nReqParam = nParam2;
|
pKBus->nReqReCount = 0;
|
if (*len1>0) {
|
memcpy(pKBus->pReqDatas,*pData,*len1);
|
pKBus->nReqDataLen = *len1;
|
pKBus->nReqDataOff = 0;
|
}
|
}
|
|
break;
|
|
case ReqTransFirmware:
|
break;
|
default:
|
if (pKBus->bReq == 1) return -1;
|
if (nParam1 != 0xff && nParam1> pKBus->nChildCount) return -2;
|
if (pKBus->bReq != 1 ) {
|
pKBus->bReq=1;
|
pKBus->nReqSvrId = ReqId;
|
pKBus->nReqChildId = nParam1;
|
pKBus->nReqParam = nParam2;
|
pKBus->nReqReCount = 0;
|
if (*len1>0) {
|
memcpy(pKBus->pReqDatas,*pData,*len1);
|
pKBus->nReqDataLen = *len1;
|
pKBus->nReqDataOff = 0;
|
}
|
}
|
break;
|
}
|
return 0;
|
}
|
|
int KBusStart(stKBusDef * pKBus)
|
{
|
int iRet = 0;
|
|
return iRet;
|
}
|
|
int KBusLoopProcess(stKBusDef * pKBus)
|
{
|
int iRet = 0;
|
if (pKBus->bMaster)
|
{
|
if (pKBus->nChildCount>0) KBusMasterFunc(&KBus1);
|
}
|
if (pKBus->bSlave)
|
{
|
KBusSlaveFunc(&KBus1);
|
}
|
if (pKBus->bRepeater)
|
{
|
}
|
if (pKBus->RunStat) {pKBus->RunStat--;}
|
if (pKBus->ErrStat) {pKBus->ErrStat--;}
|
return iRet;
|
}
|
|
int KBusRepeaterFunc(stKBusDef * pKBus)
|
{
|
if ((KMem.nRunCount &0x7f) == 88)
|
{
|
ToggleRunLed();
|
}
|
return 0;
|
}
|
|
int KBusUpdateChildInfo(stKBusDef * pKBus, int nChild, stDeviceInfo * pInfoBlock)
|
{
|
pKBus->DeviceInfos[nChild] = *pInfoBlock;
|
return 0;
|
}
|
|
int KBusMakeDefaultClildInfo(stKBusDef * pKBus, int nChild)
|
{
|
// unsigned DefaultInBitCount = 8;
|
// unsigned DefaultOutBitCount = 8;
|
|
// stDeviceInfo * pDeviceInfo = &pKBus->DeviceInfos[nChild];
|
pKBus->DeviceInfos[nChild] = (stDeviceInfo){
|
.DeviceType=0,
|
.DeviceVer=0,
|
.InBitCount=8,
|
.OutBitCount=8,
|
.AIWCount=0,
|
.AQWCount=0,
|
.DWStartAddr=0,
|
.OutDWCount=0
|
};
|
|
return 0;
|
}
|
|
//int KBusSetChildCfg(int nChn, int nChild, )
|
int KBusAddChildAddrByInfo(stKBusDef * pKBus, int nChild, stDeviceInfo * pDeviceInfo)
|
{
|
int iRet = 0;
|
stClientCfg * pClientCfg = &pKBus->ClientCfg[nChild];
|
|
pClientCfg->Addr = pKBus->nCurPollId;
|
pClientCfg->Configed = KBusConfiged;
|
pClientCfg->InStartAddrBit = pKBus->CurXBitAddr;
|
pClientCfg->OutStartAddrBit = pKBus->CurYBitAddr;
|
pClientCfg->AIWStartAddrByte = pKBus->CurAIWAddr;
|
pClientCfg->AQWStartAddrByte = pKBus->CurAQWAddr;
|
pClientCfg->DIWStartAddrByte = pKBus->CurDIWAddr;
|
pClientCfg->DOWStartAddrByte = pKBus->CurDOWAddr;
|
|
pKBus->CurXBitAddr += pDeviceInfo->InBitCount;
|
pKBus->CurYBitAddr += pDeviceInfo->OutBitCount;
|
pKBus->CurAIWAddr += pDeviceInfo->AIWCount;
|
pKBus->CurAQWAddr += pDeviceInfo->AQWCount;
|
|
return iRet;
|
}
|
|
|
int KBusSearchChildProc(stKBusDef * pKBus)
|
{
|
int iRet = 0;
|
uint32_t tick1=GetTick();
|
// uint32_t thisuS=GetuS();
|
int nThisPollId = pKBus->nCurPollId;
|
if (pKBus->bMasterSent) {
|
if (pKBus->bMasterRecved) {
|
pKBus->bMasterSent=0;
|
pKBus->RetryCount=0;
|
nThisPollId++;
|
pKBus->nCurPollId = nThisPollId;
|
if (nThisPollId > pKBus->nChildCount)
|
{
|
// all query done, next stage
|
pKBus->nCurPollId = 1;
|
pKBus->MyStat = KBusStatReady;
|
// CallBack
|
if (pKBus->KBusEvCBFunc) pKBus->KBusEvCBFunc(pKBus, KBusEvStateChange,0,0);
|
}
|
}
|
|
if (!pKBus->bMasterRecved && tick1- pKBus->SendTimeTick > KBUS_WAIT_TIME_OUT1)
|
{
|
/*
|
// timeOut,
|
if (pKBus->RetryCount <3) {
|
pKBus->RetryCount++;
|
// resent query packet for curPollId;
|
pKBus->bMasterSent=0; // no wait any more;
|
// pKBus->bMasterSent=1;
|
// pKBus->SendTimeTick = tick1;
|
}
|
if (pKBus->RetryCount >3 )
|
// */
|
{
|
// Set Cur Child As Default
|
KBusMakeDefaultClildInfo(pKBus,nThisPollId);
|
KBusAddChildAddrByInfo(pKBus,nThisPollId,&pKBus->DeviceInfos[nThisPollId]);
|
|
// Next Child;
|
pKBus->RetryCount=0;
|
nThisPollId++;
|
pKBus->nCurPollId = nThisPollId;
|
if (nThisPollId > pKBus->nChildCount)
|
{
|
// all query done, next stage
|
pKBus->nCurPollId = 1;
|
pKBus->MyStat = KBusStatReady;
|
// CallBack
|
if (pKBus->KBusEvCBFunc) pKBus->KBusEvCBFunc(pKBus, KBusEvStateChange,0,0);
|
}
|
pKBus->bMasterSent=0;
|
}
|
|
}
|
}else { // ! pKBus->bMasterSent »¹Ã»Óз¢ËÍ
|
// Sent Query Packet for CurPollId;
|
//pKBus->nCurPollId;
|
|
unStatus ThisStatus;
|
ThisStatus.nSeq = pKBus->nSeq;
|
ThisStatus.nErr1 = (pKBus->KBusChnStats[nThisPollId].MStat==0);
|
|
int len1=KBusMakePacket((pKBPacket)pKBus->PacketBuf2,0,nThisPollId,cmdQuery,ThisStatus.nStatus,0,NULL);
|
// LL_USART_SetBaudRate(USART2,48000000,LL_USART_OVERSAMPLING_8,DefaultUart2Baud);
|
pKBus->KBusSendPacket(pKBus->PacketBuf2, len1);
|
pKBus->KBusChnStats[nThisPollId].SendPackets++;
|
pKBus->KBusChnStats[nThisPollId].SendTimeInterval=pKBus->SendTimeTick-pKBus->KBusChnStats[nThisPollId].LastSentTimeTick;
|
pKBus->KBusChnStats[nThisPollId].LastSentTimeTick=pKBus->SendTimeTick;
|
// PacketLength = len1;
|
pKBus->SendTime=tick1;
|
|
pKBus->bMasterRecved=0;
|
pKBus->bMasterRecvOK=0;
|
|
pKBus->bMasterSent=1;
|
pKBus->SendTimeTick = tick1;
|
}
|
|
|
// pKBus->MyStat = KBusStatReady;
|
|
return iRet;
|
}
|
|
int KBusPacketSendDone(stKBusDef * pKBus)
|
{
|
switch (pKBus->MyStat){
|
case KBusStatUnInited:
|
break;
|
case KBusStatInited:
|
break;
|
case KBusStatConfig:
|
break;
|
case KBusStatReady:
|
break;
|
case KBusStatRunning:
|
switch(pKBus->nRunStep) {
|
case KBusRunStepBroadCastCfg:
|
pKBus->nRunStep = KBusRunStepTimeSync;
|
break;
|
case KBusRunStepTimeSync:
|
pKBus->nRunStep = KBusRunStepMultiDataPoll;
|
break;
|
case KBusRunStepMultiDataPoll:
|
pKBus->nRunStep = KBusRunStepUniDataPoll;
|
break;
|
case KBusRunStepUniDataPoll:
|
|
break;
|
case KBusRunStepUniDataTranster:
|
|
break;
|
default:
|
break;
|
}
|
// KBusDataPoll(pKBus);
|
break;
|
default:
|
break;
|
}
|
return 0;
|
}
|
|
|
|
int GoStep(stKBusDef * pKBus, enKBusRunStep NextStep)
|
{
|
pKBus->nRunStep = NextStep;
|
pKBus->TimeOutCount=0;
|
return 0;
|
}
|
|
int KBusMasterFunc(stKBusDef * pKBus)
|
{
|
int len1;
|
uint32_t tick1=GetTick();
|
ushort DataLen = 0;
|
switch (pKBus->MyStat){
|
case KBusStatUnInited:
|
KBusLoadSavedConfig(pKBus);
|
pKBus->MyStat = KBusStatInited;
|
pKBus->TimeOutCount=0;
|
break;
|
case KBusStatInited:
|
pKBus->TimeOutCount++;
|
if (pKBus->TimeOutCount>30){
|
pKBus->MyStat = KBusStatConfig;
|
pKBus->TimeOutCount = 0;
|
}
|
break;
|
case KBusStatConfig:
|
KBusSearchChildProc(pKBus);
|
break;
|
case KBusStatReady:
|
pKBus->MyStat = KBusStatRunning;
|
pKBus->nRunStep = KBusRunStepBroadCastCfg;
|
pKBus->TimeOutCount=0;
|
break;
|
case KBusStatRunning:
|
switch(pKBus->nRunStep) {
|
case KBusRunStepBroadCastCfg:
|
pKBus->TimeOutCount++;
|
if (pKBus->TimeOutCount>4){
|
pKBus->nRunStep = KBusRunStepTimeSync;
|
pKBus->TimeOutCount = 0;
|
}
|
break;
|
case KBusRunStepTimeSync:
|
pKBus->Datas[0]=tick1&0xff;
|
pKBus->Datas[1]=(tick1>>8)&0xff;
|
pKBus->Datas[2]=(tick1>>16)&0xff;
|
pKBus->Datas[3]=(tick1>>24)&0xff;
|
len1=KBusMakePacket((pKBPacket)pKBus->PacketBuf2,0,0xff,cmdSyncTime,pKBus->nSeq,4,pKBus->Datas);
|
pKBus->KBusSendPacket(pKBus->PacketBuf2, len1);
|
|
pKBus->nRunStep = KBusRunStepTimeSyncWait;
|
pKBus->TimeOutCount=0;
|
break;
|
case KBusRunStepTimeSyncWait:
|
pKBus->TimeOutCount++;
|
if (pKBus->TimeOutCount>2){
|
pKBus->nRunStep = KBusRunStepMultiDataPoll;
|
pKBus->TimeOutCount=0;
|
}
|
break;
|
case KBusRunStepMultiDataPoll:
|
pKBus->TimeOutCount++;
|
if (pKBus->TimeOutCount>1){
|
pKBus->nCurPollId = 1;
|
pKBus->nRunStep = KBusRunStepUniDataPoll;
|
pKBus->TimeOutCount=0;
|
}
|
break;
|
case KBusRunStepUniDataPoll:
|
KBusDataPoll(pKBus);
|
break;
|
case KBusRunStepUniDataTranster:
|
// ¿´ÊÇ·ñÓÐÔ¶³ÌÇëÇó
|
if (pKBus->bReq &&pKBus->nReqReCount<1)
|
{
|
pKBus->nReqDataHdr[0]=0;
|
pKBus->nReqDataHdr[1]=0;
|
pKBus->nReqDataHdr[2]=pKBus->nReqSvrId;
|
pKBus->nReqDataHdr[3]=pKBus->nReqParam;
|
// [4] Addr
|
// [5] Addr
|
// [6] nCount
|
DataLen = pKBus->nReqDataLen+2;
|
len1=KBusMakePacket((pKBPacket)pKBus->PacketBuf2,0,pKBus->nReqChildId,cmdRemoteReq,pKBus->nSeq,DataLen,&pKBus->nReqDataHdr[2]);
|
pKBus->KBusSendPacket(pKBus->PacketBuf2, len1);
|
pKBus->nReqReCount++;
|
}else {
|
|
}
|
pKBus->nRunStep = KBusRunStepUniDataTransterWait;
|
pKBus->TimeOutCount=0;
|
break;
|
case KBusRunStepUniDataTransterWait:
|
pKBus->TimeOutCount++;
|
if (pKBus->TimeOutCount>4){
|
if (pKBus->bReq ==1) {pKBus->bReq = 3;}
|
pKBus->nRunStep = KBusRunStepBroadCastCfg;
|
pKBus->TimeOutCount=0;
|
|
}
|
break;
|
default:
|
break;
|
}
|
break;
|
default:
|
break;
|
}
|
return 0;
|
}
|
|
int KBusDataPoll(stKBusDef * pKBus)
|
{
|
int iRet = 0;
|
uint32_t tick1=GetTick();
|
// uint32_t thisuS=GetuS();
|
int len1=0;
|
int nThisPollId = pKBus->nCurPollId;
|
|
stChnStat * pChnStat = &pKBus->KBusChnStats[nThisPollId];
|
if (!pKBus->bMasterSent){
|
pKBus->Datas[0]=KBusMem.WLYB[nThisPollId -1 ];
|
for (int i=1; i*8 < pKBus->DeviceInfos[nThisPollId].OutBitCount;i++){
|
pKBus->Datas[0+i]=KBusMem.WLYB[nThisPollId -1 + i];
|
}
|
|
// pKBus->Datas[1]=KBusMem.WLYB[nThisPollId ];;
|
// pKBus->Datas[2]=KBusMem.WLYB[nThisPollId + 1 ]; //KBusChnStats[nCurPollId].Stat;
|
// pKBus->Datas[3]=KBusMem.WLYB[nThisPollId + 2 ];
|
pKBus->Datas[4]=tick1&0xff;
|
pKBus->Datas[5]=(tick1>>8)&0xff;
|
pKBus->Datas[6]=(tick1>>16)&0xff;
|
pKBus->Datas[7]=(tick1>>24)&0xff;
|
|
pKBus->SendTimeTick=tick1;
|
unStatus ThisStatus;
|
ThisStatus.nStatus= pChnStat->MStat;
|
ThisStatus.nSeq = pKBus->nSeq;
|
//ThisStatus.nErr1 = (pChnStat->MStat==0);
|
// ThisStatus.nErr1 = 0;
|
len1=KBusMakePacket((pKBPacket)pKBus->PacketBuf2,0,nThisPollId,cmdUniExChgData,ThisStatus.nStatus,8,pKBus->Datas);
|
// LL_USART_SetBaudRate(USART2,48000000,LL_USART_OVERSAMPLING_8,DefaultUart2Baud);
|
|
pKBus->KBusSendPacket(pKBus->PacketBuf2, len1);
|
pChnStat->SendPackets++;
|
pChnStat->SendTimeInterval=pKBus->SendTimeTick - pChnStat->LastSentTimeTick;
|
pChnStat->LastSentTimeTick=pKBus->SendTimeTick;
|
// PacketLength = len1;
|
pKBus->SendTime=tick1;
|
pKBus->bMasterSent = 1;
|
pKBus->bMasterRecved=0;
|
pKBus->bMasterRecvOK=0;
|
// LL_GPIO_TogglePin(GPIOA,LL_GPIO_PIN_5);
|
//ToggleErrLed();
|
// ToggleOut8();
|
}else
|
{
|
|
if ((pKBus->bMasterRecved && pKBus->bMasterRecvOK && tick1-pKBus->SendTimeTick>1) || tick1-pKBus->SendTimeTick>KBUS_WAIT_TIME_OUT2)
|
{
|
if (!pKBus->bMasterRecvOK)
|
{
|
pKBus->TimeOutCount++;
|
// Uart2Stat.TimeOutErr++;
|
pChnStat->LostPackets++;
|
pChnStat->CtnLstPkts++;
|
if (!pKBus->bMasterRecved) {pChnStat->TimeOutErr++;}
|
if (pChnStat->CtnLstPkts > pChnStat->MaxCtnLstPkts)
|
{pChnStat->MaxCtnLstPkts = pChnStat->CtnLstPkts;}
|
if (pChnStat->CtnLstPkts>3)
|
{
|
pChnStat->MStat = 0;
|
pKBus->ErrStat=200;
|
KBusMem.WLXB[nThisPollId]=0;
|
if (pKBus->KBusEvCBFunc) pKBus->KBusEvCBFunc(pKBus, KBusEvStateChange,0,0);
|
if (pKBus->KBusEvCBFunc) pKBus->KBusEvCBFunc(pKBus, KBusEvDataUpdate,0,0);
|
|
}
|
// LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_7);
|
}else
|
{
|
// pChnStat->CtnLstPkts = 0;
|
// pKBus->KBusChnStats[nThisPollId].CtnLstPkts=0;
|
pChnStat->MStat=1;
|
|
pKBus->RunStat=100;
|
}
|
if (pKBus->DeviceInfos[nThisPollId].InBitCount >8 || pKBus->DeviceInfos[nThisPollId].OutBitCount > 8) {
|
nThisPollId += 2;
|
//nThisPollId ++;
|
}else {
|
nThisPollId ++;
|
}
|
if (nThisPollId > pKBus->nChildCount)
|
{
|
// Êý¾ÝÂÖѯÍê, ÖÜÆÚ¼ä϶,²åÈëÆäËû´¦ÀíÊý¾Ý. ÿ´Î´¦ÀíµÄʱ¼ä¼ä϶, Ò»ÎÊ Ò»´ð ʱ¼ä.
|
// ·Ö³É¼¸ÖÖÀàÐÍ, ÂÖÁ÷½øÐÐ
|
// ʱ¼äͬ²½, ²éѯÐÂ×Ó»ú, ´¦Àí´øÍâÊý¾Ý, ,´¦Àí¶îÍâµÄÊÂÇé, »òÕßÌø¹ý.
|
pKBus->CircleTime=tick1-pKBus->LastCircleStartTime;
|
pKBus->LastCircleStartTime=tick1;
|
pKBus->nSeq++;
|
GoStep(pKBus,KBusRunStepUniDataTranster);
|
//nThisPollId=1;
|
}else {
|
pKBus->nCurPollId = nThisPollId;
|
}
|
pKBus->bMasterSent = 0;
|
}
|
}
|
return iRet;
|
}
|
|
int KBusSlaveFunc(stKBusDef * pKBus)
|
{
|
// int ThisuS=GetuS();
|
int ThisTick = GetTick();
|
int thisRecvTime=pKBus->RecvTimeTick;
|
if (pKBus->nStationId >0) {
|
if (pKBus->bSlaveRecved)
|
{
|
pKBus->RunStat=8000;
|
pKBus->bSlaveRecved=0;
|
}else if ((ThisTick - thisRecvTime) > KBUS_SLAVE_TIME_OUT) // 30u
|
{
|
pKBus->ErrStat=7000;
|
}else if ( ThisTick > (thisRecvTime + KBUS_SLAVE_TIME_OUT)) // 30u
|
{
|
pKBus->ErrStat=7100;
|
}
|
}
|
return 0;
|
}
|
|
int KBusCheckPacket(stKBusDef * pKBus, pKBPacket p1, int nLen1)
|
{
|
unsigned char * p2 = (unsigned char *)p1;
|
pKBPacket p3=p1;
|
if ((p2[0] == KB_SYN || p2[0] != KBStartSign) && nLen1 > 1)
|
{
|
p3=(pKBPacket)(p2+1);
|
nLen1--;
|
}
|
|
if (p3->Sign != KBStartSign)
|
{
|
// pKBus->NotPacketErr++;
|
KMem.WDB[0x40]=pKBus->nCurPollId;
|
KMem.WDB[0x41]=nLen1;
|
memcpy(&KMem.WDB[0x42],p1,nLen1);
|
|
pKBus->KBusChnStats[pKBus->nCurPollId].NotPkgErr++;
|
if (pKBus->KBusDiagnosis) {
|
if (pKBus->KBusSnapPos == 0) {
|
KMem.WDB[0x20]=nLen1;
|
memcpy(&KMem.WDB[0x21],p1,nLen1);
|
pKBus->KBusSnapPos++;
|
} else if (pKBus->KBusSnapPos==1) {
|
KMem.WDB[0x40]=nLen1;
|
memcpy(&KMem.WDB[0x41],p1,nLen1);
|
pKBus->KBusSnapPos++;
|
} else {
|
KMem.WDB[0x60]=nLen1;
|
memcpy(&KMem.WDB[0x61],p1,nLen1);
|
pKBus->KBusSnapPos=0;
|
}
|
|
}
|
return -1;
|
}
|
int DataLen=p3->DataLen;
|
if (DataLen>KBMaxPacketLength)
|
{
|
// Uart2Stat.LengthErr++;
|
pKBus->KBusChnStats[pKBus->nCurPollId].PkgLenErr++;
|
return -1;
|
}
|
if (nLen1<DataLen+sizeof(stKBPacket)+1)
|
{
|
//len4=sprintf(str3,"%d < %d + %d \r\n",len2,DataLen,sizeof(stKBPacket));
|
//PutStr(str3,len4);
|
pKBus->KBusChnStats[pKBus->nCurPollId].PkgLenErr++;
|
// Uart2Stat.LengthErr++;
|
return -3; //not long enough
|
}
|
// if (p3->data[DataLen+1] != EndSign)
|
// {
|
// KBusChnStats[nCurPollId].NoEndErr++;
|
// Uart2Stat.LengthErr++;
|
// return -2;
|
// }
|
unsigned char thisBCC=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
if (thisBCC != p3->data[DataLen])
|
{//BCC Error;
|
// Uart2Stat.BCCerr++;
|
pKBus->KBusChnStats[pKBus->nCurPollId].BCCErr++;
|
return -4;
|
}
|
return 0;
|
}
|
|
int KBusSlaveCheckPacket(stKBusDef * pKBus, pKBPacket p1, int nLen1)
|
{
|
unsigned char * p2 = (unsigned char *)p1;
|
pKBPacket p3=p1;
|
if ((p2[0] == KB_SYN || p2[0] != KBStartSign) && nLen1 > 1)
|
{
|
p3=(pKBPacket)(p2+1);
|
nLen1--;
|
}
|
|
if (p3->Sign != KBStartSign)
|
{
|
// Uart2Stat.NotPacketErr++;
|
pKBus->KBusChnStats[0].ClientNotPktErr++;
|
return -1;
|
}
|
int DataLen=p3->DataLen;
|
if (DataLen>KBMaxPacketLength)
|
{
|
// Uart2Stat.LengthErr++;
|
pKBus->KBusChnStats[0].ClientPkgLenErr++;
|
return -1;
|
}
|
if (nLen1<DataLen+sizeof(stKBPacket)+1)
|
{
|
//len4=sprintf(str3,"%d < %d + %d \r\n",len2,DataLen,sizeof(stKBPacket));
|
//PutStr(str3,len4);
|
pKBus->KBusChnStats[0].ClientPkgLenErr++;
|
// Uart2Stat.LengthErr++;
|
return -3; //not long enough
|
}
|
// if (p3->data[DataLen+1] != EndSign)
|
// {
|
// KBusChnStats[nCurPollId].NoEndErr++;
|
// Uart2Stat.LengthErr++;
|
// return -2;
|
// }
|
unsigned char thisBCC=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
if (thisBCC != p3->data[DataLen])
|
{//BCC Error;
|
// Uart2Stat.BCCerr++;
|
pKBus->KBusChnStats[0].ClientBccErr++;
|
return -4;
|
}
|
return 0;
|
}
|
|
int KBusMasterParsePacket(stKBusDef * pKBus, pKBPacket p1, int Len1)
|
{
|
unsigned char * p6 = (unsigned char *)p1;
|
|
if ((p6[0] == KB_SYN || p6[0] != KBStartSign) && Len1 > 1)
|
{
|
p1=(pKBPacket)(p6+1);
|
Len1--;
|
}
|
|
int DataLen=p1->DataLen;
|
pKBus->KBusChnStats[pKBus->nCurPollId].RecvPackets++;
|
// pKBPacket p2=(pKBPacket)PacketBuf2;
|
// int PacketLen=0;
|
//LL_GPIO_TogglePin(GPIOA,LL_GPIO_PIN_6);
|
int nCurPollId = pKBus->nCurPollId;
|
int ChildId=p1->SrcAddr;
|
// int ThisuS = GetuS();
|
int ThisTick = GetTick();
|
unsigned char nIndex;
|
switch (p1->nCMD)
|
{
|
|
case cmdNone:
|
break;
|
case cmdQueryRply:
|
DataLen=sizeof(stDeviceInfo);
|
KBusUpdateChildInfo(pKBus,nCurPollId,(stDeviceInfo *)&p1->data[0]);
|
pKBus->KBusChnStats[nCurPollId].ClientSendPkts++;
|
break;
|
case cmdSetCfgRply:
|
break;
|
case cmdToRunModeRply:
|
break;
|
case cmdBroadCastCfg:
|
break;
|
case cmdMuExchgDataRply:
|
break;
|
case cmdToSafeMode:
|
break;
|
case cmdReHeartBeat:
|
break;
|
|
case cmdPing:
|
break;
|
case cmdPingReply:
|
pKBus->DelayTick = ThisTick - pKBus->SendTimeTick;
|
if (pKBus->DelayTick > pKBus->nMaxDelayTick) pKBus->nMaxDelayTick = pKBus->DelayTick;
|
|
KBusMem.WLXB[ChildId]=p1->data[0];
|
|
//RunStat=100;
|
pKBus->KBusChnStats[nCurPollId].CtnLstPkts=0;
|
pKBus->KBusChnStats[nCurPollId].Delay=pKBus->DelayTick;
|
if (pKBus->DelayTick > pKBus->KBusChnStats[nCurPollId].MaxDelay)
|
pKBus->KBusChnStats[nCurPollId].MaxDelay=pKBus->DelayTick;
|
//PutOutput(outputvalue);
|
pKBus->bMasterRecvOK=1;
|
break;
|
case cmdRead:
|
break;
|
case cmdReadReply:
|
break;
|
case cmdWrite:
|
break;
|
case cmdWriteReply:
|
pKBus->bMasterRecved=1;
|
break;
|
case cmdGetVersion:
|
break;
|
case cmdVerInfo:
|
break;
|
case cmdUniExChgData:
|
|
break;
|
case cmdExChgDataReply:
|
pKBus->DelayTick = ThisTick - pKBus->SendTimeTick;
|
if (pKBus->DelayTick > pKBus->nMaxDelayTick) pKBus->nMaxDelayTick = pKBus->DelayTick;
|
KBusMem.WLXB[ChildId - 1 ]=p1->data[0];
|
for (int i=1; i*8 < pKBus->DeviceInfos[ChildId].InBitCount;i++){
|
KBusMem.WLXB[ChildId - 1 + i]=p1->data[0 + i];;
|
}
|
// KBusMem.WLXB[ChildId+0]=p1->data[1];
|
// KBusMem.WLXB[ChildId+1]=p1->data[2];
|
// KBusMem.WLXB[ChildId+2]=p1->data[3];;
|
// KBusMem.WLXB[ChildId+3]=p1->data[4];
|
// KBusMem.WLXB[ChildId+4]=p1->data[5];
|
// KBusMem.WLXB[ChildId+5]=p1->data[6];
|
// KBusMem.WLXB[ChildId+6]=p1->data[7];
|
//Call Back
|
if (pKBus->KBusEvCBFunc) pKBus->KBusEvCBFunc(pKBus, KBusEvDataUpdate,0,0);
|
//RunStat=100;
|
pKBus->KBusChnStats[nCurPollId].CtnLstPkts=0;
|
pKBus->KBusChnStats[nCurPollId].Delay=pKBus->DelayTick;
|
if (pKBus->DelayTick > pKBus->KBusChnStats[nCurPollId].MaxDelay)
|
pKBus->KBusChnStats[nCurPollId].MaxDelay=pKBus->DelayTick;
|
//PutOutput(outputvalue);
|
|
if (DataLen>=14) {
|
nIndex=p1->data[9];
|
pKBus->KBusChnStats[nCurPollId].ClientDatas[nIndex]=p1->data[10]|(p1->data[11]<<8)|(p1->data[12]<<16)|(p1->data[13]<<24);
|
}
|
pKBus->bMasterRecvOK=1;
|
|
break;
|
case cmdRemoteReqReply:
|
pKBus->bReq = 2;
|
|
break;
|
default:
|
break;
|
}
|
// nCurPollId ++;
|
// if (nCurPollId > nChilds)
|
// {
|
// nCurPollId=1;
|
// }
|
return 0;
|
}
|
|
int KBusSlaveParsePacket(stKBusDef * pKBus, pKBPacket p1, int Len1)
|
{
|
unsigned char * p3 = (unsigned char *)p1;
|
if (p3[0] == KB_SYN && Len1 > 1)
|
{
|
p1=(pKBPacket)(p3+1);
|
Len1--;
|
}
|
|
// Uart2Stat.OKPacket++;
|
unsigned short Addr;
|
unsigned short DataLen=p1->DataLen;
|
//int nSrcAddr=p1->SrcAddr;
|
int nDstHost=p1->DstHost;
|
|
// KBusRecvTimeuS=ThisuS;
|
// KBusSlaveRecved=1;
|
|
pKBPacket p2=(pKBPacket)pKBus->PacketBuf2;
|
void * pData = 0;
|
int PacketLen=0;
|
unsigned char nIndex;// = p1->nStatus & 0x07;
|
if (nDstHost!=pKBus->nStationId && nDstHost != 0xff)
|
{
|
pKBus->KBusChnStats[0].ClientMisIdPkts++;
|
return -1;
|
}
|
// int ThisuS = GetuS();
|
int ThisTick = GetTick();
|
if (nDstHost==0xff){
|
pKBus->RecvTimeTick=ThisTick;
|
pKBus->bSlaveRecved=1;
|
switch (p1->nCMD)
|
{
|
case cmdNone:
|
break;
|
case cmdBroadCastCfg:
|
|
break;
|
case cmdMuExchgData:
|
|
break;
|
case cmdToSafeMode:
|
|
break;
|
case cmdHeartBeat:
|
break;
|
case cmdSyncRead:
|
break;
|
case cmdSyncWrite:
|
break;
|
case cmdSequenRead:
|
break;
|
case cmdSyncTime:
|
pKBus->nSlaveTick=p1->data[0]+(p1->data[1]<<8)+(p1->data[2]<<16)+(p1->data[3]<<24);
|
if (pKBus->KBusEvCBFunc) pKBus->KBusEvCBFunc(pKBus, KBusEvTimeSync,0,0);
|
break;
|
case cmdRemoteReq: //ÊÕµ½RemoteÇëÇó
|
// KBusSlaveRunRemoteReq(pKBus,p1->data[0],p1->data, DataLen);
|
// data[0] -> reqSvr;
|
// data[1] -> param;
|
switch (p1->data[0]) {
|
case ReqBlinkLED:
|
case ReqTransBlink:
|
KMRunStat.bLEDFlick=p1->data[1];
|
DataLen = 0;
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdRemoteReqReply,p1->nStatus,DataLen,p1->data);
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
break;
|
case ReqUpdateFirm: //37¸ö×Ö½Ú
|
DataLen = 0;
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdRemoteReqReply,p1->nStatus,DataLen,p1->data);
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
pData = &p1->data[5];
|
Addr = p1->data[2] + (p1->data[3] <<8);
|
DataLen = p1->data[4] ;
|
KMRunService(p1->data[0],Addr,0,&pData,&DataLen);
|
DataLen=0;
|
break;
|
case ReqUpdateFirmInfo:
|
DataLen = 0;
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdRemoteReqReply,p1->nStatus,DataLen,p1->data);
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
pData = &p1->data[5];
|
Addr = p1->data[2] + (p1->data[3] <<8);
|
DataLen = p1->data[4] ;
|
KMRunService(p1->data[0],Addr,0,&pData,&DataLen);
|
DataLen=0;
|
break;
|
default:
|
pData = &p1->data[5];
|
Addr = p1->data[2] + (p1->data[3] <<8);
|
DataLen = p1->data[4] ;
|
KMRunService(p1->data[0],p1->data[1],0,&pData,&DataLen);
|
DataLen = 0;
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdRemoteReqReply,p1->nStatus,DataLen,p1->data);
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
DataLen=0;
|
|
break;
|
}
|
break;
|
default:
|
break;
|
}
|
|
}
|
|
if (nDstHost==pKBus->nStationId)
|
{
|
pKBus->RecvTimeTick=ThisTick;
|
pKBus->bSlaveRecved=1;
|
switch (p1->nCMD)
|
{
|
case cmdNone:
|
break;
|
case cmdQuery:
|
DataLen=sizeof(stDeviceInfo);
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdQueryRply,p1->nStatus,DataLen,pKBus->pMyDeviceInfo);
|
pKBus->KBusChnStats[0].ClientSendPkts++;
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
break;
|
case cmdSetCfg:
|
break;
|
case cmdToRunMode:
|
break;
|
case cmdBroadCastCfg:
|
break;
|
case cmdMuExchgData:
|
break;
|
case cmdToSafeMode:
|
break;
|
case cmdHeartBeat:
|
break;
|
|
case cmdPing:
|
KBusMem.WLYB[0]=p1->data[0];
|
//PutOutput(outputvalue);
|
//memcpy(DispBuf,p1->data+2,8);
|
p1->data[0]=KBusMem.WLXB[0];
|
//pKBus->RecvTimeuS=ThisuS;
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdPingReply,p1->nStatus,DataLen,p1->data);
|
pKBus->KBusChnStats[0].ClientSendPkts++;
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
break;
|
case cmdPingReply:
|
break;
|
case cmdRead:
|
break;
|
case cmdReadReply:
|
break;
|
case cmdWrite:
|
//memcpy(DispBuf,p1->data,DataLen);
|
PacketLen=KBusMakePacket(p2,1,0,cmdWriteReply,p1->nStatus,0,0);
|
pKBus->KBusChnStats[0].ClientSendPkts++;
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
break;
|
case cmdWriteReply:
|
break;
|
case cmdGetVersion:
|
break;
|
case cmdVerInfo:
|
break;
|
case cmdUniExChgData:
|
KBusMem.WLYB[0]=p1->data[0];
|
KBusMem.WLYB[1]=p1->data[1];
|
KBusMem.WLYB[2]=p1->data[2];
|
KBusMem.WLYB[3]=p1->data[3];
|
|
// pKBus->nSlaveTick=p1->data[4]+(p1->data[5]<<8);//+(p1->data[6]<<16)+(p1->data[7]<<24);
|
|
if (pKBus->KBusEvCBFunc) pKBus->KBusEvCBFunc(pKBus, KBusEvTimeSync,0,0);
|
|
if (pKBus->KBusEvCBFunc) pKBus->KBusEvCBFunc(pKBus, KBusEvDataUpdate,0,0);
|
|
nIndex=pKBus->nClientDataIndex;
|
p1->data[0]=KBusMem.WLXB[0];
|
p1->data[1]=KBusMem.WLXB[1];
|
p1->data[2]=KBusMem.WLXB[2];
|
p1->data[3]=KBusMem.WLXB[3];
|
p1->data[4]=KBusMem.WLXB[4];
|
p1->data[5]=KBusMem.WLXB[5];
|
p1->data[6]=KBusMem.WLXB[6];
|
p1->data[7]=KBusMem.WLXB[7];
|
|
p1->data[9]=nIndex;
|
p1->data[10]=pKBus->KBusChnStats[0].ClientDatas[nIndex];
|
p1->data[11]=pKBus->KBusChnStats[0].ClientDatas[nIndex]>>8;
|
p1->data[12]=pKBus->KBusChnStats[0].ClientDatas[nIndex]>>16;
|
p1->data[13]=pKBus->KBusChnStats[0].ClientDatas[nIndex]>>24;
|
pKBus->nClientDataIndex++;
|
DataLen = 14;
|
if (pKBus->nClientDataIndex >= 10) { pKBus->nClientDataIndex=0;}
|
unStatus nStatus;
|
nStatus.nStatus = p1->nStatus;
|
if (nStatus.nErr1) { pKBus->ErrStat=8100;}
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdExChgDataReply,p1->nStatus,DataLen,p1->data);
|
pKBus->KBusChnStats[0].ClientSendPkts++;
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
break;
|
case cmdExChgDataReply:
|
break;
|
|
|
case cmdSyncRead:
|
break;
|
case cmdSyncWrite:
|
break;
|
case cmdSequenRead:
|
break;
|
case cmdSyncTime:
|
break;
|
|
case cmdRemoteReq: //ÊÕµ½RemoteÇëÇó
|
// KBusSlaveRunRemoteReq(pKBus,p1->data[0],p1->data, DataLen);
|
// data[0] -> reqSvr;
|
// data[1] -> param;
|
switch (p1->data[0]) {
|
case ReqBlinkLED:
|
case ReqTransBlink:
|
KMRunStat.bLEDFlick=p1->data[1];
|
DataLen = 0;
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdRemoteReqReply,p1->nStatus,DataLen,p1->data);
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
break;
|
case ReqUpdateFirm: //37¸ö×Ö½Ú
|
DataLen = 0;
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdRemoteReqReply,p1->nStatus,DataLen,p1->data);
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
pData = &p1->data[5];
|
Addr = p1->data[2] + (p1->data[3] <<8);
|
DataLen = p1->data[4] ;
|
KMRunService(p1->data[0],Addr,0,&pData,&DataLen);
|
DataLen=0;
|
break;
|
case ReqUpdateFirmInfo:
|
DataLen = 0;
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdRemoteReqReply,p1->nStatus,DataLen,p1->data);
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
pData = &p1->data[5];
|
Addr = p1->data[2] + (p1->data[3] <<8);
|
DataLen = p1->data[4] ;
|
KMRunService(p1->data[0],Addr,0,&pData,&DataLen);
|
DataLen=0;
|
break;
|
default:
|
pData = &p1->data[5];
|
Addr = p1->data[2] + (p1->data[3] <<8);
|
DataLen = p1->data[4] ;
|
KMRunService(p1->data[0],p1->data[1],0,&pData,&DataLen);
|
DataLen = 0;
|
PacketLen=KBusMakePacket(p2,pKBus->nStationId,0,cmdRemoteReqReply,p1->nStatus,DataLen,p1->data);
|
pKBus->KBusSendPacket((uchar *)p2, PacketLen);
|
DataLen=0;
|
|
break;
|
}
|
break;
|
|
default:
|
break;
|
}
|
}
|
return 0;
|
}
|
|
int KBusSlaveRunRemoteReq(stKBusDef * pKBus, int nReqSvrId, unsigned char * pData , int Len1)
|
{
|
int PacketLen;
|
switch (nReqSvrId) {
|
case ReqTransBlink:
|
KMRunStat.bLEDFlick=5;
|
// PacketLen=KBusMakePacket(pKBus->PacketBuf2,pKBus->nStationId,0,cmdRemoteReq,p1->nStatus,DataLen,p1->data);
|
break;
|
default:
|
break;
|
}
|
return 0;
|
}
|
|
int KBusParsePacket(stKBusDef * pKBus, pKBPacket p1, int Len1)
|
{
|
int ThisuS=GetuS();
|
int Result=0;
|
unsigned char * p2 = (unsigned char *)p1;
|
if (p2[0] == KB_SYN && Len1 > 1)
|
{
|
p1=(pKBPacket)(p2+1);
|
Len1--;
|
}
|
|
if (pKBus->bMaster)
|
{
|
pKBus->bMasterRecved=1;
|
Result=KBusCheckPacket(pKBus, p1, Len1);
|
if (Result != S_OK)
|
{
|
|
return Result;
|
}
|
pKBus->bMasterRecvOK=1;
|
Result=KBusMasterParsePacket(pKBus, p1, Len1);
|
return Result;
|
}
|
if (pKBus->bSlave)
|
{
|
pKBus->KBusChnStats[0].ClientRecvPkts++;
|
Result=KBusSlaveCheckPacket(pKBus, p1, Len1);
|
if (Result != S_OK)
|
{
|
return Result;
|
}
|
pKBus->KBusChnStats[0].ClientTimeOutErr=pKBus->RunStat;
|
Result=KBusSlaveParsePacket(pKBus, p1, Len1);
|
return Result;
|
}
|
//int len1=p1->PacketLen;
|
// if (p1->DstHost!=255&&p1->DstHost!=2) return -3;
|
// pKBPacket p2=(pKBPacket)PacketBuf2;
|
// Uart2Stat.OKPacket++;
|
|
return Result;
|
}
|
|
/*
|
int InitMachine(stMachineConfig * pConfig)
|
{
|
return S_OK;
|
}
|
|
int SetConfig(void)
|
{
|
return S_OK;
|
}
|
|
int StartConfig(void)
|
{
|
return S_OK;
|
}
|
|
int SetMasterConfig(void)
|
{
|
return S_OK;
|
}
|
|
int StartPolling(void)
|
{
|
return S_OK;
|
}
|
|
int ReadData(void)
|
{
|
return S_OK;
|
}
|
|
int WriteData(void)
|
{
|
return S_OK;
|
}
|
|
int GetStat(void)
|
{
|
return S_OK;
|
}
|
*/
|
|
|
|
unsigned char KBusBCC(void * pData, int nSize)
|
{
|
unsigned char k;
|
k=0;
|
for (int i=0;i<nSize;i++)
|
{
|
k^=((unsigned char *)pData)[i];
|
}
|
return k;
|
}
|
|
int KBusMakePacket(pKBPacket p1,unsigned char src, uchar dst, uchar nType,unsigned char nStatus, unsigned char DataLen,void * pData )
|
{
|
p1->Sign=KBStartSign;
|
p1->DstHost=dst;
|
p1->SrcAddr=src;
|
p1->nCMD=nType;
|
p1->nStatus=nStatus;
|
int PacketLenth=0;
|
switch (nType)
|
{
|
case cmdNone:
|
break;
|
case cmdPing:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
case cmdPingReply:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
case cmdRead:
|
break;
|
case cmdReadReply:
|
break;
|
case cmdWrite:
|
break;
|
case cmdWriteReply:
|
p1->DataLen=DataLen;
|
if (DataLen !=0 ) memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
case cmdGetVersion:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
case cmdVerInfo:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
case cmdUniExChgData:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
case cmdExChgDataReply:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
|
case cmdSyncRead:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
case cmdSyncWrite:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
case cmdSequenRead:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
|
case cmdSyncTime:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
|
default:
|
p1->DataLen=DataLen;
|
memcpy(p1->data,pData,DataLen);
|
p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
|
p1->data[DataLen+1]=KBEndSign;
|
PacketLenth=sizeof(stKBPacket)+DataLen+1;
|
break;
|
}
|
|
return PacketLenth;
|
}
|
