use timeout_t for time variable, use clock_t for save ticks

IDL/Services/TimerService_i.idl

@@ -54,7 +54,7 @@ interface TimerService_i: UniSetObject_i
 	*/
 	exception TimeMSLowLimit
 	{	
-		long lowLimitMS;
+		unsigned long lowLimitMS; // instead timeout_t
 	};
 
 
@@ -62,8 +62,8 @@ interface TimerService_i: UniSetObject_i
 	struct Timer
 	{
 		UniSetTypes::TimerId timerid;
-		long timeMS;
-		short ticks;
+		unsigned long timeMS;
+		long ticks; // instead clock_t
 		short msgPriority;
 	};
 

extensions/ModbusSlave/MBSlave.h

@@ -174,7 +174,7 @@ class MBSlave:
 		bool activated;
 		int activateTimeout;
 		bool pingOK;
-		int wait_msec;
+		timeout_t wait_msec;
 		bool force;		/*!<  ,     SM,      */
 
 		bool mbregFromID;

include/IONotifyController_LT.h

@@ -51,13 +51,13 @@ class IONotifyController_LT:
 			\return   []   
 			 
 		*/
-		void askTimer( UniSetTypes::TimerId timerid, long timeMS, short ticks=-1,
+		void askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, short ticks=-1,
 						UniSetTypes::Message::Priority p=UniSetTypes::Message::High );
 
 		/*!     */
 		virtual void callback();
 
-		int sleepTime;
+		timeout_t sleepTime;
 		LT_Object lt;
 	private:
 

include/LT_Object.h

@@ -110,7 +110,7 @@ class LT_Object
 			\return   []   
 			 
 		*/
-		int askTimer( UniSetTypes::TimerId timerid, long timeMS, short ticks=-1, 
+		timeout_t askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, clock_t ticks=-1, 
 						UniSetTypes::Message::Priority p=UniSetTypes::Message::High );
 
 
@@ -120,10 +120,10 @@ class LT_Object
 			\return   []   
 				 
 		*/
-		int checkTimers( UniSetObject* obj );
+		timeout_t checkTimers( UniSetObject* obj );
 
 		/*!     */
-		inline int getSleepTimeMS(){ return sleepTime; }
+		//inline timeout_t getSleepTimeMS(){ return sleepTime; }
 
 	protected:
 
@@ -131,7 +131,7 @@ class LT_Object
 		struct TimerInfo
 		{
 			TimerInfo():id(0), curTimeMS(0), priority(UniSetTypes::Message::High){};
-			TimerInfo(UniSetTypes::TimerId id, long timeMS, short cnt, UniSetTypes::Message::Priority p):
+			TimerInfo(UniSetTypes::TimerId id, timeout_t timeMS, short cnt, UniSetTypes::Message::Priority p):
 				id(id),
 				curTimeMS(timeMS),
 				priority(p),
@@ -147,14 +147,14 @@ class LT_Object
 			}
 			
 			UniSetTypes::TimerId id;	/*!<    */
-			int curTimeMS;				/*!<    */
+			timeout_t curTimeMS;				/*!<    */
 			UniSetTypes::Message::Priority priority; /*!<     */
 
 			/*!
 			 *  
 			 * \note    -1     
 			*/
-			short curTick; 
+			clock_t curTick; 
 			
 			//        
 			bool operator < ( const TimerInfo& ti ) const

include/ObjectsManager_LT.h

@@ -51,7 +51,7 @@ class ObjectsManager_LT:
 			\return   []   
 			 
 		*/
-		void askTimer( UniSetTypes::TimerId timerid, long timeMS, short ticks=-1,
+		void askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, short ticks=-1,
 						UniSetTypes::Message::Priority p=UniSetTypes::Message::High );
 
 		/*!     */

include/PassiveTimer.h

@@ -28,6 +28,7 @@
 //----------------------------------------------------------------------------
 #include <signal.h>
 #include <sys/time.h>
+#include <cc++/socket.h>
 //#include "Exceptions.h"
 
 
@@ -44,26 +45,34 @@ class UniSetTimer
 		virtual ~UniSetTimer(){};
 	
 		virtual bool checkTime()=0;				/*!<     */
-		virtual void setTiming( int timeMS )=0; /*!<     */
+		virtual timeout_t setTiming( timeout_t timeMS )=0; /*!<     */
 		virtual void reset()=0;					/*!<   */
 
-		virtual int getCurrent()=0; 		/*!<     */
-		virtual int getInterval()=0;		/*!<  ,    ,   */
+		virtual timeout_t getCurrent()=0; 		/*!<     */
+		virtual timeout_t getInterval()=0;		/*!<  ,    ,   */
+		timeout_t getLeft(timeout_t timeout)		/*<  ,    timeout    getCurrent() */
+		{
+			timeout_t ct = getCurrent();
+			if( timeout <= ct )
+				return 0;
+			return timeout - ct;
+		}
 		
 		//     ..
 		//      
 		// .
-		virtual int wait(int timeMS){ return 0;} 	/*!<     */
+		virtual bool wait(timeout_t timeMS){ return 0;} 	/*!<     */
 		virtual void terminate(){}					/*!<    */
 		virtual void stop(){ terminate(); };		/*!<    */
 
 		/*!  ,        
 		 *  terminate()  stop()
 		 */
-		static const int WaitUpTime = -1;
+		static const timeout_t WaitUpTime = TIMEOUT_INF;
 		
 		/*!   .   . */
