Исправления ошибок по результатам компиляции с -Werror

configure.ac

@@ -275,7 +275,7 @@ AM_CONDITIONAL(HAVE_COVERAGE, test ${buildgcov} = true)
 AM_CONDITIONAL(HAVE_TESTS, test ${buildtests} = true)
 
 # -Weffc++
-CXX_EXTRA_FLAGS="-Wnon-virtual-dtor -Wctor-dtor-privacy -Woverloaded-virtual"
+CXX_EXTRA_FLAGS="-Wnon-virtual-dtor -Wctor-dtor-privacy -Woverloaded-virtual -Werror"
 
 # export
 LDFLAGS="$LDFLAGS ${OMNI_LIBS} ${XML_LIBS} ${SIGC_LIBS} ${COV_LIBS} ${COMCPP_LIBS}"

extensions/DBServer-PostgreSQL/PostgreSQLInterface.cc

@@ -207,7 +207,7 @@ PostgreSQLResult::PostgreSQLResult( const pqxx::result& res )
 	{
 		COL col;
 
-		for( int i = 0; i < c.size(); i++ )
+		for( size_t i = 0; i < c.size(); i++ )
 			col.push_back( c[i].as<string>() );
 
 		row.push_back(col);

extensions/DBServer-SQLite/main.cc

@@ -6,11 +6,6 @@
 using namespace UniSetTypes;
 using namespace std;
 // --------------------------------------------------------------------------
-static void short_usage()
-{
-	cout << "Usage: uniset-mysql-dbserver [--name ObjectId] [--confile configure.xml]\n";
-}
-// --------------------------------------------------------------------------
 int main(int argc, char** argv)
 {
 	//	std::ios::sync_with_stdio(false);

extensions/LogicProcessor/Element.h

@@ -124,7 +124,7 @@ class TOR:
 {
 
 	public:
-		TOR( ElementID id, int numbers = 0, bool st = false );
+		TOR( ElementID id, unsigned int numbers = 0, bool st = false );
 		virtual ~TOR();
 
 		virtual void setIn( int num, bool state ) override;

extensions/LogicProcessor/TDelay.cc

@@ -5,7 +5,7 @@
 using namespace std;
 using namespace UniSetExtensions;
 // -------------------------------------------------------------------------
-TDelay::TDelay( Element::ElementID id, int delayMS, int inCount):
+TDelay::TDelay( Element::ElementID id, timeout_t delayMS, unsigned int inCount):
 	Element(id),
 	myout(false),
 	delay(delayMS)
@@ -78,7 +78,7 @@ bool TDelay::getOut()
 	return myout;
 }
 // -------------------------------------------------------------------------
-void TDelay::setDelay( int timeMS )
+void TDelay::setDelay( timeout_t timeMS )
 {
 	delay = timeMS;
 }

extensions/LogicProcessor/TDelay.h

@@ -11,7 +11,7 @@ class TDelay:
 {
 
 	public:
-		TDelay( Element::ElementID id, int delayMS = 0, int inCount = 0 );
+		TDelay( Element::ElementID id, timeout_t delayMS = 0, unsigned int inCount = 0 );
 		virtual ~TDelay();
 
 
@@ -23,8 +23,8 @@ class TDelay:
 			return "Delay";
 		}
 
-		void setDelay( int timeMS );
-		inline int getDelay()
+		void setDelay( timeout_t timeMS );
+		inline timeout_t getDelay()
 		{
 			return delay;
 		}
@@ -34,7 +34,7 @@ class TDelay:
 
 		bool myout;
 		PassiveTimer pt;
-		int delay;
+		timeout_t delay;
 
 	private:
 };

extensions/LogicProcessor/TOR.cc

@@ -6,7 +6,7 @@
 using namespace std;
 using namespace UniSetExtensions;
 // -------------------------------------------------------------------------
-TOR::TOR(ElementID id, int num, bool st):
+TOR::TOR(ElementID id, unsigned int num, bool st):
 	Element(id),
 	myout(false)
 {

extensions/LogicProcessor/tests/lproc.cc

@@ -139,12 +139,6 @@ TEST_CASE("Logic processor: elements", "[LogicProcessor][elements]")
 		e.setDelay(0);
 		e.setIn(1, true);
 		CHECK( e.getOut() );
-
-		// delay < 0 === 0
-		e.setIn(1, false);
-		e.setDelay(-10);
-		e.setIn(1, true);
-		CHECK( e.getOut() );
 	}
 }
 // -----------------------------------------------------------------------------

extensions/ModbusMaster/MBExchange.cc

@@ -1052,8 +1052,8 @@ bool MBExchange::pollRTU( std::shared_ptr<RTUDevice>& dev, RegMap::iterator& it
 				return true;
 			}
 
