blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
QuakeGod
2023-02-01 4392349b649164f2b498ca5157ecd141631ea96f 
 Src/KLink.c


@@ -16,7 +16,7 @@


unsigned char KLBufferIn[16]={0};



unsigned char KLBufferOut[16]={0};







unsigned  char nKLAddr=1;



unsigned  char nKLStationId=1;



unsigned  char nKLSeq=0;







unKLStat nKLStatus ={0};



@@ -61,7 +61,7 @@


      case KLCmdRead:



//      case KLCmdReadReply:



         //p1->data[DataLen+1]=KLEndSign;



         //PacketLenth=sizeof(stPacket)+DataLen+1;



         //PacketLenth=sizeof(stKBPacket)+DataLen+1;



         break;



      case KLCmdWrite:



//      case KLCmdWriteReply:



@@ -91,13 +91,13 @@


   }



   if (nLen1<DataLen+sizeof(stKLReqPktHdr))



   {



      //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);



      return 3;   //not long enough               



   }



//   if (p1->data[DataLen+1] != EndSign)



//   {



//      ChnStats[nCurPollId].NoEndErr++;



//      KBusChnStats[nCurPollId].NoEndErr++;



//      Uart2Stat.LengthErr++;      



//      return -2;



//   }



@@ -129,11 +129,13 @@