-		static const int MIN_QUANTITY_TIME_MS = 30;
+		static const timeout_t MinQuantityTime = 30;
+		static const timeout_t MIN_QUANTITY_TIME_MS = 30; /*< ,  ! */
 };
 //----------------------------------------------------------------------------------------
 /*! \class PassiveTimer
@@ -82,15 +91,15 @@ class PassiveTimer:
 {
 public:
 	PassiveTimer();
-	PassiveTimer( int timeMS ); 			/*!<   */
+	PassiveTimer( timeout_t timeMS ); 			/*!<   */
 	
 
 	virtual bool checkTime();				/*!<     */
-	virtual void setTiming( int timeMS ); 	/*!<     */
+	virtual timeout_t setTiming( timeout_t timeMS ); 	/*!<     */
 	virtual void reset();					/*!<   */
 
-	virtual int getCurrent(); 				/*!<    ,   */
-	virtual int getInterval()				/*!<  ,    ,   */
+	virtual timeout_t getCurrent(); 				/*!<    ,   */
+	virtual timeout_t getInterval()				/*!<  ,    ,   */
 	{
 		return timeSS*10;
 	}
@@ -98,11 +107,12 @@ public:
 	virtual void terminate();				/*!<    */
 
 protected:
-	int timeAct;	/*!<   ,   */
-	int timeSS;		/*!<  ,   */
-	int timeStart;	/*!<    () */
+	clock_t timeAct;	/*!<   ,   */
+	timeout_t timeSS;		/*!<  ,   */
+	clock_t timeStart;	/*!<    () */
 private:
-	int clock_ticks; // CLK_TCK
+	clock_t clock_ticks; //    
+	clock_t times(); //     
 };
 
 //----------------------------------------------------------------------------------------
@@ -115,7 +125,7 @@ class omni_condition;
  * \date  $Date: 2007/08/02 22:52:27 $
  * \version $Id: PassiveTimer.h,v 1.9 2007/08/02 22:52:27 vpashka Exp $
  * \par
- *      wait(int timeMS).
+ *      wait(timeout_t timeMS).
  *        (mutex  condition). 
  * \note       (WaitUpTime),       
  *   terminate().
@@ -128,7 +138,7 @@ class ThrPassiveTimer:
 		ThrPassiveTimer();
 		~ThrPassiveTimer();
 
-		virtual int wait(int timeMS);	/*!<       */
+		virtual bool wait(timeout_t timeMS);	/*!<       */
 		virtual void terminate();		/*!<    */
 	protected:
 	private:
@@ -154,13 +164,13 @@ class PassiveSysTimer:
 		PassiveSysTimer();
 		~PassiveSysTimer();
 
-		virtual int wait(int timeMS); //throw(UniSetTypes::NotSetSignal);
-		virtual void terminate();		
+		virtual bool wait(timeout_t timeMS); //throw(UniSetTypes::NotSetSignal);
+		virtual void terminate();
 		
 	protected:
 
 	private:
-		struct itimerval mtimer;	
+		struct itimerval mtimer;
 		pid_t pid;	
 
 //		bool terminated;

include/TimerService.h

@@ -139,7 +139,7 @@ class TimerService:
 			UniSetTypes::ConsumerInfo cinf;		/*!<     */
 			UniSetObject_i_var ref;				/*!<    */
 			UniSetTypes::TimerId id;			/*!<    */
-			int curTimeMS;						/*!<    */
+			timeout_t curTimeMS;						/*!<    */
 			UniSetTypes::Message::Priority priority;	/*!<     */
 
 			/*!

include/UniSetObject.h

@@ -132,7 +132,7 @@ class UniSetObject:
 			inline void terminate(){ disactivate(); }
 
 			/*!   timeMS */
-			virtual bool waitMessage(UniSetTypes::VoidMessage& msg, int timeMS=UniSetTimer::WaitUpTime);		
+			virtual bool waitMessage(UniSetTypes::VoidMessage& msg, timeout_t timeMS=UniSetTimer::WaitUpTime);
 
 			void setID(UniSetTypes::ObjectId id);
 

include/UniSetObject_LT.h

@@ -51,13 +51,13 @@ class UniSetObject_LT:
 			\return   []   
 			 
 		*/
-		void askTimer( UniSetTypes::TimerId timerid, long timeMS, short ticks=-1,
+		void askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, short ticks=-1,
 						UniSetTypes::Message::Priority p=UniSetTypes::Message::High );
 
 		/*!     */
 		virtual void callback();
 
-		int sleepTime;
+		timeout_t sleepTime;
 		LT_Object lt;
 	private:
 };

include/modbus/ModbusClient.h

@@ -107,7 +107,7 @@ class ModbusClient
 			\param part_timeout_msec -      .
 		*/
 		ModbusRTU::FileTransferRetMessage partOfFileTransfer( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusData idFile, 
-																ModbusRTU::ModbusData numpack, int part_timeout_msec=2000 )
+																ModbusRTU::ModbusData numpack, timeout_t part_timeout_msec=2000 )
 																	throw(ModbusRTU::mbException);
 
 		/*!  
@@ -116,17 +116,17 @@ class ModbusClient
 			\param part_timeout_msec -      .
 		*/
 		void fileTransfer( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusData idFile, 
-							const char* save2filename, int part_timeout_msec=2000 )
+							const char* save2filename, timeout_t part_timeout_msec=2000 )
 														throw(ModbusRTU::mbException);
 
 		// ---------------------------------------------------------------------
 		/*!      */