-			//            cerr << "**** mbreg=" << ModbusRTU::dat2str(p->mbreg) << " val=" << ModbusRTU::dat2str(p->mbval) << endl;
-			ModbusRTU::WriteSingleOutputRetMessage ret = mb->write06(dev->mbaddr, p->mbreg, p->mbval);
+			// игнорируем return т.к. в случае ошибки будет исключение..
+			(void)mb->write06(dev->mbaddr, p->mbreg, p->mbval);
 		}
 		break;
 
@@ -1081,7 +1081,9 @@ bool MBExchange::pollRTU( std::shared_ptr<RTUDevice>& dev, RegMap::iterator& it
 				msg.addData(it->second->mbval);
 
 			it--;
-			ModbusRTU::WriteOutputRetMessage ret = mb->write10(msg);
+
+			// игнорируем return т.к. в случае ошибки будет исключение..
+			(void)mb->write10(msg);
 		}
 		break;
 
@@ -1101,7 +1103,8 @@ bool MBExchange::pollRTU( std::shared_ptr<RTUDevice>& dev, RegMap::iterator& it
 				return true;
 			}
 
-			ModbusRTU::ForceSingleCoilRetMessage ret = mb->write05(dev->mbaddr, p->mbreg, p->mbval);
+			// игнорируем return т.к. в случае ошибки будет исключение..
+			(void)mb->write05(dev->mbaddr, p->mbreg, p->mbval);
 		}
 		break;
 
@@ -1120,7 +1123,8 @@ bool MBExchange::pollRTU( std::shared_ptr<RTUDevice>& dev, RegMap::iterator& it
 				msg.addBit( (it->second->mbval ? true : false) );
 
 			it--;
-			ModbusRTU::ForceCoilsRetMessage ret = mb->write0F(msg);
+			// игнорируем return т.к. в случае ошибки будет исключение..
+			(void)mb->write0F(msg);
 		}
 		break;
 

extensions/ModbusMaster/tests/test_mbtcpmaster.cc

@@ -83,20 +83,6 @@ static void InitTest()
 	}
 }
 // -----------------------------------------------------------------------------