{



   pKLReqPktHdr p1 = (pKLReqPktHdr)pBuf;







   int nDstHost=p1->DstHost;



   unsigned char nDstHost=p1->DstHost;



   KLRecvTimeuS=KLThisuS;



   int nDataType=p1->nType1;



   int nAddr=0;



   int DataLen=0;   //p1->LoadLen;



   unsigned char nDataType=p1->nType1;



   unsigned short nWordAddr=0;



   unsigned short nByteAddr=0;



   unsigned short nBitAddr=0;



   unsigned short DataLen=0;   //p1->LoadLen;



//int nSrcAddr=p1->SrcAddr;







   nKLStatus.nSEQ = ((pKLStat)(&(p1->Stat)))->nSEQ;;



@@ -144,7 +146,7 @@






   int PacketLen=0;



   KLRecvTimeuS=KLThisuS;



   if (nDstHost==nKLAddr || nDstHost==0xff)



   if (nDstHost==nKLStationId || nDstHost==0xff)



   {



      switch (p1->nCMD)



      {



@@ -183,7 +185,7 @@


            SendPacket(nChn, p2, PacketLen);            



            break;



         case KLCmdWriteFactoryData:



            nAddr=p1->Params[0]+ (p1->Params[1]<<8);



            nWordAddr=p1->Params[0]+ (p1->Params[1]<<8);



            DataLen= p1->Params[2];



            //DataLen=16;



            for (int i=0;i<DataLen;i++)



@@ -196,22 +198,24 @@


         case KLCmdRead:



         case KLCmdReadDataWord:



         case KLCmdReadDataByte:            



            nAddr=p1->Params[0]+ (p1->Params[1]<<8);



            nWordAddr=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 == KLDataTypeWSR)   {      pData=KMem.WSR+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.SV+nAddr;   }



            else if (nDataType == KLDataTypeEV)      {      pData=KMem.EV+nAddr;   }



            else if (nDataType == KLDataTypeTest)   {      pData=KMem.SDT+nAddr;   }



            else if (nDataType == KLDataSysCfg) { pData = (unsigned short *)&storedKMSysCfg + nAddr;}



            else if (nDataType == KLDataTypeFlash) { pData = (unsigned short *)FLASH_BASE + nAddr;}



            else            {               pData=KLBufferOut+nAddr;            }



            if (nDataType ==KLDataTypeDT)            {         pData=KMem.DT+nWordAddr;      }



            else if (nDataType == KLDataTypeSDT)   {      pData=KMem.SDT+nWordAddr;   }



            else if (nDataType == KLDataTypeWSR)   {      pData=KMem.WSR+nWordAddr;   }



            else if (nDataType == KLDataTypeWX)      {      pData=KMem.WX+nWordAddr;      }



            else if (nDataType == KLDataTypeWY)      {      pData=KMem.WY+nWordAddr;      }



            else if (nDataType == KLDataTypeWR)      {      pData=KMem.WR+nWordAddr;      }



            else if (nDataType == KLDataTypeWLX)      {      pData=KMem.WLX+nWordAddr;      }



            else if (nDataType == KLDataTypeWLY)      {      pData=KMem.WLY+nWordAddr;      }



            else if (nDataType == KLDataTypeSV)      {      pData=KMem.SV+nWordAddr;   }



            else if (nDataType == KLDataTypeEV)      {      pData=KMem.EV+nWordAddr;   }



            else if (nDataType == KLDataTypeTest)   {      pData=KMem.SDT+nWordAddr;   }



            else if (nDataType == KLDataTypeWDT)   {      pData=KMem.WDT+nWordAddr;   }



            else if (nDataType == KLDataTypeKBD)   {      pData=(unsigned short *)&KBusChnStats  +nWordAddr;   }



            else if (nDataType == KLDataSysCfg) { pData = (unsigned short *)&storedKMSysCfg.theKMSysCfg + nWordAddr;}



            else if (nDataType == KLDataTypeFlash) { pData = (unsigned short *)FLASH_BASE + nWordAddr;}



            else            {               pData=KLBufferOut+nWordAddr;            }



            



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,p1->nCMD,DataLen,pData);



            SendPacket(nChn, p2, PacketLen);



@@ -224,22 +228,24 @@


         case KLCmdWriteDataByte:



            



            //memcpy(DispBuf,p1->data,DataLen);



            nAddr=p1->Params[0]+ (p1->Params[1]<<8);



            nWordAddr=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 == KLDataTypeWSR)   {      pData=KMem.WSR+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.SV+nAddr;   DataLen=0;}



            else if (nDataType == KLDataTypeEV)      {      pData=KMem.EV+nAddr;   DataLen=0;}



            else if (nDataType == KLDataTypeTest)   {      pData=KMem.SDT+nAddr;   DataLen=0;}



            else if (nDataType == KLDataSysCfg)      { pData = (unsigned short *)&storedKMSysCfg + nAddr;}



            else if (nDataType == KLDataTypeFlash) { pData = (unsigned short *)FLASH_BASE + nAddr;}



            else            {               pData=KLBufferOut+nAddr;   DataLen=0;         }



               if (nDataType ==KLDataTypeDT)            {      pData=KMem.DT+nWordAddr;      }



            else if (nDataType == KLDataTypeSDT)   {      pData=KMem.SDT+nWordAddr;   }



            else if (nDataType == KLDataTypeWSR)   {      pData=KMem.WSR+nWordAddr;   }



            else if (nDataType == KLDataTypeWX)      {      pData=KMem.WX+nWordAddr;      }



            else if (nDataType == KLDataTypeWY)      {      pData=KMem.WY+nWordAddr;      }



            else if (nDataType == KLDataTypeWR)      {      pData=KMem.WR+nWordAddr;      }



            else if (nDataType == KLDataTypeWLX)      {      pData=KMem.WLX+nWordAddr;      }



            else if (nDataType == KLDataTypeWLY)      {      pData=KMem.WLY+nWordAddr;      }



            else if (nDataType == KLDataTypeSV)      {      pData=KMem.SV+nWordAddr;   DataLen=0;}



            else if (nDataType == KLDataTypeEV)      {      pData=KMem.EV+nWordAddr;   DataLen=0;}



            else if (nDataType == KLDataTypeTest)   {      pData=KMem.SDT+nWordAddr;   DataLen=0;}



            else if (nDataType == KLDataTypeWDT)   {      pData=KMem.WDT+nWordAddr;   DataLen=0;}



            else if (nDataType == KLDataTypeKBD)   {      pData=(unsigned short *)KBusChnStats +nWordAddr;   DataLen=0;}



            else if (nDataType == KLDataSysCfg)      { pData = (unsigned short *)&(storedKMSysCfg) + nWordAddr;}



            else if (nDataType == KLDataTypeFlash) { pData = (unsigned short *)FLASH_BASE + nWordAddr;}



            else            {               pData=KLBufferOut+nWordAddr;   DataLen=0;         }



                  



            memcpy(pData,p1->Params+4,DataLen);               



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,p1->nCMD,0,0);



