fixed:寻址成功，读寄存器数据更新频率是3869

service/impl/ProtocolImpl.cpp

 using namespace std;
 bool ProtocolImpl::hasInit = false;
 
-
+int ProtocolImpl::findAddrFlag = 0;
+int ProtocolImpl::idSuccessFlag = 0;
+int ProtocolImpl::currentId = 1;
+int ProtocolImpl::timeOut = 0;
+int ProtocolImpl::count  = 1;
+int ProtocolImpl::currentState = 0;
+int ProtocolImpl::sendDelayCout = 0;
+int ProtocolImpl::flag = 0;
+int ProtocolImpl::deviceCounts = 0;
 uint8_t ProtocolImpl::retBigEndian(uint32_t value, int offset)
 {
 	uint8_t ret = 0;
 		{
 		}
 	}
-	log_i("最大的起始地址:0x%x", maxRegAddr);
+	//log_i("最大的起始地址:0x%x", maxRegAddr);
 	return maxRegAddr;
 }
 
 	std::string sParaRegAddr;
 	int iParaRegAddr;
 	std::vector<Item*> items = ppacket->getVitem();
-	log_i("Items size: %zu", items.size());
+	//log_i("Items size: %zu", items.size());
 	sMinRegAddr = items[0]->getBase().getParam("起始地址");
 	iMinRegAddr = strtol(sMinRegAddr.c_str(), NULL, HEX);
-	log_i("Initial minimum register address value: 0x%x", iMinRegAddr);
+	//log_i("Initial minimum register address value: 0x%x", iMinRegAddr);
 	for (size_t i = 0; i < items.size(); ++i)
 	{
-		log_i("Processing item %zu", i);
+		//log_i("Processing item %zu", i);
 		sParaRegAddr = items[i]->getBase().getParam("起始地址");
 		iParaRegAddr = strtol(sParaRegAddr.c_str(), NULL, HEX);
 		if (iParaRegAddr < iMinRegAddr)
 			iMinRegAddr = iParaRegAddr;
 		}
 	}
-	log_i("最小的寄存器起始地址:0x%x", iMinRegAddr);
+	//log_i("最小的寄存器起始地址:0x%x", iMinRegAddr);
 
 	return iMinRegAddr;
 }
 
-int ProtocolImpl::retStateResponse(Packet *ppacket, Item *pitem, const int len)
+//过滤出错误帧
+int ProtocolImpl::filterErrFrame(PBYTE pbuf,int len)
+{
+	int validlen = len;
+	int frameId ;
+	int kindId;
+	int errFrameCount = 0;
+	for (int count = 0;
+				((count < validlen) && ((validlen - count) >= 12));
+				count += 12)
+	{
+		frameId = getRealFrame(pbuf,count);
+
+		kindId = (frameId >> 24) & 0xffff;
+		//log_i("frameId = 0x%x,kindID = 0X%x",frameId,kindId);
+		if(kindId != 0xff84 )
+		{
+			errFrameCount ++;
+		}
+	}
+	return errFrameCount;
+}
+
+int ProtocolImpl::retStateResponse(Packet *ppacket, Item *pitem, const int len,PBYTE pbuf)
 {
 	int maxRegAddr = -1;
 	int minRegAddr = 0;
 	int regNum = 0;
 	int datasLen = 0;
+	int errFrameCount = 0;
+	int errFrameLen = 0;
 	maxRegAddr = getRegAddrMax(ppacket, pitem);
 	minRegAddr = getRegAddrMin(ppacket, pitem);
 	regNum = maxRegAddr - minRegAddr + 1;
-	log_i("reg:%d", regNum);
+	//log_i("reg:%d", regNum);
+	errFrameCount = filterErrFrame(pbuf,len);
+	errFrameLen = errFrameCount * 10;
 	datasLen = getRealValidLen(regNum);
-	log_i("最大寄存器地址:0x%x,最小寄存器数量:0x%x,寄存器个数:0x%x,数据长度:%d,合法的数据长度=%d", maxRegAddr,
-			minRegAddr, regNum, datasLen, len);
-	if (len >= datasLen)
+	//log_i("datasLen:%d",datasLen);
+
+	log_i("最大寄存器地址:0x%x,最小寄存器数量:0x%x,寄存器个数:0x%x,理论算出应收到合法数据长度:%d,\
+			实际收到数据长度=%d,错误帧个数=%d,错误帧长度:%d", maxRegAddr,
+			minRegAddr, regNum, datasLen, len,errFrameCount,errFrameLen);
+
+	if (len >= (datasLen + errFrameLen))
 	{
 		return S_OK;
 	}
 	if (maxRegNum <= 4 && maxRegNum > 0)
 	{
 		len = 4 + 2 * maxRegNum;
-		log_i("寄存器数量小于等于4个，计算得出合法数据长度:%d", len);
+		log_i("第1种情况，寄存器数量小于等于4个，计算得出合法数据长度:%d", len);
 	}
 	else
 	{
 		if (maxRegNum % 4 == 0)
 		{
 			len = 12 * (maxRegNum / 4);
-			log_i("寄存器请求数量:%d,回复帧长度:%d",maxRegNum,len);
+			log_i("第2种情况，寄存器数量多余4且%4 == 0情况，寄存器请求数量:%d,回复帧长度:%d",maxRegNum,len);
 		}
 		else
 		{
 			len = 4*((maxRegNum / 4) +1) + (maxRegNum *2);   //帧数据长度+寄存器长度
-			log_i("寄存器请求数量:%d,回复帧长度:%d",maxRegNum,len);
+			log_i("第3种情况，寄存器数量多余4，寄存器请求数量:%d,回复帧长度:%d",maxRegNum,len);
 		}
 	}
 	return len;
 			| ((ptemp[1 + count] << 16) & 0x00ff0000)
 			| ((ptemp[2 + count] << 8) & 0x0000ff00)
 			| ((ptemp[3 + count]) & 0x000000ff));
