(Modbus): рефакторинг кода и тестов, корректировка под 64bit

conf/libuniset2.spec

@@ -505,6 +505,7 @@ mv -f %buildroot%python_sitelibdir_noarch/* %buildroot%python_sitelibdir/%oname
 %exclude %_pkgconfigdir/libUniSet2.pc
         
 # history of current unpublished changes
+# Modbus: refactoring code and test (for 64bit)
 
 %changelog
 * Mon Dec 12 2016 Pavel Vainerman <pv@altlinux.ru> 2.6-alt6

extensions/ModbusMaster/MBExchange.cc

@@ -30,6 +30,22 @@ namespace uniset
 	using namespace std;
 	using namespace uniset::extensions;
 	// -----------------------------------------------------------------------------
+	// вспомогательная структура для предотвращения утечки памяти
+	struct DataGuard
+	{
+		DataGuard( size_t sz )
+		{
+			data = new ModbusRTU::ModbusData[sz];
+		}
+
+		~DataGuard()
+		{
+			delete[] data;
+		}
+
+		ModbusRTU::ModbusData* data;
+	};
+	// -----------------------------------------------------------------------------
 	MBExchange::MBExchange(uniset::ObjectId objId, uniset::ObjectId shmId,
 						   const std::shared_ptr<SharedMemory>& _ic, const std::string& prefix ):
 		UniSetObject(objId),
@@ -715,7 +731,7 @@ namespace uniset
 			return true;
 
 		auto dev = p->dev;
-		unsigned int q_count = p->p.rnum;
+		size_t q_count = p->p.rnum;
 
 		if( mblog->is_level3()  )
 		{
@@ -754,38 +770,36 @@ namespace uniset
 			case ModbusRTU::fnReadInputStatus:
 			{
 				ModbusRTU::ReadInputStatusRetMessage ret = mb->read02(dev->mbaddr, p->mbreg, q_count);
-				ModbusRTU::ModbusData* dat = new ModbusRTU::ModbusData[q_count];
-				unsigned int m = 0;
+				DataGuard d(q_count);
+				size_t m = 0;
 
-				for( unsigned int i = 0; i < ret.bcnt; i++ )
+				for( size_t i = 0; i < ret.bcnt; i++ )
 				{
 					ModbusRTU::DataBits b(ret.data[i]);
 
-					for( unsigned int k = 0; k < ModbusRTU::BitsPerByte && m < q_count; k++, m++ )
-						dat[m] = b[k];
+					for( size_t k = 0; k < ModbusRTU::BitsPerByte && m < q_count; k++, m++ )
+						d.data[m] = b[k];
 				}
 
-				p->initOK = initSMValue(dat, q_count, &(p->p));
-				delete[] dat;
+				p->initOK = initSMValue(d.data, q_count, &(p->p));
 			}
 			break;
 
 			case ModbusRTU::fnReadCoilStatus:
 			{
 				ModbusRTU::ReadCoilRetMessage ret = mb->read01(dev->mbaddr, p->mbreg, q_count);
-				ModbusRTU::ModbusData* dat = new ModbusRTU::ModbusData[q_count];
-				unsigned int m = 0;
+				DataGuard d(q_count);
+				size_t m = 0;
 
-				for( unsigned int i = 0; i < ret.bcnt; i++ )
+				for( size_t i = 0; i < ret.bcnt; i++ )
 				{
 					ModbusRTU::DataBits b(ret.data[i]);
 
-					for( unsigned int k = 0; k < ModbusRTU::BitsPerByte && m < q_count; k++, m++ )
-						dat[m] = b[k];
+					for( size_t k = 0; k < ModbusRTU::BitsPerByte && m < q_count; k++, m++ )
+						d.data[m] = b[k];
 				}
 
-				p->initOK = initSMValue(dat, q_count, &(p->p));
-				delete[] dat;
+				p->initOK = initSMValue(d.data, q_count, &(p->p));
 			}
 			break;
 
@@ -833,7 +847,7 @@ namespace uniset
 						IOBase::processingAsDI( p, data[0], shm, true );
 					}
 					else
-						IOBase::processingAsAI( p, (signed short)(data[0]), shm, true );
+						IOBase::processingAsAI( p, (int16_t)(data[0]), shm, true );
 
 					return true;
 				}
@@ -851,7 +865,7 @@ namespace uniset
 					IOBase::processingAsDI( p, data[0], shm, true );
 				}
 				else
-					IOBase::processingAsAI( p, (signed short)(data[0]), shm, true );
+					IOBase::processingAsAI( p, (int16_t)(data[0]), shm, true );
 
 				return true;
 			}
@@ -863,7 +877,7 @@ namespace uniset
 					IOBase::processingAsDI( p, data[0], shm, true );
 				}
 				else
-					IOBase::processingAsAI( p, (unsigned short)data[0], shm, true );
+					IOBase::processingAsAI( p, (uint16_t)data[0], shm, true );
 
 				return true;
 			}
@@ -898,22 +912,22 @@ namespace uniset
 			else if( p->vType == VTypes::vtI2 )
 			{
 				VTypes::I2 i2(data, VTypes::I2::wsize());
-				IOBase::processingAsAI( p, (int)i2, shm, true );
+				IOBase::processingAsAI( p, (int32_t)i2, shm, true );
 			}
 			else if( p->vType == VTypes::vtI2r )
 			{
 				VTypes::I2r i2(data, VTypes::I2::wsize());
-				IOBase::processingAsAI( p, (int)i2, shm, true );
+				IOBase::processingAsAI( p, (int32_t)i2, shm, true );
 			}
 			else if( p->vType == VTypes::vtU2 )
 			{
 				VTypes::U2 u2(data, VTypes::U2::wsize());
-				IOBase::processingAsAI( p, (unsigned int)u2, shm, true );
+				IOBase::processingAsAI( p, (uint32_t)u2, shm, true );
 			}
 			else if( p->vType == VTypes::vtU2r )
 			{
 				VTypes::U2r u2(data, VTypes::U2::wsize());
-				IOBase::processingAsAI( p, (unsigned int)u2, shm, true );
+				IOBase::processingAsAI( p, (uint32_t)u2, shm, true );
 			}
 
 			return true;
@@ -996,7 +1010,7 @@ namespace uniset
 			{
 				ModbusRTU::ReadInputRetMessage ret = mb->read04(dev->mbaddr, p->mbreg, p->q_count);
 
-				for( unsigned int i = 0; i < p->q_count; i++, it++ )
+				for( size_t i = 0; i < p->q_count; i++, it++ )
 				{
 					it->second->mbval = ret.data[i];
 					it->second->mb_initOK = true;
@@ -1010,7 +1024,7 @@ namespace uniset
 			{
 				ModbusRTU::ReadOutputRetMessage ret = mb->read03(dev->mbaddr, p->mbreg, p->q_count);
 
-				for( unsigned int i = 0; i < p->q_count; i++, it++ )
+				for( size_t i = 0; i < p->q_count; i++, it++ )
 				{
 					it->second->mbval = ret.data[i];
 					it->second->mb_initOK = true;
@@ -1023,13 +1037,13 @@ namespace uniset
 			case ModbusRTU::fnReadInputStatus:
 			{
 				ModbusRTU::ReadInputStatusRetMessage ret = mb->read02(dev->mbaddr, p->mbreg, p->q_count);
-				unsigned int m = 0;
+				size_t m = 0;
 
 				for( uint i = 0; i < ret.bcnt; i++ )
 				{
 					ModbusRTU::DataBits b(ret.data[i]);
 
-					for( unsigned int k = 0; k < ModbusRTU::BitsPerByte && m < p->q_count; k++, it++, m++ )
+					for( size_t k = 0; k < ModbusRTU::BitsPerByte && m < p->q_count; k++, it++, m++ )
 					{
 						it->second->mbval = b[k];
 						it->second->mb_initOK = true;
@@ -1043,13 +1057,13 @@ namespace uniset
 			case ModbusRTU::fnReadCoilStatus:
 			{
 				ModbusRTU::ReadCoilRetMessage ret = mb->read01(dev->mbaddr, p->mbreg, p->q_count);
-				unsigned int m = 0;
+				size_t m = 0;
 
 				for( auto i = 0; i < ret.bcnt; i++ )
 				{
 					ModbusRTU::DataBits b(ret.data[i]);
 
-					for( unsigned int k = 0; k < ModbusRTU::BitsPerByte && m < p->q_count; k++, it++, m++ )
+					for( size_t k = 0; k < ModbusRTU::BitsPerByte && m < p->q_count; k++, it++, m++ )
 					{
 						it->second->mbval = b[k] ? 1 : 0;
 						it->second->mb_initOK = true;
@@ -1102,7 +1116,7 @@ namespace uniset
 
 				ModbusRTU::WriteOutputMessage msg(dev->mbaddr, p->mbreg);
 
-				for( unsigned int i = 0; i < p->q_count; i++, it++ )
+				for( size_t i = 0; i < p->q_count; i++, it++ )
 					msg.addData(it->second->mbval);
 
 				it--;
@@ -1144,7 +1158,7 @@ namespace uniset
 
 				ModbusRTU::ForceCoilsMessage msg(dev->mbaddr, p->mbreg);
 
-				for( unsigned i = 0; i < p->q_count; i++, it++ )
+				for( size_t i = 0; i < p->q_count; i++, it++ )
 					msg.addBit( (it->second->mbval ? true : false) );
 
 				it--;
@@ -1400,10 +1414,10 @@ namespace uniset
 						if( p->stype == UniversalIO::DI ||
 								p->stype == UniversalIO::DO )
 						{
-							r->mbval = (unsigned short)IOBase::processingAsDO( p, shm, force_out );
+							r->mbval = (uint16_t)IOBase::processingAsDO( p, shm, force_out );
 						}
 						else
-							r->mbval = (unsigned short)IOBase::processingAsAO( p, shm, force_out );
+							r->mbval = (uint16_t)IOBase::processingAsAO( p, shm, force_out );
 
 						r->sm_initOK = true;
 					}
@@ -1417,7 +1431,7 @@ namespace uniset
 					}
 					else
 					{
-						IOBase::processingAsAI( p, (unsigned short)r->mbval, shm, force );
+						IOBase::processingAsAI( p, (uint16_t)r->mbval, shm, force );
 					}
 				}
 
@@ -1481,26 +1495,24 @@ namespace uniset
 				}
 				else
 				{
-					ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[VTypes::F2::wsize()];
+					DataGuard d(VTypes::F2::wsize());
 
 					for( size_t k = 0; k < VTypes::F2::wsize(); k++, i++ )
-						data[k] = i->second->mbval;
+						d.data[k] = i->second->mbval;
 
 					float f = 0;
 
 					if( p->vType == VTypes::vtF2 )
 					{
-						VTypes::F2 f1(data, VTypes::F2::wsize());
+						VTypes::F2 f1(d.data, VTypes::F2::wsize());
 						f = (float)f1;
 					}
 					else if( p->vType == VTypes::vtF2r )
 					{
-						VTypes::F2r f1(data, VTypes::F2r::wsize());
+						VTypes::F2r f1(d.data, VTypes::F2r::wsize());
 						f = (float)f1;
 					}
 
-					delete[] data;
-
 					IOBase::processingFasAI( p, f, shm, force );
 				}
 			}
@@ -1523,13 +1535,12 @@ namespace uniset
 				}
 				else
 				{
-					ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[VTypes::F4::wsize()];
+					DataGuard d(VTypes::F4::wsize());
 
 					for( size_t k = 0; k < VTypes::F4::wsize(); k++, i++ )
-						data[k] = i->second->mbval;
+						d.data[k] = i->second->mbval;
 
-					VTypes::F4 f(data, VTypes::F4::wsize());
-					delete[] data;
+					VTypes::F4 f(d.data, VTypes::F4::wsize());
 
 					IOBase::processingFasAI( p, (float)f, shm, force );
 				}
@@ -1546,14 +1557,14 @@ namespace uniset
 
 						if( p->vType == VTypes::vtI2 )
 						{
-							VTypes::I2 i2(v);
+							VTypes::I2 i2( (int32_t)v );
 
 							for( size_t k = 0; k < VTypes::I2::wsize(); k++, i++ )
 								i->second->mbval = i2.raw.v[k];
 						}
 						else if( p->vType == VTypes::vtI2r )
 						{
-							VTypes::I2r i2(v);
+							VTypes::I2r i2( (int32_t)v );
 
 							for( size_t k = 0; k < VTypes::I2::wsize(); k++, i++ )
 								i->second->mbval = i2.raw.v[k];
@@ -1564,25 +1575,24 @@ namespace uniset
 				}
 				else
 				{
-					ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[VTypes::I2::wsize()];
+					DataGuard d(VTypes::I2::wsize());
 
 					for( size_t k = 0; k < VTypes::I2::wsize(); k++, i++ )
-						data[k] = i->second->mbval;
+						d.data[k] = i->second->mbval;
 
 					int v = 0;
 
 					if( p->vType == VTypes::vtI2 )
 					{
-						VTypes::I2 i2(data, VTypes::I2::wsize());
+						VTypes::I2 i2(d.data, VTypes::I2::wsize());
 						v = (int)i2;
 					}
 					else if( p->vType == VTypes::vtI2r )
 					{
-						VTypes::I2r i2(data, VTypes::I2::wsize());
+						VTypes::I2r i2(d.data, VTypes::I2::wsize());
 						v = (int)i2;
 					}
 
-					delete[] data;
 					IOBase::processingAsAI( p, v, shm, force );
 				}
 			}
@@ -1616,25 +1626,24 @@ namespace uniset
 				}
 				else
 				{
-					ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[VTypes::U2::wsize()];
+					DataGuard d(VTypes::U2::wsize());
 
 					for( size_t k = 0; k < VTypes::U2::wsize(); k++, i++ )
-						data[k] = i->second->mbval;
+						d.data[k] = i->second->mbval;
 
-					unsigned int v = 0;
+					uint32_t v = 0;
 
 					if( p->vType == VTypes::vtU2 )
 					{
-						VTypes::U2 u2(data, VTypes::U2::wsize());
-						v = (unsigned int)u2;
+						VTypes::U2 u2(d.data, VTypes::U2::wsize());
+						v = (uint32_t)u2;
 					}
 					else if( p->vType == VTypes::vtU2r )
 					{
-						VTypes::U2r u2(data, VTypes::U2::wsize());
-						v = (unsigned int)u2;
+						VTypes::U2r u2(d.data, VTypes::U2::wsize());
+						v = (uint32_t)u2;
 					}
 
-					delete[] data;
 					IOBase::processingAsAI( p, v, shm, force );
 				}
 			}
@@ -1727,18 +1736,17 @@ namespace uniset
 						{
 							MTR::T3 t(IOBase::processingAsAO( &(*it), shm, force_out ));
 
-							for( unsigned int k = 0; k < MTR::T3::wsize(); k++, i++ )
+							for( size_t k = 0; k < MTR::T3::wsize(); k++, i++ )
 								i->second->mbval = t.raw.v[k];
 						}
 						else
 						{
-							ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[MTR::T3::wsize()];
+							DataGuard d(MTR::T3::wsize());
 
-							for( unsigned int k = 0; k < MTR::T3::wsize(); k++, i++ )
-								data[k] = i->second->mbval;
+							for( size_t k = 0; k < MTR::T3::wsize(); k++, i++ )
+								d.data[k] = i->second->mbval;
 
-							MTR::T3 t(data, MTR::T3::wsize());
-							delete[] data;
+							MTR::T3 t(d.data, MTR::T3::wsize());
 							IOBase::processingAsAI( &(*it), (long)t, shm, force );
 						}
 
@@ -1768,18 +1776,17 @@ namespace uniset
 						{
 							MTR::T5 t(IOBase::processingAsAO( &(*it), shm, force_out ));
 
-							for( unsigned int k = 0; k < MTR::T5::wsize(); k++, i++ )
+							for( size_t k = 0; k < MTR::T5::wsize(); k++, i++ )
 								i->second->mbval = t.raw.v[k];
 						}
 						else
 						{
-							ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[MTR::T5::wsize()];
+							DataGuard d(MTR::T5::wsize());
 
-							for( unsigned int k = 0; k < MTR::T5::wsize(); k++, i++ )
-								data[k] = i->second->mbval;
+							for( size_t k = 0; k < MTR::T5::wsize(); k++, i++ )
+								d.data[k] = i->second->mbval;
 
-							MTR::T5 t(data, MTR::T5::wsize());
-							delete[] data;
+							MTR::T5 t(d.data, MTR::T5::wsize());
 
 							IOBase::processingFasAI( &(*it), (float)t.val, shm, force );
 						}
@@ -1795,18 +1802,17 @@ namespace uniset
 						{
 							MTR::T6 t(IOBase::processingAsAO( &(*it), shm, force_out ));
 
-							for( unsigned int k = 0; k < MTR::T6::wsize(); k++, i++ )
+							for( size_t k = 0; k < MTR::T6::wsize(); k++, i++ )
 								i->second->mbval = t.raw.v[k];
 						}
 						else
 						{
-							ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[MTR::T6::wsize()];
+							DataGuard d(MTR::T6::wsize());
 
-							for( unsigned int k = 0; k < MTR::T6::wsize(); k++, i++ )
-								data[k] = i->second->mbval;
+							for( size_t k = 0; k < MTR::T6::wsize(); k++, i++ )
+								d.data[k] = i->second->mbval;
 
-							MTR::T6 t(data, MTR::T6::wsize());
-							delete[] data;
+							MTR::T6 t(d.data, MTR::T6::wsize());
 
 							IOBase::processingFasAI( &(*it), (float)t.val, shm, force );
 						}
@@ -1822,18 +1828,17 @@ namespace uniset
 						{
 							MTR::T7 t(IOBase::processingAsAO( &(*it), shm, force_out ));
 
-							for( unsigned int k = 0; k < MTR::T7::wsize(); k++, i++ )
+							for( size_t k = 0; k < MTR::T7::wsize(); k++, i++ )
 								i->second->mbval = t.raw.v[k];
 						}
 						else
 						{
-							ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[MTR::T7::wsize()];
+							DataGuard d(MTR::T7::wsize());
 
-							for( unsigned int k = 0; k < MTR::T7::wsize(); k++, i++ )
-								data[k] = i->second->mbval;
+							for( size_t k = 0; k < MTR::T7::wsize(); k++, i++ )
+								d.data[k] = i->second->mbval;
 
-							MTR::T7 t(data, MTR::T7::wsize());
-							delete[] data;
+							MTR::T7 t(d.data, MTR::T7::wsize());
 
 							IOBase::processingFasAI( &(*it), (float)t.val, shm, force );
 						}
@@ -1882,19 +1887,17 @@ namespace uniset
 							float f = IOBase::processingFasAO( &(*it), shm, force_out );
 							MTR::F1 f1(f);
 
-							for( unsigned int k = 0; k < MTR::F1::wsize(); k++, i++ )
+							for( size_t k = 0; k < MTR::F1::wsize(); k++, i++ )
 								i->second->mbval = f1.raw.v[k];
 						}
 						else
 						{
-							ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[MTR::F1::wsize()];
-
-							for( unsigned int k = 0; k < MTR::F1::wsize(); k++, i++ )
-								data[k] = i->second->mbval;
+							DataGuard d(MTR::F1::wsize());
 
-							MTR::F1 t(data, MTR::F1::wsize());
-							delete[] data;
+							for( size_t k = 0; k < MTR::F1::wsize(); k++, i++ )
+								d.data[k] = i->second->mbval;
 
+							MTR::F1 t(d.data, MTR::F1::wsize());
 							IOBase::processingFasAI( &(*it), (float)t, shm, force );
 						}
 

extensions/ModbusMaster/tests/MBTCPTestServer.cc

 // -------------------------------------------------------------------------
 #include <sstream>
+#include <limits>
 #include <Poco/Net/NetException.h>
 #include "UniSetTypes.h"
 #include "MBTCPTestServer.h"
@@ -23,7 +24,7 @@ MBTCPTestServer::MBTCPTestServer( const std::unordered_set<ModbusAddr>& _vaddr,
 	sslot(NULL),
 	vaddr(_vaddr),
 	verbose(verb),
-	replyVal(-1),
+	replyVal(std::numeric_limits<uint32_t>::max()),
 	forceSingleCoilCmd(false),
 	lastWriteOutputSingleRegister(0),
 	lastForceCoilsQ(0, 0),
@@ -122,7 +123,7 @@ ModbusRTU::mbErrCode MBTCPTestServer::readCoilStatus( ReadCoilMessage& query,
 
 	if( query.count <= 1 )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(d);
@@ -136,7 +137,7 @@ ModbusRTU::mbErrCode MBTCPTestServer::readCoilStatus( ReadCoilMessage& query,
 
 	for( ; num < query.count; num++, reg++ )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(d);
@@ -167,7 +168,7 @@ ModbusRTU::mbErrCode MBTCPTestServer::readInputStatus( ReadInputStatusMessage& q
 	d.b[3] = 1;
 	d.b[7] = 1;
 
-	if( replyVal == -1 )
+	if( replyVal == std::numeric_limits<uint32_t>::max() )
 	{
 		size_t bnum = 0;
 		size_t i = 0;
@@ -207,7 +208,7 @@ mbErrCode MBTCPTestServer::readInputRegisters( ReadInputMessage& query,
 
 	if( query.count <= 1 )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(query.start);
@@ -221,7 +222,7 @@ mbErrCode MBTCPTestServer::readInputRegisters( ReadInputMessage& query,
 
 	for( ; num < query.count; num++, reg++ )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(reg);
@@ -252,7 +253,7 @@ ModbusRTU::mbErrCode MBTCPTestServer::readOutputRegisters(
 
 	if( query.count <= 1 )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(query.start);
@@ -266,7 +267,7 @@ ModbusRTU::mbErrCode MBTCPTestServer::readOutputRegisters(
 
 	for( ; num < query.count; num++, reg++ )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(reg);

extensions/ModbusMaster/tests/MBTCPTestServer.h

@@ -19,7 +19,7 @@ class MBTCPTestServer
 			verbose = state;
 		}
 
-		inline void setReply( long val )
+		inline void setReply( uint32_t val )
 		{
 			replyVal = val;
 		}
@@ -47,7 +47,7 @@ class MBTCPTestServer
 		{
 			return forceSingleCoilCmd;
 		}
-		inline int getLastWriteOutputSingleRegister()
+		inline int16_t getLastWriteOutputSingleRegister()
 		{
 			return lastWriteOutputSingleRegister;
 		}
@@ -131,9 +131,9 @@ class MBTCPTestServer
 		std::unordered_set<uniset::ModbusRTU::ModbusAddr> vaddr; /*!< адреса данного узла */
 
 		bool verbose;