@@ -249,16 +255,16 @@


//            break;







         case KLCmdRead1Bit:



            nAddr=p1->Params[0]+ (p1->Params[1]<<8);



            nBitAddr=p1->Params[0]+ (p1->Params[1]<<8);



            DataLen = 1;



            if (nDataType == KLCoilTypeX)          { rData[0] = ((KMem.WX[nAddr>>4]&(1<<(nAddr&0x0f)))>0);}



            else if (nDataType == KLCoilTypeY) { rData[0] = ((KMem.WY[nAddr>>4]&(1<<(nAddr&0x0f)))>0);}



            else if (nDataType == KLCoilTypeR) { rData[0] = ((KMem.WR[nAddr>>4]&(1<<(nAddr&0x0f)))>0);}



            else if (nDataType == KLCoilTypeLX) { rData[0] = ((KMem.WLX[nAddr>>4]&(1<<(nAddr&0x0f)))>0);}



            else if (nDataType == KLCoilTypeLY) { rData[0] = ((KMem.WLY[nAddr>>4]&(1<<(nAddr&0x0f)))>0);}



            else if (nDataType == KLCoilTypeT) { rData[0] = KMem.Timers[nAddr].bTon;}



            else if (nDataType == KLCoilTypeC) { rData[0] = KMem.Timers[nAddr].bTon;}



            else if (nDataType == KLCoilTypeSR) {rData[0] = ((KMem.WSR[nAddr>>4]&(1<<(nAddr&0x0f)))>0);}



            if (nDataType == KLCoilTypeX)          { rData[0] = ((KMem.WX[nBitAddr>>4]&(1<<(nBitAddr&0x0f)))>0);}



            else if (nDataType == KLCoilTypeY) { rData[0] = ((KMem.WY[nBitAddr>>4]&(1<<(nBitAddr&0x0f)))>0);}



            else if (nDataType == KLCoilTypeR) { rData[0] = ((KMem.WR[nBitAddr>>4]&(1<<(nBitAddr&0x0f)))>0);}



            else if (nDataType == KLCoilTypeLX) { rData[0] = ((KMem.WLX[nBitAddr>>4]&(1<<(nBitAddr&0x0f)))>0);}



            else if (nDataType == KLCoilTypeLY) { rData[0] = ((KMem.WLY[nBitAddr>>4]&(1<<(nBitAddr&0x0f)))>0);}



            else if (nDataType == KLCoilTypeT) { rData[0] = KMem.Timers[nBitAddr].bTon;}



            else if (nDataType == KLCoilTypeC) { rData[0] = KMem.Timers[nBitAddr].bTon;}



            else if (nDataType == KLCoilTypeSR) {rData[0] = ((KMem.WSR[nBitAddr>>4]&(1<<(nBitAddr&0x0f)))>0);}



            



            else if (nDataType == KLCoilTypeLR) { rData[0] = 0;}



            else {rData[0]=0;}



@@ -266,16 +272,16 @@


            SendPacket(nChn, 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) { KMem.Timers[nAddr].bTon = p1->Params[2];}



            else if (nDataType == KLCoilTypeC) { KMem.Timers[nAddr].bTon = p1->Params[2];}



            else if (nDataType == KLCoilTypeC) { KMem.Timers[nAddr].bTon = p1->Params[2];}



            else if (nDataType == KLCoilTypeLR) { SetBitValue( &KMem.WSR[nAddr>>4],nAddr&0x0f,p1->Params[2]);;}



            nBitAddr=p1->Params[0]+ (p1->Params[1]<<8);



            if (nDataType == KLCoilTypeX)          { SetBitValue( &KMem.WX[nBitAddr>>4],nBitAddr&0x0f,p1->Params[2]);}



            else if (nDataType == KLCoilTypeY) { SetBitValue( &KMem.WY[nBitAddr>>4],nBitAddr&0x0f,p1->Params[2]);}



            else if (nDataType == KLCoilTypeR) { SetBitValue( &KMem.WR[nBitAddr>>4],nBitAddr&0x0f,p1->Params[2]);}



            else if (nDataType == KLCoilTypeLX) {SetBitValue( &KMem.WLX[nBitAddr>>4],nBitAddr&0x0f,p1->Params[2]);}



            else if (nDataType == KLCoilTypeLY) {SetBitValue( &KMem.WLY[nBitAddr>>4],nBitAddr&0x0f,p1->Params[2]);}



            else if (nDataType == KLCoilTypeT) { KMem.Timers[nBitAddr].bTon = p1->Params[2];}



            else if (nDataType == KLCoilTypeC) { KMem.Timers[nBitAddr].bTon = p1->Params[2];}



            else if (nDataType == KLCoilTypeC) { KMem.Timers[nBitAddr].bTon = p1->Params[2];}



            else if (nDataType == KLCoilTypeLR) { SetBitValue( &KMem.WSR[nBitAddr>>4],nBitAddr&0x0f,p1->Params[2]);;}



            else {rData[0]=0;}



            DataLen=0;



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,KLCmdWrite1Bit,DataLen,rData);



