(MBTCPMaster): исправил ошибки в логах

extensions/UNetUDP/UNetSender.cc

@@ -115,7 +115,7 @@ bool UNetSender::createConnection( bool throwEx )
 		//udp = make_shared<UDPSocketU>(addr, port);
 		udp = make_shared<UDPSocketU>();
 		udp->setBroadcast(true);
-		udp->setSendTimeout(UniSetTimer::timeoutToPoco(writeTimeout * 1000));
+		udp->setSendTimeout( UniSetTimer::millisecToPoco(writeTimeout) );
 		//		udp->setNoDelay(true);
 	}
 	catch( const std::exception& e )
@@ -286,14 +286,14 @@ void UNetSender::real_send( PackMessage& mypack )
 	if( packetnum == 0 )
 		packetnum = 1;
 
-	if( !udp || !udp->poll(writeTimeout * 1000, Poco::Net::Socket::SELECT_WRITE) )
+	if( !udp || !udp->poll( UniSetTimer::millisecToPoco(writeTimeout), Poco::Net::Socket::SELECT_WRITE) )
 		return;
 
 	mypack.msg.transport_msg(s_msg);
 
 	try
 	{
-		size_t ret = udp->sendTo((char*)s_msg.data, s_msg.len, saddr);
+		size_t ret = udp->sendTo(&s_msg.data, s_msg.len, saddr);
 
 		if( ret < s_msg.len )
 			unetcrit << myname << "(real_send): FAILED ret=" << ret << " < sizeof=" << s_msg.len << endl;

extensions/UNetUDP/tests/test_unetudp.cc

@@ -63,7 +63,7 @@ static UniSetUDP::UDPMessage receive( unsigned int pnum = 0, timeout_t tout = 20
 
 	while( ncycle > 0 )
 	{
-		if( !udp_r->poll(tout * 1000, Poco::Net::Socket::SELECT_READ) )
+		if( !udp_r->poll(UniSetTimer::millisecToPoco(tout), Poco::Net::Socket::SELECT_READ) )
 			break;
 
 		size_t ret = udp_r->receiveBytes(&(buf.data), sizeof(buf.data) );
@@ -81,7 +81,7 @@ static UniSetUDP::UDPMessage receive( unsigned int pnum = 0, timeout_t tout = 20
 // -----------------------------------------------------------------------------
 void send( UniSetUDP::UDPMessage& pack, int tout = 2000 )
 {
-	CHECK( udp_s->poll(tout * 1000, Poco::Net::Socket::SELECT_WRITE) );
+	CHECK( udp_s->poll(UniSetTimer::millisecToPoco(tout), Poco::Net::Socket::SELECT_WRITE) );
 
 	pack.nodeID = s_nodeID;
 	pack.procID = s_procID;
@@ -89,7 +89,7 @@ void send( UniSetUDP::UDPMessage& pack, int tout = 2000 )
 
 	UniSetUDP::UDPPacket s_buf;
 	pack.transport_msg(s_buf);
-	size_t ret = udp_s->sendTo((char*)&s_buf.data, s_buf.len, s_addr);
+	size_t ret = udp_s->sendTo(&s_buf.data, s_buf.len, s_addr);
 	REQUIRE( ret == s_buf.len );
 }
 // -----------------------------------------------------------------------------

extensions/UNetUDP/unet-udp-tester.cc

@@ -243,7 +243,7 @@ int main(int argc, char* argv[])
 							npack = 0;
 						}
 
-						if( !udp.poll(tout * 1000, Poco::Net::Socket::SELECT_READ) )
+						if( !udp.poll(UniSetTimer::millisecToPoco(tout), Poco::Net::Socket::SELECT_READ) )
 						{
 							cout << "(recv): Timeout.." << endl;
 							continue;
@@ -362,7 +362,7 @@ int main(int argc, char* argv[])
 
 					try
 					{
-						if( udp->poll(tout * 1000, Poco::Net::Socket::SELECT_WRITE) )
+						if( udp->poll(UniSetTimer::millisecToPoco(tout), Poco::Net::Socket::SELECT_WRITE) )
 						{
 							mypack.transport_msg(s_buf);
 

include/PassiveTimer.h

@@ -65,8 +65,9 @@ class UniSetTimer
 		 */
 		static const timeout_t WaitUpTime = std::numeric_limits<timeout_t>::max();
 
-		// преобразование WaitUpTime в Poco waitpuTime у которого он = 0 :(
-		static const Poco::Timespan timeoutToPoco( const timeout_t );
+		// преобразование с учётом WaitUpTime, т.к. в Poco::Timespan вечное ожидание это "0" :(
+		static const Poco::Timespan millisecToPoco( const timeout_t msec );
+		static const Poco::Timespan microsecToPoco( const timeout_t usec );
 
 		/*! Минимальное время срабатывания. Задается в мсек.
 		 * Используется в LT_Object и CallbackTimer

src/Communications/Modbus/ModbusTCPMaster.cc

@@ -58,7 +58,7 @@ void ModbusTCPMaster::setChannelTimeout( timeout_t msec )
 	if( !tcp )
 		return;
 
-	Poco::Timespan tm = UniSetTimer::timeoutToPoco(msec*1000);
+	Poco::Timespan tm = UniSetTimer::millisecToPoco(msec);
 	Poco::Timespan old = tcp->getReceiveTimeout();;
 
 	if( old.microseconds() == tm.microseconds() )
@@ -112,17 +112,12 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 		assert(timeout);
 		ptTimeout.setTiming(timeout);
 
-		if( timeout == UniSetTimer::WaitUpTime )
-			tcp->setReceiveTimeout(0);
-		else
-			tcp->setReceiveTimeout(timeout * 1000);
-
+		tcp->setReceiveTimeout( UniSetTimer::millisecToPoco(timeout) );
 		msg.makeHead(++nTransaction, crcNoCheckit);
 
 		for( size_t i = 0; i < 2; i++ )
 		{
-			//if( tcp->isPending(ost::Socket::pendingOutput, timeout) )
-			if( tcp->poll(timeout * 1000, Poco::Net::Socket::SELECT_WRITE) )
+			if( tcp->poll(UniSetTimer::millisecToPoco(timeout), Poco::Net::Socket::SELECT_WRITE) )
 			{
 				mbErrCode res = send(msg);
 
@@ -168,7 +163,7 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 
 		//tcp->sync();
 
-		if( tcp->poll(timeout * 1000, Poco::Net::Socket::SELECT_READ ) )
+		if( tcp->poll(UniSetTimer::millisecToPoco(timeout), Poco::Net::Socket::SELECT_READ ) )
 		{
 			size_t ret = 0;
 
@@ -237,7 +232,6 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 			}
 
 			//
-
 			timeout = ptTimeout.getLeft(timeout);
 
 			if( timeout <= 0 )
@@ -295,7 +289,8 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 		if( dlog->is_crit() )
 			dlog->crit() << "(query): " << ex << endl;
 
-		tcp->forceDisconnect();
+		if( tcp )
+			tcp->forceDisconnect();
 	}
 	catch( const UniSetTypes::Exception& ex )
 	{
@@ -380,7 +375,7 @@ void ModbusTCPMaster::reconnect()
 	{
 		tcp = make_shared<UTCPStream>();
 		tcp->create(iaddr, port, 500);
-		tcp->setReceiveTimeout(UniSetTimer::timeoutToPoco(replyTimeOut_ms * 1000));
+		tcp->setReceiveTimeout(UniSetTimer::millisecToPoco(replyTimeOut_ms));
 		tcp->setKeepAliveParams((replyTimeOut_ms > 1000 ? replyTimeOut_ms / 1000 : 1));
 		tcp->setNoDelay(true);
 	}
@@ -389,7 +384,7 @@ void ModbusTCPMaster::reconnect()
 		if( dlog->debugging(Debug::CRIT) )
 		{
 			ostringstream s;
-			s << "(ModbusTCPMaster): connection " << s.str() << " error: " << e.what();
+			s << "(ModbusTCPMaster): connection " << iaddr << ":" << port << " error: " << e.what();
 			dlog->crit() << s.str() << std::endl;
 		}
 	}
@@ -398,7 +393,7 @@ void ModbusTCPMaster::reconnect()
 		if( dlog->debugging(Debug::CRIT) )
 		{
 			ostringstream s;
-			s << "(ModbusTCPMaster): connection " << s.str() << " error: catch ...";
+			s << "(ModbusTCPMaster): connection " << iaddr << ":" << port << " error: catch ...";
 			dlog->crit() << s.str() << std::endl;
 		}
 	}
@@ -430,7 +425,7 @@ void ModbusTCPMaster::connect( const Poco::Net::SocketAddress& addr, int _port )
 		tcp = make_shared<UTCPStream>();
 		tcp->create(iaddr, port, 500);
 		//tcp->connect(addr,500);
-		tcp->setReceiveTimeout(replyTimeOut_ms * 1000);
+		tcp->setReceiveTimeout(UniSetTimer::millisecToPoco(replyTimeOut_ms));
 		tcp->setKeepAlive(true); // tcp->setKeepAliveParams((replyTimeOut_ms > 1000 ? replyTimeOut_ms / 1000 : 1));
 		tcp->setNoDelay(true);
 	}

src/Log/LogReader.cc

@@ -19,6 +19,7 @@
 #include <Poco/Net/NetException.h>
 #include <iostream>
 #include <sstream>
+#include "PassiveTimer.h"
 #include "Exceptions.h"
 #include "LogReader.h"
 #include "UniSetTypes.h"
@@ -78,8 +79,8 @@ void LogReader::connect( const std::string& _addr, int _port, timeout_t msec )
 	{
 		tcp = make_shared<UTCPStream>();
 		tcp->create(iaddr, port, msec );
-		tcp->setReceiveTimeout( UniSetTimer::timeoutToPoco(inTimeout * 1000) );
-		tcp->setSendTimeout( UniSetTimer::timeoutToPoco(outTimeout * 1000) );
+		tcp->setReceiveTimeout( UniSetTimer::millisecToPoco(inTimeout) );
+		tcp->setSendTimeout( UniSetTimer::millisecToPoco(outTimeout) );
 		tcp->setKeepAlive(true);
 		tcp->setBlocking(true);
 	}
@@ -254,7 +255,7 @@ void LogReader::sendCommand(const std::string& _addr, int _port, std::vector<Com
 	{
 		int a = 2;
 
-		while( a > 0 && tcp->poll(reply_timeout * 1000, Poco::Net::Socket::SELECT_READ) )
+		while( a > 0 && tcp->poll(UniSetTimer::millisecToPoco(reply_timeout), Poco::Net::Socket::SELECT_READ) )
 		{
 			int n = tcp->available();
 
@@ -336,7 +337,7 @@ void LogReader::readlogs( const std::string& _addr, int _port, LogServerTypes::C
 				send_ok = true;
 			}
 
-			while( tcp->poll(inTimeout * 1000, Poco::Net::Socket::SELECT_READ) )
+			while( tcp->poll(UniSetTimer::millisecToPoco(inTimeout), Poco::Net::Socket::SELECT_READ) )
 			{
 				ssize_t n = tcp->available();
 
@@ -397,7 +398,7 @@ void LogReader::sendCommand(LogServerTypes::lsMessage& msg, bool verbose )
 
 	try
 	{
-		if( tcp->poll(outTimeout * 1000, Poco::Net::Socket::SELECT_WRITE) )
+		if( tcp->poll(UniSetTimer::millisecToPoco(outTimeout), Poco::Net::Socket::SELECT_WRITE) )
 		{
 			rlog.info() << "(LogReader): ** send command: cmd='" << msg.cmd << "' logname='" << msg.logname << "' data='" << msg.data << "'" << endl;
 			tcp->sendBytes((unsigned char*)(&msg), sizeof(msg));

src/Timers/PassiveTimer.cc

@@ -111,11 +111,20 @@ void UniSetTimer::stop()
 	terminate();
 }
 //------------------------------------------------------------------------------
-const Poco::Timespan UniSetTimer::timeoutToPoco( const timeout_t msec )
+const Poco::Timespan UniSetTimer::millisecToPoco( const timeout_t msec )
 {
 	if( msec == WaitUpTime )
 		return Poco::Timespan(0,0);
 
-	return Poco::Timespan(msec/100, msec%1000);
+	// msec --> usec
+	return Poco::Timespan( long(msec/1000), long((msec%1000)*1000) );
+}
+//------------------------------------------------------------------------------
+const Poco::Timespan UniSetTimer::microsecToPoco( const timeout_t usec )
+{
+	if( usec == WaitUpTime )
+		return Poco::Timespan(0,0);
+
+	return Poco::Timespan( long(usec/1000000), long(usec%1000000) );
 }
 //------------------------------------------------------------------------------

tests/develop.cc

@@ -32,6 +32,9 @@ class PtrMapHashFn
 
 int main( int argc, const char** argv )
 {
+	cerr << "2000%1000000=" << int(2000%1000000) << endl;
+	return 0;
+
 	unordered_map<const long*, const long*, PtrMapHashFn> vmap;
 
 	const long id = 10;

tests/test_passivetimer.cc

@@ -96,3 +96,52 @@ TEST_CASE("PassiveTimer: 1 msec", "[PassiveTimer][msec]" )
 	CHECK( pt.checkTime() );
 }
 // -----------------------------------------------------------------------------
+TEST_CASE("UniSetTimer: conv to Poco", "[PassiveTimer][poco]" )
+{
+	// msec --> Poco::Timespan
+	{
+		Poco::Timespan tm = UniSetTimer::millisecToPoco(2000);
+		REQUIRE( tm.seconds() == 2 );
+		REQUIRE( tm.totalMilliseconds() == 2000 );
+	}
+
+	{
+		Poco::Timespan tm = UniSetTimer::millisecToPoco(UniSetTimer::WaitUpTime);
+		REQUIRE( tm.seconds() == 0 );
+		REQUIRE( tm.microseconds() == 0 );
+	}
+
+	{
+		Poco::Timespan tm = UniSetTimer::millisecToPoco(20);
+		REQUIRE( tm.seconds() == 0 );
+		REQUIRE( tm.milliseconds() == 20 );
+		REQUIRE( tm.microseconds() == 0 );
+		REQUIRE( tm.totalMicroseconds() == 20000 );
+	}
+
+
+	// usec --> Poco::Timespan
+	{
+		Poco::Timespan tm = UniSetTimer::microsecToPoco(UniSetTimer::WaitUpTime);
+		REQUIRE( tm.seconds() == 0 );
+		REQUIRE( tm.microseconds() == 0 );
+	}
+	{
+		Poco::Timespan tm = UniSetTimer::microsecToPoco(2000000);
+		REQUIRE( tm.seconds() == 2 );
+		REQUIRE( tm.microseconds() == 0 );
+	}
+	{
+		Poco::Timespan tm = UniSetTimer::microsecToPoco(2000);
+		REQUIRE( tm.seconds() == 0 );
+		REQUIRE( tm.totalMicroseconds() == 2000 );
+		REQUIRE( tm.useconds() == 2000 );
+	}
+	{
+		Poco::Timespan tm = UniSetTimer::microsecToPoco(2);
+		REQUIRE( tm.seconds() == 0 );
+		REQUIRE( tm.microseconds() == 2 );
+	}
+}
+// -----------------------------------------------------------------------------
+