-		long replyVal;
+		uint32_t replyVal;
 		bool forceSingleCoilCmd;
-		int lastWriteOutputSingleRegister;
+		int16_t lastWriteOutputSingleRegister;
 		uniset::ModbusRTU::ForceCoilsMessage lastForceCoilsQ;
 		uniset::ModbusRTU::WriteOutputMessage lastWriteOutputQ;
 		float f2_test_value = {0.0};

extensions/ModbusMaster/tests/test_mbtcpmaster.cc

@@ -222,12 +222,12 @@ TEST_CASE("MBTCPMaster: 0x03 (read register outputs or memories or read word out
 	REQUIRE( ui->getValue(1004) == -10 );
 	REQUIRE( ui->getValue(1005) == -10 );
 	REQUIRE( ui->getValue(1006) == -10 );
-	mbs->setReply(0);
+	mbs->setReply(1);
 	msleep(polltime + 200);
-	REQUIRE( ui->getValue(1003) == 0 );
-	REQUIRE( ui->getValue(1004) == 0 );
-	REQUIRE( ui->getValue(1005) == 0 );
-	REQUIRE( ui->getValue(1006) == 0 );
+	REQUIRE( ui->getValue(1003) == 1 );
+	REQUIRE( ui->getValue(1004) == 1 );
+	REQUIRE( ui->getValue(1005) == 1 );
+	REQUIRE( ui->getValue(1006) == 1 );
 	mbs->setReply(65535);
 	msleep(polltime + 200);
 	REQUIRE( ui->getValue(1003) == -1 );
@@ -236,10 +236,14 @@ TEST_CASE("MBTCPMaster: 0x03 (read register outputs or memories or read word out
 	REQUIRE( ui->getValue(1006) == -1 );
 	REQUIRE( ui->getValue(1007) == 65535 ); // unsigned
 
-	mbs->setReply(0xffff);
+	mbs->setReply( std::numeric_limits<uint16_t>::max() );
+	msleep(polltime + 200);
+	REQUIRE( (uint16_t)ui->getValue(1009) == std::numeric_limits<uint16_t>::max() ); // U2
+
+	mbs->setReply( std::numeric_limits<int16_t>::max() );
 	msleep(polltime + 200);
-	REQUIRE( ui->getValue(1008) == 0xffffffff ); // I2
-	REQUIRE( ui->getValue(1009) == 0xffffffff ); // U2
+	REQUIRE( (int16_t)ui->getValue(1008) == std::numeric_limits<int16_t>::max() ); // I2
+
 	mbs->setReply(0xff);
 	msleep(polltime + 200);
 	REQUIRE( ui->getValue(1008) == 0x00ff00ff ); // I2
@@ -281,10 +285,14 @@ TEST_CASE("MBTCPMaster: 0x04 (read input registers or memories or read word outp
 	REQUIRE( ui->getValue(1013) == -1 );
 	REQUIRE( ui->getValue(1014) == 65535 ); // unsigned
 
-	mbs->setReply(0xffff);
+	mbs->setReply( std::numeric_limits<uint16_t>::max() );
 	msleep(polltime + 200);
-	REQUIRE( ui->getValue(1015) == 0xffffffff ); // I2
-	REQUIRE( ui->getValue(1016) == 0xffffffff ); // U2
+	REQUIRE( (uint16_t)ui->getValue(1009) == std::numeric_limits<uint16_t>::max() ); // U2
+
+	mbs->setReply( std::numeric_limits<int16_t>::max() );
+	msleep(polltime + 200);
+	REQUIRE( (int16_t)ui->getValue(1008) == std::numeric_limits<int16_t>::max() ); // I2
+
 	mbs->setReply(0xff);
 	msleep(polltime + 200);
 	REQUIRE( ui->getValue(1015) == 0x00ff00ff ); // I2
@@ -457,23 +465,23 @@ TEST_CASE("MBTCPMaster: 0x10 (write register outputs or memories)", "[modbus][0x
 		REQUIRE( q.addr == slaveADDR );
 		REQUIRE( q.start == 31 );
 		REQUIRE( q.quant == 6 );
-		REQUIRE( q.data[0] == (unsigned short)(-100) );
-		REQUIRE( q.data[2] == (unsigned short)(-10) );
-		REQUIRE( q.data[3] == (unsigned short)(-32767) );
+		REQUIRE( q.data[0] == (uint16_t)(-100) );
+		REQUIRE( q.data[2] == (uint16_t)(-10) );
+		REQUIRE( q.data[3] == (uint16_t)(-32767) );
 	}
 
 	SECTION("I2")
 	{
-		ui->setValue(1023, 0xffffffff);
-		REQUIRE( ui->getValue(1023) == 0xffffffff );
+		ui->setValue(1023, std::numeric_limits<uint32_t>::max());
+		REQUIRE( (uint32_t)ui->getValue(1023) == std::numeric_limits<uint32_t>::max() );
 		msleep(polltime + 200);
 
 		ModbusRTU::WriteOutputMessage q = mbs->getLastWriteOutput();
 		REQUIRE( q.addr == slaveADDR );
 		REQUIRE( q.start == 31 );
 		REQUIRE( q.quant == 6 );
-		REQUIRE( q.data[4] == 0xffff );
-		REQUIRE( q.data[5] == 0xffff );
+		REQUIRE( q.data[4] == std::numeric_limits<uint16_t>::max() );
+		REQUIRE( q.data[5] == std::numeric_limits<uint16_t>::max() );
 	}
 }
 // -----------------------------------------------------------------------------

extensions/ModbusMaster/tests/test_mbtcpmultimaster.cc

@@ -127,6 +127,8 @@ TEST_CASE("MBTCPMultiMaster: rotate channel", "[modbus][mbmaster][mbtcpmultimast
 	InitTest();
 	CHECK( ui->isExist(mbID) );
 
+	mbs1->setReply(0);
+	msleep(polltime + 1000);
 	REQUIRE( ui->getValue(1003) == 0 );
 	mbs1->setReply(100);
 	mbs2->setReply(10);

extensions/include/VTypes.h

@@ -19,6 +19,7 @@
 #define _RTUTypes_H_
 // -----------------------------------------------------------------------------
 #include <string>
+#include <stdint.h>
 #include <cmath>
 #include <cstring>
 #include <ostream>
@@ -61,7 +62,7 @@ namespace uniset
 				/*! тип хранения в памяти */
 				typedef union
 				{
-					unsigned short v[f2Size];
+					uint16_t v[f2Size];
 					float val; //
 				} F2mem;
 				// ------------------------------------------
@@ -147,7 +148,7 @@ namespace uniset
 				/*! тип хранения в памяти */
 				typedef union
 				{
-					unsigned short v[f4Size];
+					uint16_t v[f4Size];
 					float val; //
 				} F4mem;
 				// ------------------------------------------
@@ -202,8 +203,8 @@ namespace uniset
 				/*! тип хранения в памяти */
 				typedef union
 				{
-					unsigned short w;
-					unsigned char b[bsize];
+					uint16_t w;
+					uint8_t b[bsize];
 				} Bytemem;
 				// ------------------------------------------
 				// конструкторы на разные случаи...
@@ -212,15 +213,11 @@ namespace uniset
 					raw.w = 0;
 				}
 
-				Byte( unsigned char b1, unsigned char b2 ) noexcept
+				Byte( uint8_t b1, uint8_t b2 ) noexcept
 				{
 					raw.b[0] = b1;
 					raw.b[1] = b2;
 				}
-				Byte( const long& val ) noexcept
-				{
-					raw.w = val;
-				}
 
 				Byte( const ModbusRTU::ModbusData dat ) noexcept
 				{
@@ -240,16 +237,12 @@ namespace uniset
 					return vtByte;
 				}
 				// ------------------------------------------
-				operator long()
-				{
-					return lroundf(raw.w);
-				}
-				operator unsigned short()
+				operator uint16_t()
 				{
 					return raw.w;
 				}
 
-				unsigned char operator[]( const int i )
+				uint8_t operator[]( const size_t i )
 				{
 					return raw.b[i];
 				}
@@ -293,7 +286,7 @@ namespace uniset
 					return raw;
 				}
 
-				unsigned short raw;
+				uint16_t raw;
 		};
 		// --------------------------------------------------------------------------
 		class Signed