@@ -289,16 +295,16 @@


            



            break;



         case KLCmdReadProgram:



            nAddr=p1->Params[0]+ (p1->Params[1]<<8);



            nWordAddr=p1->Params[0]+ (p1->Params[1]<<8);



            DataLen= p1->Params[2];



             if (nDataType==0){



                  pData = (unsigned short *)STORE_PRG_BASE + nAddr;



                  pData = (unsigned short *)STORE_PRG_BASE + nWordAddr;



             } else if (nDataType==1){



                  pData = (unsigned short *)ALT_PRG_BASE + nAddr;



                  pData = (unsigned short *)ALT_PRG_BASE + nWordAddr;



             } else if (KMRunStat.nBinProgBank == 0) {



                  pData = (unsigned short *)STORE_PRG_BASE + nAddr;



                  pData = (unsigned short *)STORE_PRG_BASE + nWordAddr;



             }else {



                  pData = (unsigned short *)ALT_PRG_BASE + nAddr;



                  pData = (unsigned short *)ALT_PRG_BASE + nWordAddr;



             }



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,p1->nCMD,DataLen,pData);



            SendPacket(nChn, p2, PacketLen);



@@ -316,22 +322,22 @@


            break;



         case KLCmdWriteProgram:



            if (PLCMem.bPLCRunning) PLCMem.bPLCRunning=0;



            nAddr=p1->Params[0]+ (p1->Params[1]<<8);



            nWordAddr=p1->Params[0]+ (p1->Params[1]<<8);



            DataLen= p1->Params[2];







            //DataLen=16;



            for (int i=0;i<DataLen;i++)



            {KLPacketBuf2[i]=p1->Params[4+i];}



            WriteProgram(nAddr, KLPacketBuf2, DataLen,nDataType);



            WriteProgram(nWordAddr, KLPacketBuf2, DataLen,nDataType);



            DataLen=4;



            *((int *)(&rData[0]))=(long)(p1->Params+4);



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,KLCmdWriteProgram,0,0);



            SendPacket(nChn, p2, PacketLen);



            break;



         case KLCmdFinishProgram:



            nAddr=p1->Params[0]+ (p1->Params[1]<<8);      //Program Size;



            nWordAddr=p1->Params[0]+ (p1->Params[1]<<8);      //Program Size;



            DataLen=nDataType;



            KMRunStat.nBinProgSize=nAddr;



            KMRunStat.nBinProgSize=nWordAddr;



            if (KMRunStat.nBinProgBank ==0) {KMRunStat.nBinProgBank=1;}



            else {KMRunStat.nBinProgBank=0;}



            SaveRunStat(&KMRunStat);            