-		void setTimeout( int msec );
+		void setTimeout( timeout_t msec );
 		
 		/*!     
 			\return  
 		*/
-		int setAfterSendPause( int msec );
+		int setAfterSendPause( timeout_t msec );
 
 		void initLog( UniSetTypes::Configuration* conf, const std::string name, const std::string logfile="" );
 		void setLog( DebugStream& dlog );
@@ -146,13 +146,13 @@ class ModbusClient
 		virtual int getNextData( unsigned char* buf, int len )=0;
 
 		/*! set timeout for send/receive data */
-		virtual void setChannelTimeout( int msec )=0;
+		virtual void setChannelTimeout( timeout_t msec )=0;
 
 		virtual ModbusRTU::mbErrCode sendData( unsigned char* buf, int len )=0;
 
 		/*!  - */
 		virtual ModbusRTU::mbErrCode query( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusMessage& msg, 
-											ModbusRTU::ModbusMessage& reply, int timeout )=0;
+											ModbusRTU::ModbusMessage& reply, timeout_t timeout )=0;
 
 		// -------------------------------------
 		/*!   */
@@ -160,18 +160,18 @@ class ModbusClient
 
 		/*!   */
 		virtual ModbusRTU::mbErrCode recv( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusByte qfunc, 
-									ModbusRTU::ModbusMessage& rbuf, int timeout );
+									ModbusRTU::ModbusMessage& rbuf, timeout_t timeout );
 
 		virtual ModbusRTU::mbErrCode recv_pdu( ModbusRTU::ModbusByte qfunc, 
-									ModbusRTU::ModbusMessage& rbuf, int timeout );
+									ModbusRTU::ModbusMessage& rbuf, timeout_t timeout );
 
 
 
 		ModbusRTU::ModbusMessage reply;	/*!<   ɣ  */
 		ModbusRTU::ModbusMessage qbuf; 	/*!<     */
 
-		int replyTimeOut_ms;	/*!<     */
-		int aftersend_msec;		/*!<     */
+		timeout_t replyTimeOut_ms;	/*!<     */
+		timeout_t aftersend_msec;		/*!<     */
 		
 		bool crcNoCheckit;
 

include/modbus/ModbusRTUMaster.h

@@ -43,13 +43,13 @@ class ModbusRTUMaster:
 		virtual int getNextData( unsigned char* buf, int len );
 
 		/*! set timeout for send/receive data */
-		virtual void setChannelTimeout( int msec );
+		virtual void setChannelTimeout( timeout_t msec );
 
 		virtual ModbusRTU::mbErrCode sendData( unsigned char* buf, int len );
 
 		/*!  - */
 		virtual ModbusRTU::mbErrCode query( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusMessage& msg, 
-											ModbusRTU::ModbusMessage& reply, int timeout );
+											ModbusRTU::ModbusMessage& reply, timeout_t timeout );
 
 
 		std::string dev; 		/*!<  */

include/modbus/ModbusRTUSlave.h

@@ -32,13 +32,13 @@ class ModbusRTUSlave:
 		void setSpeed( const std::string s );
 		ComPort::Speed getSpeed();
 
-		virtual ModbusRTU::mbErrCode receive( ModbusRTU::ModbusAddr addr, int msecTimeout );
+		virtual ModbusRTU::mbErrCode receive( ModbusRTU::ModbusAddr addr, timeout_t msecTimeout );
 		
 	protected:
 
 		// realisation (see ModbusServer.h)
 		virtual int getNextData( unsigned char* buf, int len );
-		virtual void setChannelTimeout( int msec );
+		virtual void setChannelTimeout( timeout_t msec );
 		virtual ModbusRTU::mbErrCode sendData( unsigned char* buf, int len );
 
 		std::string dev;	/*!<  */

include/modbus/ModbusServer.h

@@ -27,21 +27,21 @@ class ModbusServer
 			\param msecTimeout 	-       .
 			\return     ModbusRTU::mbErrCode
 		*/
-		virtual ModbusRTU::mbErrCode receive( ModbusRTU::ModbusAddr addr, int msecTimeout )=0;
+		virtual ModbusRTU::mbErrCode receive( ModbusRTU::ModbusAddr addr, timeout_t msecTimeout )=0;
 
 
 		/*!     
 			\return  
 		*/
-		int setAfterSendPause( int msec );
+		timeout_t setAfterSendPause( timeout_t msec );
 
 		/*!     
 			\return  
 		*/
-		int setReplyTimeout( int msec );
+		timeout_t setReplyTimeout( timeout_t msec );
 
 		/*!      */
-		void setRecvTimeout( int msec );
+		void setRecvTimeout( timeout_t msec );
 
 		inline void setCRCNoCheckit( bool set ){ crcNoCheckit = set; }
 		inline bool isCRCNoCheckit(){ return crcNoCheckit; }
@@ -182,7 +182,7 @@ class ModbusServer
 		
 
 		/*! set timeout for receive data */
-		virtual void setChannelTimeout( int msec )=0;
+		virtual void setChannelTimeout( timeout_t msec )=0;
 
 		/*!  ()   */
 		virtual ModbusRTU::mbErrCode send( ModbusRTU::ModbusMessage& buf );