-	log_i("帧id:0x%x", id);
+	//log_i("帧id:0x%x", id);
 
 	return id;
 
 
 std::map<int,int> ProtocolImpl::handleDataGreater(PBYTE pbuf,int len,int regNum,int datasLen)
 {
-	int validlen = len;
-	int iPbufId;
+	log_i("handleDataGreater:收到实际数据长度:%d,请求采集个数:%d,理想情况下收到数据长度:%d", len, regNum, datasLen);
 	std::map<int, int> dataSet;
 
-	for (int count = 0;
-			((count < validlen) && ((validlen - count) >= 12));
-			count += 12)
+	for (int count = 0; (count < len) && (len - count >= 12); count += 12)
 	{
-		iPbufId = getRealFrame(pbuf, count);
-		for (int i = 0; i < 4 && regNum > 0; i++,regNum --)   // i代表第i个寄存器
+		int iPbufId = getRealFrame(pbuf, count); // 假设正确解析起始寄存器ID
+		int kindId = (iPbufId >> 24) & 0xffff;
+		//log_i("frameId = 0x%x,kindID = 0X%x",frameId,kindId);
+		if(kindId == 0xff84 )    //代表合法数据
 		{
-
-			uint16_t regValue = 0;
-			if (i * 2 + 4 + count <= datasLen)  //当前寄存器数量的总帧数
+			for (int i = 0; i < 4 && regNum >= 0; ++i, --regNum)
 			{
-				regValue = (pbuf[i * 2 + 4 + count] << 8)
-						| pbuf[i * 2 + 5 + count]; // 提取寄存器值
-				dataSet[iPbufId + i % 4] = regValue; // 绑定到map
-			}
-			else
-			{
-				// 数据不足，处理错误或默认值
-				regValue = 0xFFFF; // 默认值为0xFFFF
-				dataSet[iPbufId + i % 4] = regValue; // 绑定到map
+				uint16_t regValue;
+				int dataOffset = count + 4 + i * 2;
+
+				// 确保当前块的数据足够（两个字节）
+				if (dataOffset + 1 < len)
+				{
+					regValue = (pbuf[dataOffset] << 8) | pbuf[dataOffset + 1];
+				}
+				else
+				{
+					regValue = 0xFFFF; // 数据不足，默认值
+				}
+
+				dataSet[iPbufId + i] = regValue; // 寄存器ID连续递增
 			}
 		}
-		for (const auto &entry : dataSet)
-		{
-			log_i("addrFrame = 0x%x, value = 0x%x", entry.first,
-					entry.second);
-		}
+		// 每个块的数据部分为8字节（从count+4到count+11）
 
 	}
+
 	return dataSet;
 
 }
 
 	regNum = maxRegAddr - minRegAddr + 1;
 	datasLen = getRealValidLen(regNum);