@@ -341,11 +347,51 @@


            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,KLCmdFinishProgram,0,0);



            SendPacket(nChn, p2, PacketLen);



            break;



				


         case KLCmdBlinkLED:



            DataLen=nDataType;



            KMRunStat.bLEDFlick=DataLen;



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,p1->nCMD,0,0);



            SendPacket(nChn, p2, PacketLen);



            break;



			


         case KLCmdStopBlinkLED:



            DataLen=nDataType;



            KMRunStat.bLEDFlick=0;



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,p1->nCMD,0,0);



            SendPacket(nChn, p2, PacketLen);



            break;



			


         case KLCmdReadRunStat:



            DataLen= sizeof(stRunStat);



            pData=&KMRunStat;



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,p1->nCMD,DataLen,pData);



            SendPacket(nChn, p2, PacketLen);   



            break;



         case KLCmdReadSysCfg:



            nByteAddr=p1->Params[0]+ (p1->Params[1]<<8);



            pData=(UCHAR *)(&storedKMSysCfg.theKMSysCfg)+nByteAddr;



            DataLen = p1->Params[2];



            if (nByteAddr >= sizeof(stKMSysCfg)) {DataLen=0;}



            else {



               if (DataLen + nByteAddr >sizeof(stKMSysCfg))



                  DataLen= sizeof(stKMSysCfg) - nByteAddr;



            }



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,p1->nCMD,DataLen,pData);



            SendPacket(nChn, p2, PacketLen);	


            break;



         case KLCmdWriteSysCfg:



            nByteAddr=p1->Params[0]+ (p1->Params[1]<<8);



            pData=(UCHAR *)(&storedKMSysCfg.theKMSysCfg)+nByteAddr;



            DataLen = p1->Params[2];



            if (nByteAddr >= sizeof(stKMSysCfg)) {DataLen=0;}



            else {



               if (DataLen + nByteAddr >sizeof(stKMSysCfg))



                  DataLen= sizeof(stKMSysCfg) - nByteAddr;



            }



            memcpy(pData,p1->Params+4,DataLen);					


            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,p1->nCMD,0,0);



            SendPacket(nChn, p2, PacketLen);				


            break;



         case KLCmdSaveSysCfg:



            WriteSysCfgToFlash(&storedKMSysCfg);



@@ -357,6 +403,11 @@


            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,KLCmdSaveRunStat,0,0);



            SendPacket(nChn, p2, PacketLen);



            break;



         case KLCmdClearRunStat:



            memset(KBusChnStats,0,sizeof(KBusChnStats));



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,p1->nCMD,0,0);



            SendPacket(nChn, p2, PacketLen);					


            break;



         case KLCmdGetEventLogCount:



            DataLen= 4;



            pData=&KMem.nEventCount;



@@ -364,9 +415,9 @@


            SendPacket(nChn, p2, PacketLen);



            break;



         case KLCmdGetEventLog:



            nAddr=p1->Params[0]+ (p1->Params[1]<<8);



            nWordAddr=p1->Params[0]+ (p1->Params[1]<<8);



            DataLen= p1->Params[2] * sizeof(stEventLog);



            pData=GetEventLogAddr(nAddr);



            pData=GetEventLogAddr(nWordAddr);



            PacketLen=KLMakeRplyPacket(p2,nDstHost,nKLStatus.StatByte,p1->nCMD,DataLen,pData);



            SendPacket(nChn, p2, PacketLen);



            break;



@@ -378,7 +429,7 @@


         default:



         DataLen=1;



         rData[0]=KL_UNKNOWN;



         PacketLen=KLMakeRplyPacket(p2,nKLAddr,nKLStatus.StatByte,KLCmdErrRply,DataLen,rData);



         PacketLen=KLMakeRplyPacket(p2,nKLStationId,nKLStatus.StatByte,KLCmdErrRply,DataLen,rData);



         SendPacket(nChn, p2, PacketLen);         



            break;      



      }



@@ -398,7 +449,7 @@


      char rData[4];



      rData[0]=Result;



      



      PacketLen=KLMakeRplyPacket(KLPacketBuf2,nKLAddr,nKLStatus.StatByte,KLCmdErrRply,DataLen,rData);



      PacketLen=KLMakeRplyPacket(KLPacketBuf2,nKLStationId,nKLStatus.StatByte,KLCmdErrRply,DataLen,rData);



//      PacketLen=KLMakePacket(p2,0,nAddr,cmdKLPing,p1->nSEQ,DataLen,rData);



      SendPacket(nChn, KLPacketBuf2, PacketLen);



      return Result;



@@ -411,7 +462,7 @@


   



   //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;