@@ -194,13 +194,13 @@ class ModbusServer
 		virtual ModbusRTU::mbErrCode processing( ModbusRTU::ModbusMessage& buf );
 
 		/*!     */
-		ModbusRTU::mbErrCode recv( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusMessage& buf, int timeout );
-		ModbusRTU::mbErrCode recv_pdu( ModbusRTU::ModbusMessage& rbuf, int timeout );
+		ModbusRTU::mbErrCode recv( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusMessage& buf, timeout_t timeout );
+		ModbusRTU::mbErrCode recv_pdu( ModbusRTU::ModbusMessage& rbuf, timeout_t timeout );
 
 		UniSetTypes::uniset_mutex recvMutex;
-		int recvTimeOut_ms;		/*!<   ɣ */
-		int replyTimeout_ms;	/*!<     */
-		int aftersend_msec;		/*!<     */
+		timeout_t recvTimeOut_ms;		/*!<   ɣ */
+		timeout_t replyTimeout_ms;	/*!<     */
+		timeout_t aftersend_msec;		/*!<     */
 		bool onBroadcast;		/*!<     broadcst- */
 		bool crcNoCheckit;
 

include/modbus/ModbusTCPMaster.h

@@ -28,10 +28,10 @@ class ModbusTCPMaster:
 		void reconnect();
 
 		virtual int getNextData( unsigned char* buf, int len );
-		virtual void setChannelTimeout( int msec );
+		virtual void setChannelTimeout( timeout_t msec );
 		virtual ModbusRTU::mbErrCode sendData( unsigned char* buf, int len );
 		virtual ModbusRTU::mbErrCode query( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusMessage& msg, 
-											ModbusRTU::ModbusMessage& reply, int timeout );
+											ModbusRTU::ModbusMessage& reply, timeout_t timeout );
 
 	private:
 		ost::TCPStream* tcp;

include/modbus/ModbusTCPServer.h

@@ -23,7 +23,7 @@ class ModbusTCPServer:
 		ModbusTCPServer( ost::InetAddress &ia, int port=502 );
 		virtual ~ModbusTCPServer();
 		
-		virtual ModbusRTU::mbErrCode receive( ModbusRTU::ModbusAddr addr, int msecTimeout );
+		virtual ModbusRTU::mbErrCode receive( ModbusRTU::ModbusAddr addr, timeout_t msecTimeout );
 		
 	protected:
 
@@ -32,7 +32,7 @@ class ModbusTCPServer:
 
 		// realisation (see ModbusServer.h)
 		virtual int getNextData( unsigned char* buf, int len );
-		virtual void setChannelTimeout( int msec );
+		virtual void setChannelTimeout( timeout_t msec );
 		virtual ModbusRTU::mbErrCode sendData( unsigned char* buf, int len );
 
 		virtual ModbusRTU::mbErrCode tcp_processing( ost::TCPStream& tcp, ModbusTCP::MBAPHeader& mhead );

src/Communications/Modbus/ModbusClient.cc

@@ -25,15 +25,15 @@ ModbusClient::~ModbusClient()
 {
 }
 // -------------------------------------------------------------------------
-void ModbusClient::setTimeout( int msec )
+void ModbusClient::setTimeout( timeout_t msec )
 {
-	if( msec != UniSetTimer::WaitUpTime && msec>=0 )
+	if( msec != UniSetTimer::WaitUpTime )
 		replyTimeOut_ms = msec;
 }
 // -------------------------------------------------------------------------
-int ModbusClient::setAfterSendPause( int msec )
+int ModbusClient::setAfterSendPause( timeout_t msec )
 {
-	int old = aftersend_msec;
+	timeout_t old = aftersend_msec;
 	aftersend_msec = msec;
 	return old;
 }