-	log_i("regNum:%d,dataLen:%d",regNum,datasLen);
+
 	if (datasLen <= 12)
 	{
 		dataSet = handleDataLess(pbuf,len,regNum,datasLen);
 	int iAttribute = 0;
 
 	sAttribute = t_base.getParam(attribute);
-	log_i("%s: %s",attribute.c_str(), sAttribute.c_str());
+	//log_i("%s: %s",attribute.c_str(), sAttribute.c_str());
 
 	iAttribute = strtol(sAttribute.c_str(), NULL, HEX);
-	log_i("retV:0x%x",iAttribute);
+	//log_i("retV:0x%x",iAttribute);
 	return iAttribute;
 }
 
 	Base &t_base = t_item->getBase();
 	string sAttribute = "";
 	sAttribute = t_base.getParam(attribute);
-	log_i("%s: %s",attribute.c_str(), sAttribute.c_str());
+	//log_i("%s: %s",attribute.c_str(), sAttribute.c_str());
 	return sAttribute;
 }
 
 	int16_t buf = pbuf;
 	string t_str;
 	char t[256];
-	log_i("receiveData:0x%x,paraData:0x%x",receiveData,paraData);
+	//log_i("receiveData:0x%x,paraData:0x%x",receiveData,paraData);
 	if(receiveData == paraData)
 	{
-		log_i("ID匹配，处理数据");
+		//log_i("ID匹配，处理数据");
 		if (t_sDataType == "I")
 		{
-			log_i("数据类型为I，调用merge16函数,buf=0x%x",buf);
+			//log_i("数据类型为I，调用merge16函数,buf=0x%x",buf);
 			t_item->setValue(merge16(buf, t_sByteOrder));
+//			if(t_sByteOrder == "B")
+//			{
+//				log_i("字符类型B");
+//				int index = t_sBits.find(".");
+//				log_i("t_sBits =%s, index = %d",t_sBits.c_str(),index);
+//				if (index != -1)
+//				{
+//					string t_sBitnum = t_sBits.substr(0,index);
+//					int t_iBitnum =(int) (strtol(t_sBitnum.c_str(),NULL, 10));	//----位起始地址
+//					int t_Bits =(int) (strtol(t_sBits.substr(index + 1).c_str(),NULL, 10));
+//					unsigned short t_usdata =(unsigned short) (strtol(merge16_u(buf,t_sByteOrder).c_str(),NULL, 10));
+//					unsigned short bits = 0;
+//					log_i("位起始地址t_iBitnum = %d, t_Bits= %d, t_usdata = %d",t_iBitnum,t_Bits,t_usdata);
+//					for (int i = 0; i < t_Bits; i++)
+//					{
+//						unsigned short bit = (t_usdata >> (t_iBitnum + i))& 0x0001;
+//						bits += bit * pow(2, i);
+//					}
+//					snprintf(t, 256, "%d", bits);
+//					log_i("bits:%d",bits);
+//					t_str = t;
+//					log_i("字符类型设置:%s",t_str.c_str());
+//					t_item->setValue(t_str);
+//				}
+//			}
 		}
 		else if (t_sDataType == "UI")
 		{
-			log_i("数据类型为UI，调用merge16函数");
+			//log_i("数据类型为UI，调用merge16函数");
 			t_item->setValue(merge16(buf, t_sByteOrder));
 		}
 		else if (t_sDataType == "B")
 		{
+
 			int index = t_sBits.find(".");
+			//log_i("t_sBits =%s, index = %d",t_sBits.c_str(),index);
 			if (index != -1)
 			{
 				string t_sBitnum = t_sBits.substr(0,index);
 				int t_iBitnum =(int) (strtol(t_sBitnum.c_str(),NULL, 10));	//----位起始地址
 				int t_Bits =(int) (strtol(t_sBits.substr(index + 1).c_str(),NULL, 10));
+				//log_i("数据类型为B，调用merge16函数");
 				unsigned short t_usdata =(unsigned short) (strtol(merge16_u(buf,t_sByteOrder).c_str(),NULL, 10));
+				//log_i("位起始地址t_iBitnum = %d, t_Bits= %d, t_usdata = %d",t_iBitnum,t_Bits,t_usdata);
 				unsigned short bits = 0;
 				for (int i = 0; i < t_Bits; i++)
 				{
 				snprintf(t, 256, "%d", bits);
 				t_str = t;
 				t_item->setValue(t_str);
+				//log_i("字符类型设置:%s",t_str.c_str());
 			}
 		}
 	}
 	  		idSuccessFlag = 0;
 	        log_i("收到未知的CAN帧");
 	    }