@@ -332,7 +325,7 @@ namespace uniset
 					return raw;
 				}
 
-				signed short raw;
+				int16_t raw;
 		};
 		// --------------------------------------------------------------------------
 		class I2
@@ -344,8 +337,8 @@ namespace uniset
 				/*! тип хранения в памяти */
 				typedef union
 				{
-					unsigned short v[i2Size];
-					int val; //
+					uint16_t v[i2Size];
+					int32_t val; //
 				} I2mem;
 				// ------------------------------------------
 				// конструкторы на разные случаи...
@@ -354,7 +347,7 @@ namespace uniset
 					memset(raw.v, 0, sizeof(raw.v));
 				}
 
-				I2( int v ) noexcept
+				I2( int32_t v ) noexcept
 				{
 					raw.val = v;
 				}
@@ -377,7 +370,7 @@ namespace uniset
 					return vtI2;
 				}
 				// ------------------------------------------
-				operator int()
+				operator int32_t()
 				{
 					return raw.val;
 				}
@@ -394,7 +387,7 @@ namespace uniset
 					raw_backorder.val = 0;
 				}
 
-				I2r( const int v ) noexcept: I2(v)
+				I2r( const int32_t v ) noexcept: I2(v)
 				{
 					raw_backorder = raw;
 					std::swap(raw_backorder.v[0], raw_backorder.v[1]);
@@ -421,8 +414,8 @@ namespace uniset
 				/*! тип хранения в памяти */
 				typedef union
 				{
-					unsigned short v[u2Size];
-					unsigned int val; //
+					uint16_t v[u2Size];
+					uint32_t val; //
 				} U2mem;
 				// ------------------------------------------
 				// конструкторы на разные случаи...
@@ -431,7 +424,7 @@ namespace uniset
 					memset(raw.v, 0, sizeof(raw.v));
 				}
 
-				U2( unsigned int v ) noexcept
+				U2( uint32_t v ) noexcept
 				{
 					raw.val = v;
 				}
@@ -454,11 +447,21 @@ namespace uniset
 					return vtU2;
 				}
 				// ------------------------------------------
-				operator unsigned int()
+				operator uint32_t()
+				{
+					return raw.val;
+				}
+
+				operator long()
 				{
 					return raw.val;
 				}
 
+				operator unsigned long()
+				{
+					return (uint32_t)raw.val;
+				}
+
 				U2mem raw;
 		};
 		// --------------------------------------------------------------------------
@@ -471,7 +474,7 @@ namespace uniset
 					raw_backorder.val = 0;
 				}
 
-				U2r( int v ) noexcept: U2(v)
+				U2r( int32_t v ) noexcept: U2(v)
 				{
 					raw_backorder = raw;
 					std::swap(raw_backorder.v[0], raw_backorder.v[1]);