@@ -172,7 +172,7 @@ SetDateTimeRetMessage ModbusClient::setDateTime( ModbusAddr addr, ModbusByte hou
 }						
 // --------------------------------------------------------------------------------
 void ModbusClient::fileTransfer( ModbusAddr addr, ModbusData numfile, 
-									const char* save2filename, int part_timeout_msec )
+									const char* save2filename, timeout_t part_timeout_msec )
 												throw(ModbusRTU::mbException)
 {
 //#warning  
@@ -256,9 +256,9 @@ void ModbusClient::fileTransfer( ModbusAddr addr, ModbusData numfile,
 	throw mbException(res);
 }						
 // --------------------------------------------------------------------------------
-FileTransferRetMessage ModbusClient::partOfFileTransfer( ModbusAddr addr, 
+FileTransferRetMessage ModbusClient::partOfFileTransfer( ModbusAddr addr,
 										ModbusData idFile, ModbusData numpack,
-										int part_timeout_msec )
+										timeout_t part_timeout_msec )
 											throw(ModbusRTU::mbException)
 {
 	FileTransferMessage msg(addr,idFile,numpack);
@@ -272,7 +272,7 @@ FileTransferRetMessage ModbusClient::partOfFileTransfer( ModbusAddr addr,
 }									
 // --------------------------------------------------------------------------------
 mbErrCode ModbusClient::recv( ModbusAddr addr, ModbusByte qfunc, 
-								ModbusMessage& rbuf, int timeout )
+								ModbusMessage& rbuf, timeout_t timeout )
 {
 	if( timeout == UniSetTimer::WaitUpTime )
 		timeout = 15*60*1000*1000; //     (15 ).    .
@@ -329,7 +329,7 @@ mbErrCode ModbusClient::recv( ModbusAddr addr, ModbusByte qfunc,
 }
 
 // --------------------------------------------------------------------------------
-mbErrCode ModbusClient::recv_pdu( ModbusByte qfunc, ModbusMessage& rbuf, int timeout )
+mbErrCode ModbusClient::recv_pdu( ModbusByte qfunc, ModbusMessage& rbuf, timeout_t timeout )
 {
 	int bcnt=1; // receive bytes count (1 - addr)
 	try

src/Communications/Modbus/ModbusRTUMaster.cc

@@ -98,7 +98,7 @@ int ModbusRTUMaster::getNextData( unsigned char* buf, int len )
 	return port->receiveBlock(buf, len);
 }
 // --------------------------------------------------------------------------------
-void ModbusRTUMaster::setChannelTimeout( int msec )
+void ModbusRTUMaster::setChannelTimeout( timeout_t msec )
 {
 	if( port )
 		port->setTimeout(msec*1000);
@@ -120,7 +120,7 @@ mbErrCode ModbusRTUMaster::sendData( unsigned char* buf, int len )
 }
 // -------------------------------------------------------------------------
 mbErrCode ModbusRTUMaster::query( ModbusAddr addr, ModbusMessage& msg, 
-									ModbusMessage& reply, int timeout )
+									ModbusMessage& reply, timeout_t timeout )
 {
 	mbErrCode res = send(msg);
 	if( res!=erNoError )

src/Communications/Modbus/ModbusRTUSlave.cc

@@ -62,7 +62,7 @@ ModbusRTUSlave::~ModbusRTUSlave()
 		delete port;
 }
 // -------------------------------------------------------------------------
-mbErrCode ModbusRTUSlave::receive( ModbusRTU::ModbusAddr addr, int timeout )
+mbErrCode ModbusRTUSlave::receive( ModbusRTU::ModbusAddr addr, timeout_t timeout )
 {
 	uniset_mutex_lock lck(recvMutex,timeout);
 	ModbusMessage buf;
@@ -127,7 +127,7 @@ int ModbusRTUSlave::getNextData( unsigned char* buf, int len )
 	return port->receiveBlock(buf, len);
 }
 // --------------------------------------------------------------------------------
-void ModbusRTUSlave::setChannelTimeout( int msec )
+void ModbusRTUSlave::setChannelTimeout( timeout_t msec )
 {
 	if( msec == UniSetTimer::WaitUpTime )
 		port->setTimeout(15*60*1000*1000); //     (15 ).    .

src/Communications/Modbus/ModbusServer.cc

@@ -28,26 +28,28 @@ ModbusServer::~ModbusServer()
 {
 }
 // -------------------------------------------------------------------------
-void ModbusServer::setRecvTimeout( int msec )
+void ModbusServer::setRecvTimeout( timeout_t msec )
 {
-	if( msec != UniSetTimer::WaitUpTime && msec>=0 )
+	if( msec != UniSetTimer::WaitUpTime )
 		recvTimeOut_ms = msec;
 }
 // -------------------------------------------------------------------------
-int ModbusServer::setReplyTimeout( int msec )
+timeout_t ModbusServer::setReplyTimeout( timeout_t msec )
 {
-	if( msec <= 0 )
+	// #warning "Why msec can be 0?"
+	assert(msec);
+	if( msec == UniSetTimer::WaitUpTime )
 		return replyTimeout_ms;
 
-	int old = replyTimeout_ms;
+	timeout_t old = replyTimeout_ms; //   ,    
 	replyTimeout_ms = msec;
 	tmProcessing.setTiming(replyTimeout_ms);
 	return old;
 }
 // -------------------------------------------------------------------------
-int ModbusServer::setAfterSendPause( int msec )
+timeout_t ModbusServer::setAfterSendPause( timeout_t msec )
 {
-	int old = aftersend_msec;
+	timeout_t old = aftersend_msec;
 	aftersend_msec = msec;
 	return old;
 }
@@ -448,10 +450,11 @@ mbErrCode ModbusServer::processing( ModbusMessage& buf )
 }
 
 // -------------------------------------------------------------------------
-mbErrCode ModbusServer::recv( ModbusRTU::ModbusAddr addr, ModbusMessage& rbuf, int timeout )
+mbErrCode ModbusServer::recv( ModbusRTU::ModbusAddr addr, ModbusMessage& rbuf, timeout_t timeout )
 {
-	if( timeout == UniSetTimer::WaitUpTime || timeout<=0 ) 
-		timeout = 15*60*1000; //     (15 ).    .
+	assert(timeout);
+	if( timeout == UniSetTimer::WaitUpTime )
+		timeout = 15*60*1000; //     (15 ),    .
 
 	setChannelTimeout(timeout);
 	PassiveTimer tmAbort(timeout);
@@ -505,7 +508,7 @@ mbErrCode ModbusServer::recv( ModbusRTU::ModbusAddr addr, ModbusMessage& rbuf, i
 }
 
 // -------------------------------------------------------------------------
-mbErrCode ModbusServer::recv_pdu( ModbusMessage& rbuf, int timeout )
+mbErrCode ModbusServer::recv_pdu( ModbusMessage& rbuf, timeout_t timeout )
 {
 	int bcnt = 1; // 1 - addr
 	try

src/Communications/Modbus/ModbusTCPMaster.cc

@@ -31,7 +31,7 @@ int ModbusTCPMaster::getNextData( unsigned char* buf, int len )
 	return ModbusTCPCore::getNextData(buf,len,qrecv,tcp);
 }
 // -------------------------------------------------------------------------
-void ModbusTCPMaster::setChannelTimeout( int msec )
+void ModbusTCPMaster::setChannelTimeout( timeout_t msec )
 {
 	if( tcp )
 		tcp->setTimeout(msec);
@@ -45,7 +45,7 @@ mbErrCode ModbusTCPMaster::sendData( unsigned char* buf, int len )
 int ModbusTCPMaster::nTransaction = 0;
 
 mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg, 
-				 			ModbusMessage& reply, int timeout )
+				 			ModbusMessage& reply, timeout_t timeout )
 {
 
 //	if( !isConnection() )
@@ -58,13 +58,8 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 
 	reconnect();
 
-	if( timeout<=0 || timeout == UniSetTimer::WaitUpTime )
-	{
-		timeout = TIMEOUT_INF;
-		ptTimeout.setTiming(UniSetTimer::WaitUpTime);
-	}
-	else
-		ptTimeout.setTiming(timeout);
+	assert(timeout);
+	ptTimeout.setTiming(timeout);
 	
 	ost::Thread::setException(ost::Thread::throwException);
 	
@@ -100,10 +95,10 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 		if( !tcp->isPending(ost::Socket::pendingOutput,timeout) )
 			return erTimeOut;
 
-		if( timeout != TIMEOUT_INF )
+		if( timeout != UniSetTimer::WaitUpTime )
 		{
-			timeout -= ptTimeout.getCurrent();
-			if( timeout <=0 )
+			timeout = ptTimeout.getLeft(timeout);
+			if( timeout == 0 )
 				return erTimeOut;
 
 			ptTimeout.setTiming(timeout);

src/Communications/Modbus/ModbusTCPServer.cc

@@ -22,27 +22,27 @@ ModbusTCPServer::~ModbusTCPServer()
 {
 }
 // -------------------------------------------------------------------------
-mbErrCode ModbusTCPServer::receive( ModbusRTU::ModbusAddr addr, int timeout )
+mbErrCode ModbusTCPServer::receive( ModbusRTU::ModbusAddr addr, timeout_t timeout )
 {
 	PassiveTimer ptTimeout(timeout);
 	ModbusMessage buf;
 	mbErrCode res = erTimeOut;
 	
 //	Thread::setException(Thread::throwException);
-	if( timeout<=0 || timeout == UniSetTimer::WaitUpTime )
-		timeout = TIMEOUT_INF;
+//#warning "Why timeout can be 0 there?"
+	assert(timeout);
 	
 	ptTimeout.reset();
 	try 
 	{
-		if( isPendingConnection(timeout) ) 
+		if( isPendingConnection(timeout) )
 		{
 			tcp.connect(*this);
 
-			if( timeout != TIMEOUT_INF )
+			if( timeout != UniSetTimer::WaitUpTime )
 			{
-				timeout -= ptTimeout.getCurrent();
-				if( timeout <=0 )
+				timeout = ptTimeout.getLeft(timeout);
+				if( timeout == 0 )
 				{
 					tcp.disconnect();
 					return erTimeOut;
@@ -61,22 +61,21 @@ mbErrCode ModbusTCPServer::receive( ModbusRTU::ModbusAddr addr, int timeout )
 					return res;
 				}
 
-				if( timeout != TIMEOUT_INF )
+				if( timeout != UniSetTimer::WaitUpTime )
 				{
-					timeout -= ptTimeout.getCurrent();
-					if( timeout <=0 )
+					timeout = ptTimeout.getLeft(timeout);
+					if( timeout == 0 )
 					{
 						tcp.disconnect();
 						return erTimeOut;
 					}
 				}
 
-				int msec = (timeout != TIMEOUT_INF) ? timeout : UniSetTimer::WaitUpTime;
 				do
 				{
 					// buf.addr = curQueryHeader.uID;
 					// res = recv_pdu(buf,mec);
-					res = recv( addr, buf, msec );
+					res = recv( addr, buf, timeout );
 
 					if( res!=erNoError && res!=erBadReplyNodeAddress )
 					{
@@ -92,10 +91,10 @@ mbErrCode ModbusTCPServer::receive( ModbusRTU::ModbusAddr addr, int timeout )
 						return res;
 					}
 					
-					if( timeout != TIMEOUT_INF )
+					if( timeout != UniSetTimer::WaitUpTime )
 					{
-						timeout -= ptTimeout.getCurrent();
-						if( timeout <=0 )
+						timeout = ptTimeout.getLeft(timeout);
+						if( timeout == 0 )
 						{
 							tcp.disconnect();
 							return erTimeOut;
@@ -125,7 +124,7 @@ mbErrCode ModbusTCPServer::receive( ModbusRTU::ModbusAddr addr, int timeout )
 }
 
 // --------------------------------------------------------------------------------
-void ModbusTCPServer::setChannelTimeout( int msec )
+void ModbusTCPServer::setChannelTimeout( timeout_t msec )
 {
 	tcp.setTimeout(msec);
 }

src/ObjectRepository/ObjectsManager_LT.cc

@@ -67,7 +67,7 @@ void ObjectsManager_LT::callback()
 	}
 }
 // ------------------------------------------------------------------------------------------
-void ObjectsManager_LT::askTimer( UniSetTypes::TimerId timerid, long timeMS, short ticks, UniSetTypes::Message::Priority p )
+void ObjectsManager_LT::askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, short ticks, UniSetTypes::Message::Priority p )
 {
 	//   
 	if( lt.askTimer(timerid, timeMS, ticks, p) != UniSetTimer::WaitUpTime )

src/ObjectRepository/UniSetObject_LT.cc

@@ -67,7 +67,7 @@ void UniSetObject_LT::callback()
 	}
 }
 // ------------------------------------------------------------------------------------------
-void UniSetObject_LT::askTimer( UniSetTypes::TimerId timerid, long timeMS, short ticks, UniSetTypes::Message::Priority p )
+void UniSetObject_LT::askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, short ticks, UniSetTypes::Message::Priority p )
 {
 	//   
 	if( lt.askTimer(timerid, timeMS, ticks, p) != UniSetTimer::WaitUpTime )

src/Processes/IONotifyController_LT.cc

@@ -68,7 +68,7 @@ void IONotifyController_LT::callback()
 	}
 }
 // ------------------------------------------------------------------------------------------
-void IONotifyController_LT::askTimer( UniSetTypes::TimerId timerid, long timeMS, short ticks, UniSetTypes::Message::Priority p )
+void IONotifyController_LT::askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, short ticks, UniSetTypes::Message::Priority p )
 {
 	//   
 	if( lt.askTimer(timerid, timeMS, ticks,p) != UniSetTimer::WaitUpTime )

src/Services/TimerService.cc

@@ -191,11 +191,10 @@ void TimerService::work()
 	bool resort = false;
 	terminate = false;
 //	TimerInfo* ti;
-	int sleepTime(UniSetTimer::MIN_QUANTITY_TIME_MS);	// 
 
 	while(!terminate)
 	{
-		sleepTime = UniSetTimer::MIN_QUANTITY_TIME_MS; // 
+		timeout_t sleepTime = UniSetTimer::MinQuantityTime; // 
 		{	// lock
 			uniset_mutex_lock lock(lstMutex, 5000);
 			resort = false;
@@ -251,9 +250,10 @@ void TimerService::work()
 				}
 				else
 				{
-					li->curTimeMS -= sleepTime; 
-					if( li->curTimeMS < 0)
+					if( li->curTimeMS < sleepTime)
 						li->curTimeMS = 0;
+					else
+						li->curTimeMS -= sleepTime; 
 
 				}
 				
@@ -270,8 +270,8 @@ void TimerService::work()
 			if( resort )	//      
 				tlst.sort();
 			
-			if( sleepTime < UniSetTimer::MIN_QUANTITY_TIME_MS )
-				sleepTime=UniSetTimer::MIN_QUANTITY_TIME_MS;
+			if( sleepTime < UniSetTimer::MinQuantityTime )
+				sleepTime=UniSetTimer::MinQuantityTime;
 
 		} // unlock
 

src/Timers/PassiveSysTimer.cc

@@ -89,7 +89,7 @@ void PassiveSysTimer::terminate()
 	}
 }
 // ------------------------------------------------------------------------------------------
-int PassiveSysTimer::wait(int timeMS)
+bool PassiveSysTimer::wait(timeout_t timeMS)
 {
 	pid = getpid();
 

src/Timers/PassiveTimer.cc

@@ -49,7 +49,7 @@ clock_ticks(sysconf(_SC_CLK_TCK))
 
 //------------------------------------------------------------------------------
 
-PassiveTimer::PassiveTimer( int timeMS ):
+PassiveTimer::PassiveTimer( timeout_t timeMS ):
 timeAct(0),
 timeSS(0),
 timeStart(0),

src/Timers/ThrPassiveTimer.cc

@@ -63,33 +63,30 @@ void ThrPassiveTimer::terminate()
 	}
 }
 // ------------------------------------------------------------------------------------------
