F030C8xx_KBus.git

			@@ -7,8 +7,9 @@
			#include "KBus.h"
			#include "functions.h"
			#include "string.h"
			#include "stm32f0xx.h"

			int bMaster=0,bSlave=0;
			unsigned char bKBusMaster=0,bKBusSlave=0,bKBusRepeater=0;;

			unsigned char PacketBuf1[128];
			unsigned char PacketBuf2[128];
			@@ -16,27 +17,37 @@
			unsigned char BufferIn[16]={0};
			unsigned char BufferOut[16]={0};

			stChnStat ChnStats[8];
			unsigned char nAddr=0;
			stChnStat KBusChnStats[8];
			unsigned char nStationID=0;
			unsigned char nChilds;
			int ChildStat[16];
			unsigned char nCurPollId=0;
			unsigned char nSeq=0;

			volatile int MasterRecved=1;
			volatile int MasterRecvOK=1;
			volatile unsigned char KBusMasterRecved=1;
			volatile unsigned char KBusMasterRecvOK=1;

			volatile int SlaveRecved=1;
			unsigned int SendTimeuS=0;
			volatile int RecvTimeuS=0;
			volatile unsigned char KBusSlaveRecved=1;
			unsigned int KBusSendTimeuS=0;
			volatile int KBusRecvTimeuS=0;

			int DelayuS=0;
			int MaxDelayuS=0;
			int KBusDelayuS=0;
			int KBusMaxDelayuS=0;
			int ThisuS;

			volatile unsigned int nSlaveTick=0;

			unsigned char BCC(void * pData, int nSize)
			int Clk3=0;
			int SendTime,Latancy,LatancyClk,SendClk;

			volatile int nCount2=0;
			int TimeOutCount=0;
			int LastCircleStartTime=0;
			int CircleTime=0;

			unsigned char Datas[128];
			volatile int PacketLength = 0;

			unsigned char KBusBCC(void * pData, int nSize)
			{
			unsigned char k;
			k=0;
			@@ -46,7 +57,8 @@
			}
			return k;
			}
			int MakePacket(pPacket p1,unsigned char src, uchar dst, uchar nType,unsigned char nSEQ, unsigned char DataLen,void * pData )

			int KBusMakePacket(pKBPacket p1,unsigned char src, uchar dst, uchar nType,unsigned char nSEQ, unsigned char DataLen,void * pData )
			{
			p1->Sign=StartSign;
			p1->DstHost=dst;
			@@ -61,17 +73,17 @@
			case cmdPing:
			p1->PacketLen=DataLen;
			memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;

			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;
			case cmdPingReply:
			p1->PacketLen=DataLen;
			memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;
			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;
			case cmdRead:
			break;
			@@ -82,67 +94,67 @@
			case cmdWriteReply:
			p1->PacketLen=DataLen;
			if (DataLen !=0 ) memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;
			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;
			case cmdGetVersion:
			p1->PacketLen=DataLen;
			memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;
			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;
			case cmdVerInfo:
			p1->PacketLen=DataLen;
			memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;
			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;
			case cmdExChgData:
			p1->PacketLen=DataLen;
			memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;
			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;
			case cmdExChgDataReply:
			p1->PacketLen=DataLen;
			memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;
			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;

			case cmdSyncRead:
			p1->PacketLen=DataLen;
			memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;
			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;
			case cmdSyncWrite:
			p1->PacketLen=DataLen;
			memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;
			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;
			case cmdSequenRead:
			p1->PacketLen=DataLen;
			memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;
			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;

			case cmdSyncTime:
			p1->PacketLen=DataLen;
			memcpy(p1->data,pData,DataLen);
			p1->data[DataLen]=BCC(p1,sizeof(stPacket)+DataLen-1);
			p1->data[DataLen]=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			p1->data[DataLen+1]=EndSign;
			PacketLenth=sizeof(stPacket)+DataLen+1;
			PacketLenth=sizeof(stKBPacket)+DataLen+1;
			break;

			default:
			@@ -152,90 +164,90 @@
			return PacketLenth;
			}

			int CheckPacket(pPacket p1,int nLen1)
			int KBusCheckPacket(int nChn, pKBPacket p1, int nLen1)
			{
			if (p1->Sign != StartSign)
			{
			Uart2Stat.NotPacketErr++;
			ChnStats[nCurPollId].NotPkgErr++;
			KBusChnStats[nCurPollId].NotPkgErr++;
			return -1;
			}
			int DataLen=p1->PacketLen;
			if (DataLen>MaxPacketLength)
			{
			Uart2Stat.LengthErr++;
			ChnStats[nCurPollId].PkgLenErr++;
			KBusChnStats[nCurPollId].PkgLenErr++;
			return -1;
			}
			if (nLen1<DataLen+sizeof(stPacket)+1)
			if (nLen1<DataLen+sizeof(stKBPacket)+1)
			{
			//len4=sprintf(str3,"%d < %d + %d \r\n",len2,DataLen,sizeof(stPacket));
			//len4=sprintf(str3,"%d < %d + %d \r\n",len2,DataLen,sizeof(stKBPacket));
			//PutStr(str3,len4);
			ChnStats[nCurPollId].PkgLenErr++;
			KBusChnStats[nCurPollId].PkgLenErr++;
			Uart2Stat.LengthErr++;
			return -3; //not long enough
			}
			// if (p1->data[DataLen+1] != EndSign)
			// {
			// ChnStats[nCurPollId].NoEndErr++;
			// KBusChnStats[nCurPollId].NoEndErr++;
			// Uart2Stat.LengthErr++;
			// return -2;
			// }
			unsigned char thisBCC=BCC(p1,sizeof(stPacket)+DataLen-1);
			unsigned char thisBCC=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			if (thisBCC != p1->data[DataLen])
			{//BCC Error;
			Uart2Stat.BCCerr++;
			ChnStats[nCurPollId].BCCErr++;
			KBusChnStats[nCurPollId].BCCErr++;
			return -4;
			}
			return 0;
			}

			int SlaveCheckPacket(pPacket p1,int nLen1)
			int KBusSlaveCheckPacket(int nChn, pKBPacket p1, int nLen1)
			{
			if (p1->Sign != StartSign)
			{
			Uart2Stat.NotPacketErr++;
			ChnStats[0].ClientNotPktErr++;
			KBusChnStats[0].ClientNotPktErr++;
			return -1;
			}
			int DataLen=p1->PacketLen;
			if (DataLen>MaxPacketLength)
			{
			Uart2Stat.LengthErr++;
			ChnStats[0].ClientPkgLenErr++;
			KBusChnStats[0].ClientPkgLenErr++;
			return -1;
			}
			if (nLen1<DataLen+sizeof(stPacket)+1)
			if (nLen1<DataLen+sizeof(stKBPacket)+1)
			{
			//len4=sprintf(str3,"%d < %d + %d \r\n",len2,DataLen,sizeof(stPacket));
			//len4=sprintf(str3,"%d < %d + %d \r\n",len2,DataLen,sizeof(stKBPacket));
			//PutStr(str3,len4);
			ChnStats[0].ClientPkgLenErr++;
			KBusChnStats[0].ClientPkgLenErr++;
			Uart2Stat.LengthErr++;
			return -3; //not long enough
			}
			// if (p1->data[DataLen+1] != EndSign)
			// {
			// ChnStats[nCurPollId].NoEndErr++;
			// KBusChnStats[nCurPollId].NoEndErr++;
			// Uart2Stat.LengthErr++;
			// return -2;
			// }
			unsigned char thisBCC=BCC(p1,sizeof(stPacket)+DataLen-1);
			unsigned char thisBCC=KBusBCC(p1,sizeof(stKBPacket)+DataLen-1);
			if (thisBCC != p1->data[DataLen])
			{//BCC Error;
			Uart2Stat.BCCerr++;
			ChnStats[0].ClientBccErr++;
			KBusChnStats[0].ClientBccErr++;
			return -4;
			}
			return 0;
			}

			int MasterParsePacket(pPacket p1,int Len1)
			int KBusMasterParsePacket(int nChn, pKBPacket p1, int Len1)
			{

			int DataLen=p1->PacketLen;
			ChnStats[nCurPollId].RecvPackets++;
			pPacket p2=(pPacket)PacketBuf2;
			KBusChnStats[nCurPollId].RecvPackets++;
			pKBPacket p2=(pKBPacket)PacketBuf2;
			int PacketLen=0;
			//LL_GPIO_TogglePin(GPIOA,LL_GPIO_PIN_6);
			int ChildId=p1->SrcAddr;
			@@ -247,22 +259,22 @@
			break;
			case cmdPing:
			BufferIn[ChildId]=p1->data[0];
			PacketLen=MakePacket(p2,0,nCurPollId,cmdPingReply,p1->nSEQ,DataLen,p1->data);
			SendPacket2(p2,PacketLen);
			PacketLen=KBusMakePacket(p2,0,nCurPollId,cmdPingReply,p1->nSEQ,DataLen,p1->data);
			SendPacket(nChn, p2, PacketLen);
			break;
			case cmdPingReply:
			DelayuS=ThisuS-SendTimeuS;
			if (DelayuS > MaxDelayuS) MaxDelayuS = DelayuS;
			KBusDelayuS=ThisuS-KBusSendTimeuS;
			if (KBusDelayuS > KBusMaxDelayuS) KBusMaxDelayuS = KBusDelayuS;

			BufferIn[ChildId]=p1->data[0];

			//RunStat=100;
			ChnStats[nCurPollId].CtnLstPkts=0;
			ChnStats[nCurPollId].Delay=DelayuS;
			if (DelayuS > ChnStats[nCurPollId].MaxDelay)
			ChnStats[nCurPollId].MaxDelay=DelayuS;
			KBusChnStats[nCurPollId].CtnLstPkts=0;
			KBusChnStats[nCurPollId].Delay=KBusDelayuS;
			if (KBusDelayuS > KBusChnStats[nCurPollId].MaxDelay)
			KBusChnStats[nCurPollId].MaxDelay=KBusDelayuS;
			//PutOutput(outputvalue);
			MasterRecvOK=1;
			KBusMasterRecvOK=1;
			break;
			case cmdRead:
			break;
			@@ -271,7 +283,7 @@
			case cmdWrite:
			break;
			case cmdWriteReply:
			MasterRecved=1;
			KBusMasterRecved=1;
			break;
			case cmdGetVersion:
			break;
			@@ -282,31 +294,41 @@
			//PutOutput(outputvalue);
			//memcpy(DispBuf,p1->data+2,8);
			p1->data[0]=BufferOut[0];
			PacketLen=MakePacket(p2,nAddr,0,cmdExChgDataReply,p1->nSEQ,DataLen,p1->data);
			SendPacket2(p2,PacketLen);
			PacketLen=KBusMakePacket(p2,nStationID,0,cmdExChgDataReply,p1->nSEQ,DataLen,p1->data);
			SendPacket(nChn, p2, PacketLen);
			break;
			case cmdExChgDataReply:
			DelayuS=ThisuS-SendTimeuS;
			if (DelayuS > MaxDelayuS) MaxDelayuS = DelayuS;

			KBusDelayuS=ThisuS-KBusSendTimeuS;
			if (KBusDelayuS > KBusMaxDelayuS) KBusMaxDelayuS = KBusDelayuS;

			#if (BOARD_TYPE == 14)
			BufferIn[ChildId]=p1->data[0];
			KMem.WXB[ChildId-1]=BufferIn[ChildId];
			if (KMRunStat.WorkMode==0) {
			// KMem.WY[0]= KMem.WX[1]+(KMem.WX[2]<<8) ;
			// PutOutput (KMem.WY[0]);
			}
			#else
			BufferIn[ChildId]=p1->data[0];
			KMem.WX[ChildId]=BufferIn[ChildId];
			if (KMRunStat.WorkMode==0) {
			KMem.WY[0]= KMem.WX[1]+(KMem.WX[2]<<8) ;
			PutOutput (KMem.WY[0]);
			}
			#endif

			//RunStat=100;
			ChnStats[nCurPollId].CtnLstPkts=0;
			ChnStats[nCurPollId].Delay=DelayuS;
			if (DelayuS > ChnStats[nCurPollId].MaxDelay)
			ChnStats[nCurPollId].MaxDelay=DelayuS;
			KBusChnStats[nCurPollId].CtnLstPkts=0;
			KBusChnStats[nCurPollId].Delay=KBusDelayuS;
			if (KBusDelayuS > KBusChnStats[nCurPollId].MaxDelay)
			KBusChnStats[nCurPollId].MaxDelay=KBusDelayuS;
			//PutOutput(outputvalue);


			nIndex=p1->data[3];
			ChnStats[nCurPollId].ClientDatas[nIndex]=p1->data[4]\|(p1->data[5]<<8)\|(p1->data[6]<<16)\|(p1->data[7]<<24);
			KBusChnStats[nCurPollId].ClientDatas[nIndex]=p1->data[4]\|(p1->data[5]<<8)\|(p1->data[6]<<16)\|(p1->data[7]<<24);

			MasterRecvOK=1;
			KBusMasterRecvOK=1;

			break;

			@@ -321,28 +343,28 @@
			return 0;
			}
			unsigned char nClientDataIndex=0;
			int SlaveParsePacket(pPacket p1,int Len1)
			int KBusSlaveParsePacket(int nChn, pKBPacket p1, int Len1)
			{
			Uart2Stat.OKPacket++;
			int DataLen=p1->PacketLen;
			//int nSrcAddr=p1->SrcAddr;
			int nDstHost=p1->DstHost;

			// RecvTimeuS=ThisuS;
			// SlaveRecved=1;
			// KBusRecvTimeuS=ThisuS;
			// KBusSlaveRecved=1;

			pPacket p2=(pPacket)PacketBuf2;
			pKBPacket p2=(pKBPacket)PacketBuf2;
			int PacketLen=0;
			unsigned char nIndex = p1->nSEQ & 0x07;
			if (nDstHost!=nAddr && nDstHost != 0xff)
			if (nDstHost!=nStationID && nDstHost != 0xff)
			{
			ChnStats[0].ClientMisIdPkts++;
			KBusChnStats[0].ClientMisIdPkts++;
			return -1;
			}
			if (nDstHost==nAddr \|\| nDstHost==0xff)
			if (nDstHost==nStationID \|\| nDstHost==0xff)
			{
			RecvTimeuS=ThisuS;
			SlaveRecved=1;
			KBusRecvTimeuS=ThisuS;
			KBusSlaveRecved=1;
			switch (p1->nCMD)
			{
			case cmdNone:
			@@ -352,10 +374,10 @@
			//PutOutput(outputvalue);
			//memcpy(DispBuf,p1->data+2,8);
			p1->data[0]=BufferOut[0];
			RecvTimeuS=ThisuS;
			PacketLen=MakePacket(p2,nAddr,0,cmdPingReply,p1->nSEQ,DataLen,p1->data);
			ChnStats[0].ClientSendPkts++;
			SendPacket2(p2,PacketLen);
			KBusRecvTimeuS=ThisuS;
			PacketLen=KBusMakePacket(p2,nStationID,0,cmdPingReply,p1->nSEQ,DataLen,p1->data);
			KBusChnStats[0].ClientSendPkts++;
			SendPacket(nChn, p2, PacketLen);
			break;
			case cmdPingReply:
			break;
			@@ -365,9 +387,9 @@
			break;
			case cmdWrite:
			//memcpy(DispBuf,p1->data,DataLen);
			PacketLen=MakePacket(p2,1,0,cmdWriteReply,p1->nSEQ,0,0);
			ChnStats[0].ClientSendPkts++;
			SendPacket2(p2,PacketLen);
			PacketLen=KBusMakePacket(p2,1,0,cmdWriteReply,p1->nSEQ,0,0);
			KBusChnStats[0].ClientSendPkts++;
			SendPacket(nChn, p2, PacketLen);
			break;
			case cmdWriteReply:
			break;
			@@ -377,32 +399,35 @@
			break;
			case cmdExChgData:
			BufferIn[0]=p1->data[0];
			PutOutput(BufferIn[0]);
			PutOutput(BufferIn[0]);
			nSlaveTick=p1->data[4]+(p1->data[5]<<8);//+(p1->data[6]<<16)+(p1->data[7]<<24);

			#if (BOARD_TYPE == 14)
			// PutOutput(BufferIn[0]);
			//PutOutput(outputvalue);
			//memcpy(DispBuf,p1->data+2,8);
			nIndex=nClientDataIndex;
			// ChnStats[0].ClientDatas[7]++;
			// KBusChnStats[0].ClientDatas[7]++;
			// BufferOut[0]=GetInput();
			// BufferOut[0]=GetInput();
			// BufferOut[0]=GetInput();
			// BufferOut[0]=GetInput();
			// BufferOut[0]=GetInput();
			#else
			PutOutput(BufferIn[0]);
			//PutOutput(outputvalue);
			//memcpy(DispBuf,p1->data+2,8);
			nIndex=nClientDataIndex;
			// KBusChnStats[0].ClientDatas[7]++;
			// BufferOut[0]=GetInput();
			BufferOut[0]=GetInput();

			#endif
			p1->data[0]=BufferOut[0];
			p1->data[3]=nIndex;
			p1->data[4]=ChnStats[0].ClientDatas[nIndex];
			p1->data[5]=ChnStats[0].ClientDatas[nIndex]>>8;
			p1->data[6]=ChnStats[0].ClientDatas[nIndex]>>16;
			p1->data[7]=ChnStats[0].ClientDatas[nIndex]>>24;
			p1->data[4]=KBusChnStats[0].ClientDatas[nIndex];
			p1->data[5]=KBusChnStats[0].ClientDatas[nIndex]>>8;
			p1->data[6]=KBusChnStats[0].ClientDatas[nIndex]>>16;
			p1->data[7]=KBusChnStats[0].ClientDatas[nIndex]>>24;
			nClientDataIndex++;
			if (nClientDataIndex >= 10) { nClientDataIndex=0;}
			PacketLen=MakePacket(p2,nAddr,0,cmdExChgDataReply,p1->nSEQ,DataLen,p1->data);
			ChnStats[0].ClientSendPkts++;
			SendPacket2(p2,PacketLen);
			PacketLen=KBusMakePacket(p2,nStationID,0,cmdExChgDataReply,p1->nSEQ,DataLen,p1->data);
			KBusChnStats[0].ClientSendPkts++;
			SendPacket(nChn, p2, PacketLen);
			break;
			case cmdExChgDataReply:
			break;
			@@ -423,42 +448,42 @@
			}
			return 0;
			}
			int ParsePacket(pPacket p1,int Len1)
			int KBusParsePacket(int nChn, pKBPacket p1, int Len1)
			{
			ThisuS=GetuS();
			int Result=0;
			if (bMaster)
			if (bKBusMaster)
			{
			MasterRecved=1;
			Result=CheckPacket(p1,Len1);
			KBusMasterRecved=1;
			Result=KBusCheckPacket(nChn, p1, Len1);
			if (Result != S_OK)
			{
			return Result;
			}
			MasterRecvOK=1;
			Result=MasterParsePacket(p1,Len1);
			KBusMasterRecvOK=1;
			Result=KBusMasterParsePacket(nChn, p1, Len1);
			return Result;
			}
			if (bSlave)
			if (bKBusSlave)
			{
			ChnStats[0].ClientRecvPkts++;
			Result=SlaveCheckPacket(p1,Len1);
			KBusChnStats[0].ClientRecvPkts++;
			Result=KBusSlaveCheckPacket(nChn, p1, Len1);
			if (Result != S_OK)
			{
			return Result;
			}
			ChnStats[0].ClientTimeOutErr=KMem.RunStat;
			Result=SlaveParsePacket(p1,Len1);
			KBusChnStats[0].ClientTimeOutErr=KMem.RunStat;
			Result=KBusSlaveParsePacket(nChn, p1, Len1);
			return Result;
			}
			//int len1=p1->PacketLen;
			// if (p1->DstHost!=255&&p1->DstHost!=2) return -3;
			// pPacket p2=(pPacket)PacketBuf2;
			// pKBPacket p2=(pKBPacket)PacketBuf2;
			// Uart2Stat.OKPacket++;

			return Result;
			}

			/*
			int InitMachine(stMachineConfig * pConfig)
			{
			return S_OK;
			@@ -498,4 +523,133 @@
			{
			return S_OK;
			}
			*/
			int KBusRepeaterFunc(int nChn)
			{
			KMem.WY[0]=KMem.WX[0];
			if ((KMem.nRunCount &0x7f) == 88)
			{
			nCount2++;
			ToggleRunLed();
			// int len1=sprintf(str1,"%d %d Cfg %02X Input %02X \r\n",nCount,nCount2,EffJumperSW,MyKeyStat1);
			// PutStr(str1,len1);
			}
			return 0;
			}

			int KBusMasterFunc(int nChn)
			{
			uint32_t tick1=HAL_GetTick();
			uint32_t thisuS=GetuS();

			int len1=0;

			if ((KBusMasterRecved && KBusMasterRecvOK && thisuS-KBusSendTimeuS>50) \|\| thisuS-KBusSendTimeuS>1000u)
			{
			if (!KBusMasterRecvOK)
			{
			TimeOutCount++;
			Uart2Stat.TimeOutErr++;
			KBusChnStats[nCurPollId].LostPackets++;
			KBusChnStats[nCurPollId].CtnLstPkts++;
			if (!KBusMasterRecved) {KBusChnStats[nCurPollId].TimeOutErr++;}
			if (KBusChnStats[nCurPollId].CtnLstPkts>KBusChnStats[nCurPollId].MaxCtnLstPkts)
			{KBusChnStats[nCurPollId].MaxCtnLstPkts=KBusChnStats[nCurPollId].CtnLstPkts;}
			if (KBusChnStats[nCurPollId].CtnLstPkts>3)
			{
			KBusChnStats[nCurPollId].Stat=0;
			KMem.ErrStat=200;

			{BufferIn[nCurPollId]=0;}
			}
			// LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_7);
			}else
			{
			KBusChnStats[nCurPollId].Stat=1;

			KMem.RunStat=100;
			}
			nCurPollId ++;
			if (nCurPollId > nChilds)
			{
			CircleTime=thisuS-LastCircleStartTime;
			LastCircleStartTime=thisuS;
			nSeq++;
			nCurPollId=1;
			}
			#if (BOARD_TYPE == 14)
			if (KMRunStat.WorkMode==0)
			{
			// KMem.WX[0]= GetInput();
			// KMem.WY[1]=KMem.WX[0]&0xff;
			// KMem.WY[2]=(KMem.WX[0]>>8)&0xff;
			}
			// BufferOut[1]=KMem.WY[1];
			// BufferOut[2]=KMem.WY[2];
			#else
			if (KMRunStat.WorkMode==0)
			{
			KMem.WX[0]= GetInput();
			KMem.WY[1]=KMem.WX[0]&0xff;
			KMem.WY[2]=(KMem.WX[0]>>8)&0xff;
			}
			BufferOut[1]=KMem.WY[1];
			BufferOut[2]=KMem.WY[2];
			#endif

			Datas[0]=BufferOut[nCurPollId];
			Datas[1]=BufferOut[nCurPollId+1];;
			Datas[2]=KBusChnStats[nCurPollId].Stat;
			Datas[3]=0;
			Datas[4]=tick1&0xff;
			Datas[5]=(tick1>>8)&0xff;
			Datas[6]=(tick1>>16)&0xff;
			Datas[7]=(tick1>>24)&0xff;

			KBusSendTimeuS=thisuS;
			len1=KBusMakePacket((pKBPacket)PacketBuf1,0,nCurPollId,cmdExChgData,nSeq,8,Datas);
			SendPacket(nChn, (pKBPacket)PacketBuf1, len1);
			KBusChnStats[nCurPollId].SendPackets++;
			KBusChnStats[nCurPollId].SendTimeInterval=KBusSendTimeuS-KBusChnStats[nCurPollId].LastSentTimeuS;
			KBusChnStats[nCurPollId].LastSentTimeuS=KBusSendTimeuS;
			// PacketLength = len1;
			SendTime=tick1;

			KBusMasterRecved=0;
			KBusMasterRecvOK=0;
			// LL_GPIO_TogglePin(GPIOA,LL_GPIO_PIN_5);
			//ToggleErrLed();
			// ToggleOut8();

			}

			// Clk3=SysTick->VAL;
			// LL_GPIO_TogglePin(GPIOA,LL_GPIO_PIN_4);
			// HAL_Delay(1);
			return 0;
			}

			int KBusSlaveFunc(int nChn)
			{
			int ThisuS=GetuS();
			int thisRecvTime=KBusRecvTimeuS;
			if (KBusSlaveRecved)
			{
			KMem.RunStat=8000;
			KBusSlaveRecved=0;
			}else if ((ThisuS - thisRecvTime) >12000u)
			{
			KMem.ErrStat=8000;
			KMem.SDD[17]=1;
			KMem.SDD[18]=ThisuS;
			KMem.SDD[19]=KBusRecvTimeuS;
			}else if ( ThisuS > (thisRecvTime + 12000u))
			{
			KMem.ErrStat=8000;
			KMem.SDD[17]=2;
			KMem.SDD[18]=ThisuS;
			KMem.SDD[19]=KBusRecvTimeuS;
			}

			return 0;
			}