-	  	if(idSuccessFlag == 2)
+	  	if(idSuccessFlag == deviceCounts)
 	  	{
 	  		 findAddrFlag = 1;
 	  		 currentId = 1;
 	pbuf[2] = 0x07;
 	pbuf[3] = 0xf0;
 	pbuf[4] = static_cast<uint8_t>(id); // 转换为字节
-	pbuf[5] = static_cast<uint8_t>(maxId); // 转换为字节
+	pbuf[5] = static_cast<uint8_t>(deviceCounts); // 转换为字节
 	pbuf[6] = static_cast<uint8_t>(orderMode); // 转换为字节
 	pbuf[7] = static_cast<uint8_t>(orderState); // 转换为字节
 //	pbuf[8] = 0;
 {
 
 	log_i("onRead");
-	int deviceCounts;
+
 	Channel *pC = pdevice->getParent();
 
 	log_i("Channel pointer: %p", pC);
 	if (m_tmpItems.count(pC->getBase().getObjid().toString()) == 0)
 	{
 		deviceCounts = pC->getDeviceCount();
-		//maxId = deviceCounts;
-		maxId = 2;
+		maxId = deviceCounts;
+		//maxId = 2;
 
 		log_i("maxid =%d",maxId);
 	}
 	if(currentState == INIT)
 	{
 		initIO();
-		sendDelay = 0;
 	}
 
 	if(currentState == SEND)
 	{
-		sendAllocFrame(pbuf,currentId , len);
+		log_i("currenntId = %d",currentId);
+		if(currentId != 1)
+		{
+			log_i("发送延迟计数:%d",sendDelayCout);
+			if(sendDelayCout > 3)
+			{
+
+				sendAllocFrame(pbuf,currentId , len);
+				//sendDelayCout = 0;
+
+
+			}
+			sendDelayCout ++;
+		}
+		else
+		{
+			sendAllocFrame(pbuf,currentId , len);
+		}
 		timeOut = 0;
 		//pdevice->getBase().setRwstate(READ_WAIT);
 		pdevice->getBase().setRwstate(WRITE_WAIT);
 			return S_FALSE;
 		}
 
-		pdevice->getBase().setRwstate(READ_WAIT);	//----设置设备状态
+		//pdevice->getBase().setRwstate(READ_WAIT);	//----设置设备状态
 
 		std::string sParaId;
 		int iParaId;
 		Base &t_base = ppacket->getVitem().at(0)->getBase();
 		sParaId = t_base.getParam("功能码");
-		log_i("Parameter ID: %s", sParaId.c_str());
+		log_i("sParaId =%s,对应的实际名称=%s",sParaId.c_str() ,t_base.getName().c_str());
 		iParaId = strtol(sParaId.c_str(), NULL, HEX);
-		log_i("Parameter ID: %s", sParaId.c_str());
-		log_i("Converted Parameter ID: 0x%x", iParaId);
+		string t_saddr;
+		t_saddr = pdevice->getBase().getParam("站地址");
+		int t_iaddr = 0;
+		t_iaddr = strtol(t_saddr.c_str(), NULL, HEX);
 		int frameFuncCode  = (iParaId & 0x070000);
-		log_i("frameFuncCode = 0x%x",frameFuncCode);
+		log_i("stationAddr = %d,iParaId=0x%x，frameFuncCode = 0x%x",t_iaddr,iParaId,frameFuncCode);
 		if (ppacket == nullptr || pitem == nullptr)
 		{
 			log_i("Invalid packet or item");
 			return S_FALSE;
 		}
-		string t_saddr;
-		t_saddr = pdevice->getBase().getParam("站地址");
-		int t_iaddr = 0;
-		t_iaddr = strtol(t_saddr.c_str(), NULL, HEX);
-		log_i("stationAddr = %d",t_iaddr);
-		iParaId |=  (t_iaddr << 19);
-		log_i("onread -addStation-id = 0x%x",iParaId);
 
+		//iParaId |=  (t_iaddr << 19);
 		//判断寄存器是读寄存器
 		if(frameFuncCode == 0x030000)
 		{
 			int maxRegAddr = getRegAddrMax(ppacket, pitem);
 			int minRegAddr = getRegAddrMin(ppacket, pitem);
-			log_i("MaxRegAddr: 0x%x, MinRegAddr: 0x%x", maxRegAddr, minRegAddr);
+			log_i("onRead中判断出寄存器是读寄存器MaxRegAddr: 0x%x, MinRegAddr: 0x%x", maxRegAddr, minRegAddr);
 
 			if (maxRegAddr < minRegAddr)
 			{
 				return S_FALSE;
 			}
 			int regNum = maxRegAddr - minRegAddr + 1;
-
+			iParaId |=  (t_iaddr << 19);
 			pbuf[0] = retBigEndian(iParaId + minRegAddr, 24);
 			pbuf[1] = retBigEndian(iParaId + minRegAddr, 16);
 			pbuf[2] = retBigEndian(iParaId + minRegAddr, 8);
 				log_i("pbuf is null");
 				return S_FALSE;
 			}
-			for (int i = 0; i < 6; i++)
+			for (int i = 0; i < len; i++)
 			{
 				log_i("onRead-读数据:pbuf[%d]:0x%x", i, pbuf[i]);
 			}
+			pdevice->getBase().setRwstate(READ_WAIT);	//----设置设备状态
+		}
+		//判断寄存器是读写寄存器
+		if(frameFuncCode == 0x010000)
+		{
+			pdevice->getBase().setRwstate(WRITE_WAIT);
 		}
 
 		//初始化数据库容器
 		{
 			if (m_tmpItems.count(pC->getBase().getObjid().toString()) == 0)
 			{
-				log_i("Temporary items not found for Channel ID: %s",
+				log_i("初始化ZLink数据Temporary items not found for Channel ID: %s",
 						pC->getBase().getObjid().toString().c_str());
 				int ccount = pC->getDeviceCount();
 				log_i("Channel device count: %d", ccount);
 						Base &t_base =
 								pC->getVDevice().at(i)->getVitem().at(j)->getBase();
 						t_sId = t_base.getParam("写功能码");
-						log_i("写功能码: %s", t_sId.c_str());
+						//log_i("写功能码: %s", t_sId.c_str());
 						int t_iId = 0;
 						t_iId = strtol(t_sId.c_str(), NULL, HEX);	//----获取帧ID
-						log_i("功能码转换为整数: 0x%x", t_iId);
+						//log_i("功能码转换为整数: 0x%x", t_iId);
 						string t_stype;
 						t_stype = t_base.getParam("帧类型");
-						log_i("帧类型: %s", t_stype.c_str());
+						//log_i("帧类型: %s", t_stype.c_str());
 
 						if (t_stype == "1")
 						{
 						string sStartAddr;
 						//sStartAddr = pC->getVDevice().at(i)->getBase().getParam("起始地址");
 						sStartAddr = t_base.getParam("起始地址");
-						log_i("起始地址 =%s", sStartAddr.c_str());
+						//log_i("起始地址 =%s", sStartAddr.c_str());
 
 						int iStartAddr = 0;
 						iStartAddr = strtol(sStartAddr.c_str(), NULL, HEX);
-						log_i("起始地址转换为整数: 0x%x", iStartAddr);
+						//log_i("起始地址转换为整数: 0x%x", iStartAddr);
 						t_iId += iStartAddr;
 						string t_saddr;
 						t_saddr = pC->getVDevice().at(i)->getBase().getParam("站地址");
 						int t_iaddr = 0;
 						t_iaddr = strtol(t_saddr.c_str(), NULL, HEX);
+						//log_i("站地址:%d",t_iaddr);
 						t_iId |=  (t_iaddr << 19);
+						//log_i("t_Id = %d",t_iId);
 						tmpItems.insert(
 								make_pair(t_iId,
 										pC->getVDevice().at(i)->getVitem().at(j)));
-						log_i("插入临时条目: ID=0x%x", t_iId);
+						//log_i("插入临时条目: ID=0x%x", t_iId);
 					}
 				}
 
 
 		*(pbuf + (t_len++)) = t_data.data0 & 0x00ff;
 		*(pbuf + (t_len++)) = t_data.data1 & 0x00ff;
-//		*(pbuf + (t_len++)) = t_data.data2 & 0x00ff;
-//		*(pbuf + (t_len++)) = t_data.data3 & 0x00ff;
-//		*(pbuf + (t_len++)) = t_data.data4 & 0x00ff;
-//		*(pbuf + (t_len++)) = t_data.data5 & 0x00ff;
-//		*(pbuf + (t_len++)) = t_data.data6 & 0x00ff;
-//		*(pbuf + (t_len++)) = t_data.data7 & 0x00ff;
+
 
 		string t_sDataType;	//----数据类型
 		t_sDataType = base.getParam("数据类型");
 	{
 	case READ_O:
 	case WRITE_WAIT:
+		return S_OK;
 	case READ_WAIT:
-		ret = retStateResponse(ppacket, pitem, len);
+		ret = retStateResponse(ppacket, pitem, len,pbuf);
 		log_i("isResponseOK返回值:%d", ret);
 		if (ret == S_OK)
 		{
 //寻址未成功，解析寻址报文
 void ProtocolImpl::ioResponse(Packet *ppacket, Item *pitem,PBYTE pbuf, const int len)
 {
+	// jisuan
 	std::map<int, int> dataSets; // 存储寄存器地址和值
-	int id;
-	int16_t buf;
 	dataSets=retIoDataSet(ppacket, pitem, pbuf, len);
 	log_i("pbuf[4]= 0x%x,pbuf[5] = 0x%x,pbuf[6] = 0x%x,pbuf[7] = 0x%x",pbuf[4],pbuf[5],pbuf[6],pbuf[7]);
 
+	// second,
 	for (const auto &entry : dataSets)
 	{
 		log_i("addrFrame = 0x%x, value = 0x%x", entry.first,
 				entry.second);
 	}
+
+	int id;
+	int16_t buf;
+
 	for (const auto &dataPair : dataSets)
 	{
 		log_i("addData.size=%d", dataSets.size());
 
 }
 
+void ProtocolImpl::stringOutput(PBYTE pbuf, int data_len)
+{
+	// 删除strlen计算，直接使用传入的data_len
+	    int groups = data_len / 12;
+	    int remainder = data_len % 12;
+	    int total_bytes = (groups + (remainder != 0)) * 12;
+
+	    char *result = (char *)malloc(total_bytes);
+	    if (!result) {
+	        fprintf(stderr, "内存分配失败\n");
+	        return;
+	    }
+	    memset(result, 0, total_bytes);  // 更规范的写法
+
+	    int pos = 0;
+	    for (int i = 0; i < data_len; i += 12) {
+	        int bytes_to_copy = std::min(12, data_len - i);
+	        memcpy(result + pos, pbuf + i, bytes_to_copy);
+	        pos += 12;
+	    }
+
+	    // 以HEX格式打印二进制数据
+	    for (int i = 0; i < total_bytes; i += 12) {
+	        std::string hexStr;
+	        for (int j = 0; j < 12; ++j) {
+	            char buf[3];
+	            snprintf(buf, sizeof(buf), "%02X", static_cast<unsigned char>(result[i + j]));
+	            hexStr += buf;
+	            hexStr += " ";  // 可选：增加空格提高可读性
+	        }
+	        log_i("接收到的数据展示：%s", hexStr.c_str());
+	    }
+
+	    free(result);
+
+
+}
+
 //寻址成功，解析BMS传的数据
 int ProtocolImpl::normalDatasResponse(Device* pdevice,Packet* ppacket,Item* pitem,PBYTE pbuf,const int len)
 {
 		log_e("%s, 父通道为空, 无法进行数据解析", pdevice->getBase().getName().c_str());
 		return S_FALSE;
 	}
+	//stringOutput(pbuf,len);
 	dataSet = retDataSet(ppacket, pitem,pbuf,len);
-	log_i("pbuf[4]= 0x%x,pbuf[5] = 0x%x,pbuf[6] = 0x%x,pbuf[7] = 0x%x",pbuf[4],pbuf[5],pbuf[6],pbuf[7]);
 
-	for (const auto &entry : dataSet)
-	{
-		log_i("addrFrame = 0x%x, value = 0x%x", entry.first,
-				entry.second);
-	}
+	//log_i("pbuf[4]= 0x%x,pbuf[5] = 0x%x,pbuf[6] = 0x%x,pbuf[7] = 0x%x",pbuf[4],pbuf[5],pbuf[6],pbuf[7]);
+
+//	for (const auto &entry : dataSet)
+//	{
+//		log_i("dataSet填充返回值：addrFrame = 0x%x, value = 0x%x", entry.first,
+//				entry.second);
+//	}
 	for (const auto &dataPair : dataSet)
 	{
-		log_i("addData.size=%d", dataSet.size());
+		//log_i("addData.size=%d", dataSet.size());
 		id = dataPair.first;
 
 		id = (0x7fffffff) & id;
 		buf = dataPair.second;
 
-		log_i("Processing data pair with ID: 0x%x", id);
+		//log_i("Processing data pair with ID: 0x%x", id);
 
 		if (m_tmpItems.count(pC->getBase().getObjid().toString()) > 0)
 		{
 
-			log_i("Found temporary items for Channel ID: %s",
-					pC->getBase().getObjid().toString().c_str());
+			//log_i("Found temporary items for Channel ID: %s",
+					//pC->getBase().getObjid().toString().c_str());
 			std::multimap<int, Item*> tmpItms = m_tmpItems.find(
 					pC->getBase().getObjid().toString())->second; //是否有效
-			for (const auto &data : tmpItms)
-			{
-				log_i("缓存条目中的缓存地址:0x%x,0x%x", data.first, data.second);
-			}
-			log_i("Temporary items size: %zu", tmpItms.size());
+//			for (const auto &data : tmpItms)
+//			{
+//				log_i("缓存条目中的缓存地址:0x%x,0x%x", data.first, data.second);
+//			}
+			//log_i("Temporary items size: %zu", tmpItms.size());
 
 			std::multimap<int, Item*>::size_type cnt = tmpItms.count(
 					id);
-			log_i("Number of items with ID 0x%x: %zu", id, cnt);
+			//log_i("Number of items with ID 0x%x: %zu", id, cnt);
 			std::multimap<int, Item*>::iterator iter = tmpItms.find(id);
 			if (iter != tmpItms.end())
 			{
 				for (; cnt > 0; cnt--, iter++)
 				{
-					log_i("Processing item %zu for ID 0x%x", cnt, id);
+					//log_i("Processing item %zu for ID 0x%x", cnt, id);
 					Item *t_item = iter->second;
 					//Device *ptdevice = (Device*) (t_item->getParent());
 
 					if (t_item != NULL && pdevice != NULL)
 					{
-						log_i("Item and Device are valid");
+
 						int iId = iGetItemParaConfig(t_item,"写功能码");
 						int iStartAddr = iGetItemParaConfig(t_item,"起始地址");
 						string t_stype = sGetItemParaConfig(t_item,"帧类型");
 						t_saddr = pdevice->getBase().getParam("站地址");
 						int t_iaddr = 0;
 						t_iaddr = strtol(t_saddr.c_str(), NULL, HEX);
-						log_i("t_iId = 0x%x,t_iaddr =%d,",iId,t_iaddr);
+						//log_i("t_iId = 0x%x,t_iaddr =%d,",iId,t_iaddr);
 
 						iId |=  (t_iaddr << 19);
 
-						log_i("设置的数据buf=%d,paraID = 0x%x",buf,iId);
+						//log_i("设置的数据buf=%d,paraID = 0x%x",buf,iId);
 						setData(t_item, buf,id,iId,t_sDataType,t_sByteOrder,t_sBits);
 					}
 
 	return S_OK;
 }
 
-
-
-
-
 /**
  * @content:解析数据
  * @time:2016-9-9

service/impl/ProtocolImpl.h

 //	std::map<std::string, std::multimap<int, Packet*> > m_tmppackets;
 	std::map<std::string, std::multimap<int, Item*> > m_tmpItems;
 	const ULONG VERSION;
-	int findAddrFlag = 0;
-	int idSuccessFlag = 0;
-	int sendCurrentId = 0;
-	int currentId = 1; //分配ID编号
+	static int findAddrFlag ;
+	static int idSuccessFlag ;
+	static int currentId ; //分配ID编号
 	int maxId = 0;    //最大分配ID
 	int orderMode = 0; //分配模式
 	int orderState  = 0; //分配状态
-
-	int firstResponSuccessFlag = 0;
-	int timeOut = 0;
-
-
+	static int timeOut ;
 	std::string devPath = "/sys/class/gpio/gpio436/value"; //输入输出电平值设备
 	std::string exportPath = "/sys/class/gpio/export";    //GPIO设备导出设备
 	std::string directPath = "/sys/class/gpio/gpio436/direction"; //GPIO输入输出控制设备
 	std::string gpio = "436";
 	std::string highLevel = "1";
 	std::string lowLevel  = "0";
-	int count  = 0;
+	static int count ;
+	static int currentState ;
+	int initIOFlag = 0;
+	static int sendDelayCout ;
+	static int flag ;
+	static int deviceCounts;
 
-	int currentState = 0;
-	int sendDelay = 0;
 
 
 
 	unsigned short GetCRC(PBYTE pchMsg, unsigned short usDataLen);
 
 	uint8_t retBigEndian(uint32_t value, int offset);
-	int retStateResponse(Packet* ppacket,Item* pitem,const int len);
+	int retStateResponse(Packet* ppacket,Item* pitem,const int len,PBYTE pbuf);
 	int getRealFrame (PBYTE pbuf,int count);
 	int getRegAddrMax(Packet* ppacket,Item* pitem);
 	int getRegAddrMin(Packet* ppacket,Item* pitem);
 
 	std::map<int,int> retIoDataSet(Packet *ppacket, Item *pitem,PBYTE pbuf,int len);
 	std::map<int,int> handleIoData(PBYTE pbuf);
+	int filterErrFrame(PBYTE pbuf,int len);
+    void stringOutput(PBYTE pbuf,int data_len);
 
 	std::vector<uint8_t> intToBytes(int value);
 	inline std::string merge8(PBYTE pbuf, std::string byteorder)
 			snprintf(t, 256, "%d", t_sdata);
 
 			t_str = t;
-			log_i("BA-merge16 t_str= %s", t_str.c_str());
+			//log_i("BA-merge16 t_str= %s", t_str.c_str());
 }
 		else if (byteorder == "AB")
 		{
 			snprintf(t, 256, "%d", t_sdata);
 
 			t_str = t;
-			log_i("AB-merge16 t_str= %s", t_str.c_str());
+			//log_i("AB-merge16 t_str= %s", t_str.c_str());
 		}
 
 		return t_str;
 	//inline std::string merge16_u(PBYTE pbuf, std::string byteorder)
 	inline std::string merge16_u(int16_t pbuf, std::string byteorder)
 	{
+		//log_i("merge16_u pbuf:%d,byteorder = %s",pbuf,byteorder.c_str());
 		unsigned short t_sdata = 0;
 		char t[256];
 		std::string t_str;
 			snprintf(t, 256, "%d", t_sdata);
 			t_str = t;
 		}
+		//log_i("merge16_u ret = %s",t_str.c_str());
 		return t_str;
 	}