-int ThrPassiveTimer::wait(int timeMS)
+bool ThrPassiveTimer::wait(timeout_t timeMS)
 {
 	terminated = 0;
 	{
 		tmutex->lock();
-		PassiveTimer::setTiming(timeMS); //      PassiveTimer-
-		if( timeMS < 0 || timeMS == WaitUpTime )
+		timeMS = PassiveTimer::setTiming(timeMS); //      PassiveTimer-
+		if( timeMS == WaitUpTime )
 		{
 			while( !terminated )	//  ,    ...
 				tcondx->wait();
 		}
 		else
 		{
-			if( timeMS < MIN_QUANTITY_TIME_MS )
-				timeMS = MIN_QUANTITY_TIME_MS;
-				
 			unsigned long sec, msec;
 			omni_thread::get_time(&sec,&msec, timeMS/1000, (timeMS%1000)*1000000 );
 //			cout <<"timer:  "<< timeMS/1000 << "[]  " << (timeMS%1000)*1000000 <<"[]" << endl;
-			tcondx->timedwait(sec, msec);		
+			tcondx->timedwait(sec, msec);
 		}
 
 		tmutex->unlock();
 	}
 
 	terminated = 1;
-	return 1;	
+	return true;
 }
 // ------------------------------------------------------------------------------------------
 