-static bool init_iobase( IOBase* ib, const std::string& sensor )
-{
-	InitTest();
-
-	auto conf = uniset_conf();
-	xmlNode* snode = conf->getXMLObjectNode( conf->getSensorID(sensor) );
-	CHECK( snode != 0 );
-	UniXML::iterator it(snode);
-	smi->initIterator(ib->d_it);
-	smi->initIterator(ib->ioit);
-	smi->initIterator(ib->t_ait);
-	return IOBase::initItem(ib, it, smi, "", false);
-}
-// -----------------------------------------------------------------------------
 TEST_CASE("MBTCPMaster: 0x01 (read coil status)", "[modbus][0x01][mbmaster][mbtcpmaster]")
 {
 	InitTest();
@@ -602,6 +588,21 @@ TEST_CASE("MBTCPMaster: 0x66 (file transfer)", "[modbus][0x66][mbmaster][mbtcpma
 }
 // -----------------------------------------------------------------------------
 #if 0
+// -----------------------------------------------------------------------------
+static bool init_iobase( IOBase* ib, const std::string& sensor )
+{
+	InitTest();
+
+	auto conf = uniset_conf();
+	xmlNode* snode = conf->getXMLObjectNode( conf->getSensorID(sensor) );
+	CHECK( snode != 0 );
+	UniXML::iterator it(snode);
+	smi->initIterator(ib->d_it);
+	smi->initIterator(ib->ioit);
+	smi->initIterator(ib->t_ait);
+	return IOBase::initItem(ib, it, smi, "", false);
+}
+// -----------------------------------------------------------------------------
 TEST_CASE("MBTCPMaster: 0x10 (F2)", "[modbus][0x10][F2][mbmaster][mbtcpmaster]")
 {
 	InitTest();

extensions/SharedMemoryPlus/smemory-plus.cc

@@ -28,7 +28,6 @@ using namespace UniSetExtensions;
 const unsigned int MaxAddNum = 10;
 // --------------------------------------------------------------------------
 static void help_print( int argc, const char* argv[] );
-static std::shared_ptr<LogServer> run_logserver( const std::string& cnamem, std::shared_ptr<LogAgregator>& log );
 #ifdef UNISET_ENABLE_IO
 std::list< ThreadCreator<IOControl>* > lst_iothr;
 #endif
@@ -295,49 +294,3 @@ void help_print( int argc, const char* argv[] )
 	cout << "--logfile            - Use logfile. Default: smemory-plus.log" << endl;
 }
 // -----------------------------------------------------------------------------
-std::shared_ptr<LogServer> run_logserver( const std::string& cname, std::shared_ptr<LogAgregator>& log )
-{
-	auto conf = uniset_conf();
-	auto xml = conf->getConfXML();
-	xmlNode* cnode = conf->findNode(xml->getFirstNode(), "LogServer", cname);
-
-	if( cnode == 0 )
-	{
-		cerr << "(init_ulogserver): Not found xmlnode for '" << cname << "'" << endl;
-		return 0;
-
-	}
-
-	UniXML::iterator it(cnode);
-
-	auto ls = make_shared<LogServer>( log );
-
-	timeout_t sessTimeout = conf->getArgPInt("--" + cname + "-session-timeout", it.getProp("sessTimeout"), 3600000);
-	timeout_t cmdTimeout = conf->getArgPInt("--" + cname + "-cmd-timeout", it.getProp("cmdTimeout"), 2000);
-	timeout_t outTimeout = conf->getArgPInt("--" + cname + "-out-timeout", it.getProp("outTimeout"), 2000);
-
-	ls->setSessionTimeout(sessTimeout);
-	ls->setCmdTimeout(cmdTimeout);
-	ls->setOutTimeout(outTimeout);
-
-	std::string host = conf->getArgParam("--" + cname + "-host", it.getProp("host"));
-
-	if( host.empty() )
-	{
-		cerr << "(init_ulogserver): " << cname << ": unknown host.." << endl;
-		return nullptr;
-	}
-
-	ost::tpport_t port = conf->getArgPInt("--" + cname + "-port", it.getProp("port"), 0);
-
-	if( port == 0 )
-	{
-		cerr << "(init_ulogserver): " << cname << ": unknown port.." << endl;
-		return nullptr;
-	}
-
-	cout << "logserver: " << host << ":" << port << endl;
-	ls->run(host, port, true);
-	return ls;
-}
-// -----------------------------------------------------------------------------

extensions/UNetUDP/UDPPacket.h

@@ -61,7 +61,7 @@ namespace UniSetUDP
 	{
 		UDPPacket(): len(0) {}
 
-		int len;
+		size_t len;
 		unsigned char data[ sizeof(UDPHeader) + MaxDCount * sizeof(long) + MaxDDataCount + MaxACount * sizeof(UDPAData) ];
 	} __attribute__((packed));
 

extensions/UNetUDP/UNetSender.cc

@@ -349,7 +349,7 @@ bool UNetSender::initItem( UniXML::iterator& it )
 
 	if( p.iotype == UniversalIO::DI || p.iotype == UniversalIO::DO )
 	{
-		int dnum = packs_dnum[priority];
+		size_t dnum = packs_dnum[priority];
 
 		if( pk.size() <= dnum )
 			pk.resize(dnum + 1);
@@ -386,7 +386,7 @@ bool UNetSender::initItem( UniXML::iterator& it )
 	}
 	else if( p.iotype == UniversalIO::AI || p.iotype == UniversalIO::AO )
 	{
-		int anum = packs_anum[priority];
+		size_t anum = packs_anum[priority];
 
 		if( pk.size() <= anum )
 			pk.resize(anum + 1);
@@ -452,7 +452,7 @@ void UNetSender::askSensors( UniversalIO::UIOCommand cmd )
 		shm->askSensor(it.id, cmd);
 }
 // -----------------------------------------------------------------------------
-int UNetSender::getDataPackCount() const
+size_t UNetSender::getDataPackCount() const
 {
 	return mypacks.size();
 }

extensions/UNetUDP/UNetSender.h

@@ -48,15 +48,15 @@ class UNetSender
 			UItem():
 				iotype(UniversalIO::UnknownIOType),
 				id(UniSetTypes::DefaultObjectId),
-				pack_num(-1),
-				pack_ind(-1),
+				pack_num(0),
+				pack_ind(0),
 				pack_sendfactor(0) {}
 
 			UniversalIO::IOType iotype;
 			UniSetTypes::ObjectId id;
 			IOController::IOStateList::iterator ioit;
-			int pack_num;
-			int pack_ind;
+			size_t pack_num;
+			size_t pack_ind;
 			sendfactor_t pack_sendfactor = { 0 };
 
 			friend std::ostream& operator<<( std::ostream& os, UItem& p );
@@ -64,7 +64,7 @@ class UNetSender
 
 		typedef std::vector<UItem> DMap;
 
-		int getDataPackCount() const;
+		size_t getDataPackCount() const;
 
 		void start();
 		void stop();
@@ -144,8 +144,8 @@ class UNetSender
 		std::string s_host = { "" };
 
 		std::string myname = { "" };
-		int sendpause = { 150 };
-		int packsendpause = { 5 };
+		timeout_t sendpause = { 150 };
+		timeout_t packsendpause = { 5 };
 		std::atomic_bool activated = { false };
 
 		UniSetTypes::uniset_rwmutex pack_mutex;
@@ -153,11 +153,11 @@ class UNetSender
 		typedef std::unordered_map<sendfactor_t, std::vector<UniSetUDP::UDPMessage>> Packs;
 
 		Packs mypacks;
-		std::unordered_map<sendfactor_t, int> packs_anum;
-		std::unordered_map<sendfactor_t, int> packs_dnum;
+		std::unordered_map<sendfactor_t, size_t> packs_anum;
+		std::unordered_map<sendfactor_t, size_t> packs_dnum;
 		DMap dlist;
-		int maxItem = { 0 };
-		unsigned long packetnum = { 1 }; /*!< номер очередного посылаемого пакета */
+		size_t maxItem = { 0 };
+		size_t packetnum = { 1 }; /*!< номер очередного посылаемого пакета */
 		unsigned short lastcrc = { 0 };
 		UniSetUDP::UDPPacket s_msg;
 

extensions/include/UObject_SK.h

@@ -8,7 +8,7 @@
  ВСЕ ВАШИ ИЗМЕНЕНИЯ БУДУТ ПОТЕРЯНЫ.
 */ 
 // --------------------------------------------------------------------------
-// generate timestamp: 2015-10-14+03:00
+// generate timestamp: 2015-10-25+03:00
 // -----------------------------------------------------------------------------
 #ifndef UObject_SK_H_
 #define UObject_SK_H_
@@ -191,9 +191,9 @@ class UObject_SK:
 		/*! получить текстовое свойство из конф. файла по привязанной confnode */
 		inline const std::string getProp(const std::string& name) { return UniSetTypes::uniset_conf()->getProp(confnode, name); }
 
-		int smReadyTimeout; 	/*!< время ожидания готовности SM */
+		timeout_t smReadyTimeout; 	/*!< время ожидания готовности SM */
 		std::atomic_bool activated;
-		int activateTimeout;	/*!< время ожидания готовности UniSetObject к работе */
+		timeout_t activateTimeout;	/*!< время ожидания готовности UniSetObject к работе */
 		PassiveTimer ptStartUpTimeout;	/*!< время на блокировку обработки WatchDog, если недавно был StartUp */
 		int askPause; /*!< пауза между неудачными попытками заказать датчики */
 		

extensions/lib/IOBase.cc

@@ -550,13 +550,13 @@ bool IOBase::initItem( IOBase* b, UniXML::iterator& it, const std::shared_ptr<SM
 	b->breaklim = initIntProp(it, "breaklim", prefix, init_prefix_only);
 	b->rawdata  = initIntProp(it, "rawdata", prefix, init_prefix_only);
 
-	long d_msec = initIntProp(it, "debouncedelay", prefix, init_prefix_only, UniSetTimer::WaitUpTime);
+	timeout_t d_msec = initIntProp(it, "debouncedelay", prefix, init_prefix_only, UniSetTimer::WaitUpTime);
 	b->ptDebounce.setTiming(d_msec);
 
-	long d_on_msec = initIntProp(it, "ondelay", prefix, init_prefix_only, UniSetTimer::WaitUpTime);
+	timeout_t d_on_msec = initIntProp(it, "ondelay", prefix, init_prefix_only, UniSetTimer::WaitUpTime);
 	b->ptOnDelay.setTiming(d_on_msec);
 
-	long d_off_msec = initIntProp(it, "offdelay", prefix, init_prefix_only, UniSetTimer::WaitUpTime);
+	timeout_t d_off_msec = initIntProp(it, "offdelay", prefix, init_prefix_only, UniSetTimer::WaitUpTime);
 	b->ptOffDelay.setTiming(d_off_msec);
 
 

extensions/lib/UObject_SK.cc

@@ -11,7 +11,7 @@
  ВСЕ ВАШИ ИЗМЕНЕНИЯ БУДУТ ПОТЕРЯНЫ.
 */ 
 // --------------------------------------------------------------------------
-// generate timestamp: 2015-10-14+03:00
+// generate timestamp: 2015-10-25+03:00
 // -----------------------------------------------------------------------------
 #include <memory>
 #include <iomanip>
@@ -67,7 +67,6 @@ static const std::string init3_str( const std::string& s1, const std::string& s2
 // -----------------------------------------------------------------------------
 UObject_SK::UObject_SK( ObjectId id, xmlNode* cnode, const std::string& _argprefix ):
 UniSetObject(id),
-argprefix( (_argprefix.empty() ? myname+"-" : _argprefix) ),
 // Инициализация идентификаторов (имена берутся из конф. файла)
 
 // Используемые идентификаторы сообщений (имена берутся из конф. файла)
@@ -76,6 +75,7 @@ argprefix( (_argprefix.empty() ? myname+"-" : _argprefix) ),
 
 sleep_msec(150),
 active(true),
+argprefix( (_argprefix.empty() ? myname+"-" : _argprefix) ),
 
 idHeartBeat(DefaultObjectId),
 maxHeartBeat(10),
@@ -155,6 +155,9 @@ end_private(false)
 	// Инициализация значений
 	
 	
+	si.id = UniSetTypes::DefaultObjectId;
+	si.node = conf->getLocalNode();
+	
 	sleep_msec = conf->getArgPInt("--" + argprefix + "sleep-msec","150", 150);
 
 	string s_resetTime("");

include/ComPort.h

@@ -6,6 +6,7 @@
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <string>
+#include <cc++/thread.h> // for use timeout_t
 // --------------------------------------------------------------------------
 class ComPort
 {
@@ -88,8 +89,8 @@ class ComPort
 		void setCharacterSize(CharacterSize);
 		void setStopBits(StopBits sBit);
 
-		virtual void setTimeout(int msec);
-		inline int getTimeout()
+		virtual void setTimeout( timeout_t msec );
+		inline timeout_t getTimeout()
 		{
 			return uTimeout / 1000;    // msec
 		}
@@ -99,8 +100,8 @@ class ComPort
 		virtual unsigned char receiveByte();
 		virtual void sendByte(unsigned char x);
 
-		virtual int receiveBlock(unsigned char* msg, int len);
-		virtual int sendBlock(unsigned char* msg, int len);
+		virtual size_t receiveBlock(unsigned char* msg, size_t len);
+		virtual size_t sendBlock(unsigned char* msg, size_t len);
 
 		void setBlocking(bool blocking);
 
@@ -115,7 +116,7 @@ class ComPort
 		int curSym = { 0 };
 		int bufLength = { 0 };
 		int fd = { -1 };
-		int uTimeout = { 0 };
+		timeout_t uTimeout = { 0 };
 		bool waiting = { false };
 		Speed speed = ComSpeed38400;
 		std::string dev = { "" };

include/ComPort485F.h

-#ifndef _COMPORT_485F_H_
-#define _COMPORT_485F_H_
+#ifndef COMPORT_485F_H_
+#define COMPORT_485F_H_
 // --------------------------------------------------------------------------
 #include <queue>
 #include "ComPort.h"
@@ -23,16 +23,16 @@ class ComPort485F:
 
 		ComPort485F( const std::string& comDevice, int gpio_num, bool tmit_ctrl = false );
 
-		virtual void sendByte( unsigned char x );
-		virtual void setTimeout( int timeout );
-		virtual int sendBlock( unsigned char* msg, int len );
+		virtual void sendByte( unsigned char x ) override;
+		virtual void setTimeout( timeout_t timeout ) override;
+		virtual size_t sendBlock( unsigned char* msg, size_t len ) override;
 
-		virtual void cleanupChannel();
-		virtual void reopen();
+		virtual void cleanupChannel() override;
+		virtual void reopen() override;
 
 	protected:
 
-		virtual unsigned char m_receiveByte( bool wait );
+		virtual unsigned char m_receiveByte( bool wait ) override;
 		void save2queue( unsigned char* msg, int len, int bnum );
 		bool remove_echo( unsigned char tb[], int len );
 		void m_read( int tmsec );
@@ -46,8 +46,8 @@ class ComPort485F:
 		int gpio_num;
 		bool tmit_ctrl_on;
 		PassiveTimer ptRecv;
-		int tout_msec = { 2000 };
+		timeout_t tout_msec = { 2000 };
 };
 // --------------------------------------------------------------------------
-#endif // _COMPORT_E_H_
+#endif // COMPORT_485F_H_
 // --------------------------------------------------------------------------

include/modbus/ModbusClient.h

@@ -170,7 +170,7 @@ class ModbusClient
 		    \param len     - size of buf
 		    \return real data lenght ( must be <= len )
 		*/
-		virtual int getNextData( unsigned char* buf, int len ) = 0;
+		virtual size_t getNextData( unsigned char* buf, int len ) = 0;
 
 		/*! set timeout for send/receive data */
 		virtual void setChannelTimeout( timeout_t msec ) = 0;

include/modbus/ModbusRTUMaster.h

@@ -46,7 +46,7 @@ class ModbusRTUMaster:
 		    \param len     - size of buf
 		    \return real data lenght ( must be <= len )
 		*/
-		virtual int getNextData( unsigned char* buf, int len ) override;
+		virtual size_t getNextData( unsigned char* buf, int len ) override;
 
 		/*! set timeout for send/receive data */
 		virtual void setChannelTimeout( timeout_t msec ) override;

include/modbus/ModbusTCPCore.h

@@ -9,9 +9,9 @@
 /*!    ModbusTCP core functions */
 namespace ModbusTCPCore
 {
-	int readNextData( ost::TCPStream* tcp, std::queue<unsigned char>& qrecv, int max = 100 );
-	int getNextData( ost::TCPStream* tcp, std::queue<unsigned char>& qrecv, unsigned char* buf, int len );
-	ModbusRTU::mbErrCode sendData( ost::TCPStream* tcp, unsigned char* buf, int len );
+	size_t readNextData( ost::TCPStream* tcp, std::queue<unsigned char>& qrecv, int max = 100 );
+	size_t getNextData( ost::TCPStream* tcp, std::queue<unsigned char>& qrecv, unsigned char* buf, size_t len );
+	ModbusRTU::mbErrCode sendData( ost::TCPStream* tcp, unsigned char* buf, size_t len );
 }
 // -------------------------------------------------------------------------
 #endif // ModbusTCPCore_H_

include/modbus/ModbusTCPMaster.h

@@ -49,7 +49,7 @@ class ModbusTCPMaster:
 
 	protected:
 
-		virtual int getNextData( unsigned char* buf, int len ) override;
+		virtual size_t getNextData( unsigned char* buf, int len ) override;
 		virtual void setChannelTimeout( timeout_t msec ) override;
 		virtual ModbusRTU::mbErrCode sendData( unsigned char* buf, int len ) override;
 		virtual ModbusRTU::mbErrCode query( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusMessage& msg,

include/modbus/ModbusTypes.h

@@ -175,7 +175,7 @@ namespace ModbusRTU
 		ModbusByte data[MAXLENPACKET + szCRC];   /*!< данные */
 
 		// Это поле вспомогательное и игнорируется при пересылке
-		int len;    /*!< фактическая длина */
+		size_t len;    /*!< фактическая длина */
 	} __attribute__((packed));
 
 	std::ostream& operator<<(std::ostream& os, ModbusMessage& m );

python/lib/pyUniSet/Makefile.am

@@ -49,8 +49,10 @@ _pyUExceptions_la_LIBADD 	= $(UNISET_LIBS) $(UNISET_EXT_LIBS) $(PYTHON_LIBS)
 UExceptions_wrap.cxx: UExceptions.i UExceptions.h
 	swig -python -c++ -classic UExceptions.i
 
-clean-local:
-	rm -rf *.py*
+# Специальное правило для удаления сгенерированного кода
+# для дальнейшей перегенерации
+clean-gen:
+	rm -rf *.py* *_wrap.cxx
 
 include $(top_builddir)/include.mk
 

python/lib/pyUniSet/UModbus.cc

@@ -303,7 +303,9 @@ void UModbus::mbwrite( int mbaddr, int mbreg, int val, int mbfunc, const char* n
 		{
 			case ModbusRTU::fnWriteOutputSingleRegister:
 			{
-				ModbusRTU::WriteSingleOutputRetMessage ret = mb->write06(mbaddr, mbreg, val);
+				// ModbusRTU::WriteSingleOutputRetMessage ret =
+				// игнорируем return т.к. если будет ошибка, то будет исключение
+				(void)mb->write06(mbaddr, mbreg, val);
 			}
 			break;
 
@@ -311,13 +313,17 @@ void UModbus::mbwrite( int mbaddr, int mbreg, int val, int mbfunc, const char* n
 			{
 				ModbusRTU::WriteOutputMessage msg(mbaddr, mbreg);
 				msg.addData(val);
-				ModbusRTU::WriteOutputRetMessage ret = mb->write10(msg);
+				//ModbusRTU::WriteOutputRetMessage ret =
+				// игнорируем return т.к. если будет ошибка, то будет исключение
+				(void)mb->write10(msg);
 			}
 			break;
 
 			case ModbusRTU::fnForceSingleCoil:
 			{
-				ModbusRTU::ForceSingleCoilRetMessage ret = mb->write05(mbaddr, mbreg, val);
+				// ModbusRTU::ForceSingleCoilRetMessage ret =
+				// игнорируем return т.к. если будет ошибка, то будет исключение
+				(void)mb->write05(mbaddr, mbreg, val);
 			}
 			break;
 
@@ -325,7 +331,9 @@ void UModbus::mbwrite( int mbaddr, int mbreg, int val, int mbfunc, const char* n
 			{
 				ModbusRTU::ForceCoilsMessage msg(mbaddr, mbreg);
 				msg.addBit( (val ? true : false) );
-				ModbusRTU::ForceCoilsRetMessage ret = mb->write0F(msg);
+				// ModbusRTU::ForceCoilsRetMessage ret =
+				// игнорируем return т.к. если будет ошибка, то будет исключение
+				(void)mb->write0F(msg);
 			}
 			break;
 
@@ -338,7 +346,7 @@ void UModbus::mbwrite( int mbaddr, int mbreg, int val, int mbfunc, const char* n
 			break;
 		}
 	}
-	catch( ModbusRTU::mbException& ex )
+	catch( const ModbusRTU::mbException& ex )
 	{
 		if( ex.err != ModbusRTU::erTimeOut )
 			throw UTimeOut();
@@ -347,9 +355,9 @@ void UModbus::mbwrite( int mbaddr, int mbreg, int val, int mbfunc, const char* n
 		err << ex;
 		throw UException(err.str());
 	}
-	catch(...)
+	catch( const std::exception& ex )
 	{
-		throw UException("(mbwrite): catch...");
+		throw UException("(mbwrite): catch " + std::string(ex.what()) );
 	}
 }
 //---------------------------------------------------------------------------

src/Communications/ComPort.cc

@@ -271,18 +271,18 @@ void ComPort::sendByte(unsigned char x)
 }
 // --------------------------------------------------------------------------------
 // Lav: убрать, переделать в receiveBlock
-void ComPort::setTimeout( int msec )
+void ComPort::setTimeout( timeout_t msec )
 {
 	uTimeout = msec * 1000;
 }
 // --------------------------------------------------------------------------------
 // Lav: ситуация, когда отправлено меньше запрошенного, не типична и должна
 // генерировать исключение
-int ComPort::sendBlock(unsigned char* msg, int len)
+size_t ComPort::sendBlock(unsigned char* msg, size_t len)
 {
 	//    fcntl(fd,F_SETFL,0);
 
-	int sndLen =::write(fd, msg, len);
+	ssize_t sndLen =::write(fd, msg, len);
 
 	//    fcntl(fd,F_SETFL,O_NONBLOCK);
 
@@ -298,9 +298,9 @@ int ComPort::sendBlock(unsigned char* msg, int len)
 // --------------------------------------------------------------------------------
 // Lav: ожидание задавать третим необязательным параметром
 // Lav: Никогда не возвращаТЬ меньше запрошенного (кроме 0)
-int ComPort::receiveBlock(unsigned char* msg, int len)
+size_t ComPort::receiveBlock(unsigned char* msg, size_t len)
 {
-	int k;
+	size_t k = 0;
 
 	if(!len)
 		return 0;

src/Communications/ComPort485F.cc

@@ -80,7 +80,7 @@ ComPort485F::ComPort485F( const string& dev, int gpio_num, bool tmit_ctrl ):
 	}
 }
 // --------------------------------------------------------------------------------
-void ComPort485F::setTimeout( int msec )
+void ComPort485F::setTimeout( timeout_t msec )
 {
 	tout_msec = msec;
 	ComPort::setTimeout(msec);
@@ -152,7 +152,7 @@ unsigned char ComPort485F::m_receiveByte( bool wait )
 	return x;
 }
 // --------------------------------------------------------------------------------
-int ComPort485F::sendBlock( unsigned char* msg, int len )
+size_t ComPort485F::sendBlock(unsigned char* msg, size_t len )
 {
 	if( tmit_ctrl_on )
 	{
@@ -160,7 +160,7 @@ int ComPort485F::sendBlock( unsigned char* msg, int len )
 		gpio_low_set_value(gpio_num, 1);
 	}
 
-	int r = 0;
+	size_t r = 0;
 
 	try
 	{

src/Communications/Modbus/ModbusClient.cc

@@ -419,7 +419,7 @@ mbErrCode ModbusClient::recv_pdu( ModbusByte qfunc, ModbusMessage& rbuf, timeout
 			if( crcNoCheckit )
 				rbuf.len -= szCRC;
 
-			int rlen = getNextData((unsigned char*)(&(rbuf.data)), rbuf.len);
+			size_t rlen = getNextData((unsigned char*)(&(rbuf.data)), rbuf.len);
 
 			if( rlen < rbuf.len )
 			{
@@ -555,7 +555,7 @@ mbErrCode ModbusClient::recv_pdu( ModbusByte qfunc, ModbusMessage& rbuf, timeout
 		setChannelTimeout(10); // 10 msec
 
 		// Получаем остальную часть сообщения
-		int rlen = getNextData((unsigned char*)(rbuf.data), rbuf.len);
+		size_t rlen = getNextData((unsigned char*)(rbuf.data), rbuf.len);
 
 		if( rlen < rbuf.len )
 		{
@@ -992,7 +992,7 @@ mbErrCode ModbusClient::recv_pdu( ModbusByte qfunc, ModbusMessage& rbuf, timeout
 
 			if( mPreRDI.objNum > 0 )
 			{
-				int onum = 0;
+				size_t onum = 0;
 
 				while( (rlen+2) < sizeof(rbuf) && onum < mPreRDI.objNum )
 				{

src/Communications/Modbus/ModbusRTUMaster.cc

@@ -108,7 +108,7 @@ int ModbusRTUMaster::getTimeout()
 	return port->getTimeout();
 }
 // -------------------------------------------------------------------------
-int ModbusRTUMaster::getNextData( unsigned char* buf, int len )
+size_t ModbusRTUMaster::getNextData( unsigned char* buf, int len )
 {
 	//    if( !port ) return 0;
 	return port->receiveBlock(buf, len);

src/Communications/Modbus/ModbusServer.cc

@@ -751,7 +751,7 @@ mbErrCode ModbusServer::recv_pdu( ModbusMessage& rbuf, timeout_t timeout )
 		setChannelTimeout(10); // 10 msec
 
 		// Получаем остальную часть сообщения
-		int rlen = getNextData((unsigned char*)(rbuf.data), rbuf.len);
+		size_t rlen = getNextData((unsigned char*)(rbuf.data), rbuf.len);
 
 		if( rlen < rbuf.len )
 		{

src/Communications/Modbus/ModbusTCPCore.cc

@@ -3,7 +3,7 @@
 using namespace std;
 using namespace ModbusRTU;
 // -------------------------------------------------------------------------
-int ModbusTCPCore::readNextData( ost::TCPStream* tcp,
+size_t ModbusTCPCore::readNextData( ost::TCPStream* tcp,
 								 std::queue<unsigned char>& qrecv, int max )
 {
 	if( !tcp || !tcp->isConnected() )
@@ -25,9 +25,9 @@ int ModbusTCPCore::readNextData( ost::TCPStream* tcp,
 	return i;
 }
 // ------------------------------------------------------------------------
-int ModbusTCPCore::getNextData( ost::TCPStream* tcp,
+size_t ModbusTCPCore::getNextData(ost::TCPStream* tcp,
 								std::queue<unsigned char>& qrecv,
-								unsigned char* buf, int len )
+								unsigned char* buf, size_t len )
 {
 	if( !tcp || !tcp->isConnected() )
 		return 0;
@@ -43,7 +43,7 @@ int ModbusTCPCore::getNextData( ost::TCPStream* tcp,
 			return 0;
 	}
 
-	int i = 0;
+	size_t i = 0;
 
 	for( ; i < len && !qrecv.empty(); i++ )
 	{
@@ -54,14 +54,14 @@ int ModbusTCPCore::getNextData( ost::TCPStream* tcp,
 	return i;
 }
 // -------------------------------------------------------------------------
-mbErrCode ModbusTCPCore::sendData( ost::TCPStream* tcp, unsigned char* buf, int len )
+mbErrCode ModbusTCPCore::sendData(ost::TCPStream* tcp, unsigned char* buf, size_t len )
 {
 	if( !tcp || !tcp->isConnected() )
 		return erTimeOut;
 
 	try
 	{
-		for( auto i = 0; i < len; i++ )
+		for( size_t i = 0; i < len; i++ )
 			(*tcp) << buf[i];
 
 		return erNoError;

src/Communications/Modbus/ModbusTCPMaster.cc

@@ -33,7 +33,7 @@ ModbusTCPMaster::~ModbusTCPMaster()
 	tcp.reset();
 }
 // -------------------------------------------------------------------------
-int ModbusTCPMaster::getNextData( unsigned char* buf, int len )
+size_t ModbusTCPMaster::getNextData( unsigned char* buf, int len )
 {
 	return ModbusTCPCore::getNextData(tcp.get(), qrecv, buf, len);
 }

src/Communications/Modbus/ModbusTypes.cc

@@ -2521,7 +2521,7 @@ void MEIMessageRetRDI::init( ModbusMessage& m )
 
 	bcnt = 0;
 	dlist.clear();
-	int i = 6;
+	size_t i = 6;
 
 	if( objNum > 0 )
 	{

src/Various/RunLock.cc

@@ -89,6 +89,7 @@ bool RunLock::isLocked( const string& name )
 
 	fclose(out);
 	closedir(d);
+	return false;
 }
 // --------------------------------------------------------------------------
 bool RunLock::lock( const string& name )

src/Various/SMonitor.cc

@@ -115,7 +115,11 @@ void SMonitor::sensorInfo( const SensorMessage* si )
 
 		cmd << " " << si->id << " " << si->value << " " << si->sm_tv_sec << " " << si->sm_tv_usec;
 
-		(void)system(cmd.str().c_str());
+		int ret = system(cmd.str().c_str());
+		int res = WEXITSTATUS(ret);
+		if( res != 0 )
+			cerr << "run script '" <<cmd.str() << "' failed.." << endl;
+
 		//        if( WIFSIGNALED(ret) && (WTERMSIG(ret) == SIGINT || WTERMSIG(ret) == SIGQUIT))
 		//        {
 		//            cout << "finish..." << endl;

src/Various/WDTInterface.cc

@@ -31,7 +31,14 @@ bool WDTInterface::ping()
 		return false;
 	}
 
-	write(fd, (void*)CMD_PING, sizeof(CMD_PING));
+	int ret = write(fd, (void*)CMD_PING, sizeof(CMD_PING));
+	if( ret == -1 )
+	{
+		cerr << ": Unable to open device " << dev << " with err: " << strerror(errno) << endl;
+		close(fd);
+		return false;
+	}
+
 	close(fd);
 	return true;
 }
@@ -46,7 +53,14 @@ bool WDTInterface::stop()
 		return false;
 	}
 
-	write(fd, (void*)CMD_STOP, sizeof(CMD_STOP));
+	int ret = write(fd, (void*)CMD_STOP, sizeof(CMD_STOP));
+	if( ret == -1 )
+	{
+		cerr << ": Unable to open device " << dev << " with err: " << strerror(errno) << endl;
+		close(fd);
+		return false;
+	}
+
 	close(fd);
 	return true;
 }