src/Timers/WaitingPassiveTimer.cc

@@ -84,7 +84,7 @@ WaitingPassiveTimer::~WaitingPassiveTimer()
 // ------------------------------------------------------------------------------------------
 void WaitingPassiveTimer::work()
 {
-	int sleepMKS = (int)(MIN_QUANTITY_TIME_MS/1000);
+	timeout_t sleepMKS = MIN_QUANTITY_TIME_MS*1000;
 	terminated = false;
 	while( !terminated )
 	{
@@ -119,7 +119,7 @@ void WaitingPassiveTimer::terminate()
 	usleep(1000);
 }
 // ------------------------------------------------------------------------------------------
-void WaitingPassiveTimer::wait(int timeMS)
+void WaitingPassiveTimer::wait(timeout_t timeMS)
 {
 	if ( !terminated )
 		terminate();

src/Various/LT_Object.cc

@@ -37,9 +37,7 @@ using namespace UniSetTypes;
 LT_Object::LT_Object():
 sleepTime(UniSetTimer::WaitUpTime)
 {
-	tmLast.setTiming(100000);
 	tmLast.setTiming(UniSetTimer::WaitUpTime);
-	
 }
 
 // ------------------------------------------------------------------------------------------
@@ -47,7 +45,7 @@ LT_Object::~LT_Object()
 {
 }
 // ------------------------------------------------------------------------------------------
-int LT_Object::checkTimers( UniSetObject* obj )
+timeout_t LT_Object::checkTimers( UniSetObject* obj )
 {
 	try
 	{
@@ -62,13 +60,13 @@ int LT_Object::checkTimers( UniSetObject* obj )
 		}
 
 		//     
-		if( tmLast.getCurrent() < UniSetTimer::MIN_QUANTITY_TIME_MS )
+		if( tmLast.getCurrent() < UniSetTimer::MinQuantityTime )
 		{
 			//   sleepTime
-			sleepTime -= tmLast.getCurrent();
-			if( sleepTime < UniSetTimer::MIN_QUANTITY_TIME_MS )
+			sleepTime = tmLast.getLeft(sleepTime);
+			if( sleepTime < UniSetTimer::MinQuantityTime )
 			{
-				sleepTime=UniSetTimer::MIN_QUANTITY_TIME_MS;
+				sleepTime=UniSetTimer::MinQuantityTime;
 				return sleepTime;
 			}
 		}
@@ -101,10 +99,8 @@ int LT_Object::checkTimers( UniSetObject* obj )
 				}
 				else
 				{
-					li->curTimeMS -= tmLast.getCurrent(); 
-					if( li->curTimeMS < 0 )
-						li->curTimeMS = 0;
-				}			
+					li->curTimeMS = tmLast.getLeft(li->curTimeMS);
+				}
 
 				//    
 				if( li->curTimeMS < sleepTime || sleepTime == UniSetTimer::WaitUpTime )
@@ -114,8 +110,8 @@ int LT_Object::checkTimers( UniSetObject* obj )
 			if( resort )	//      
 				tlst.sort();
 			
-			if( sleepTime < UniSetTimer::MIN_QUANTITY_TIME_MS )
-				sleepTime=UniSetTimer::MIN_QUANTITY_TIME_MS;
+			if( sleepTime < UniSetTimer::MinQuantityTime )
+				sleepTime=UniSetTimer::MinQuantityTime;
 		} // unlock		
 
 		tmLast.reset();
@@ -129,15 +125,15 @@ int LT_Object::checkTimers( UniSetObject* obj )
 }
 // ------------------------------------------------------------------------------------------
 
-int LT_Object::askTimer( UniSetTypes::TimerId timerid, long timeMS, short ticks, UniSetTypes::Message::Priority p )
+timeout_t LT_Object::askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, clock_t ticks, UniSetTypes::Message::Priority p )
 {
-	if( timeMS>0 ) // 
+	if( timeMS > 0 ) // 
 	{
-		if( timeMS < UniSetTimer::MIN_QUANTITY_TIME_MS )
+		if( timeMS < UniSetTimer::MinQuantityTime )
 		{
 			unideb[Debug::CRIT] << "(LT_askTimer): []       "
-						<< "  ۣ " << UniSetTimer::MIN_QUANTITY_TIME_MS << endl;
-			timeMS = UniSetTimer::MIN_QUANTITY_TIME_MS;
+						<< "  ۣ " << UniSetTimer::MinQuantityTime << endl;
+			timeMS = UniSetTimer::MinQuantityTime;
 		}
 			
 		{	// lock
@@ -170,7 +166,7 @@ int LT_Object::askTimer( UniSetTypes::TimerId timerid, long timeMS, short ticks,
 		if( unideb.debugging(Debug::INFO) )
 			unideb[Debug::INFO] << "(LT_askTimer):    (id="<< timerid << ") " << timeMS << " []\n";
 	}
-	else // 
+	else //  ( timeMS == 0)
 	{
 		if( unideb.debugging(Debug::INFO) )
 			unideb[Debug::INFO] << "(LT_askTimer):     id="<< timerid << endl;	
@@ -193,7 +189,7 @@ int LT_Object::askTimer( UniSetTypes::TimerId timerid, long timeMS, short ticks,
 		if( tlst.empty() )
 			sleepTime = UniSetTimer::WaitUpTime;
 		else
-			sleepTime = UniSetTimer::MIN_QUANTITY_TIME_MS;
+			sleepTime = UniSetTimer::MinQuantityTime;
 	}
 
 	return sleepTime;