(2.0): - Заменил ТАБУЛЯЦИИ НА ПРОБЕЛЫ по всем исходным файлам - Небольшая…

Utilities/MBTester/MBSlave.h

@@ -94,9 +94,6 @@ class MBSlave
         ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
                                                         ModbusRTU::MEIMessageRetRDI& reply );
 
-		ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
-														ModbusRTU::MEIMessageRetRDI& reply );
-
         /*! интерфейс ModbusRTUSlave для обмена по RS */
         ModbusRTUSlaveSlot* rscomm;
         ModbusRTU::ModbusAddr addr;            /*!< адрес данного узла */

Utilities/MBTester/MBTCPServer.h

@@ -23,11 +23,6 @@ class MBTCPServer
             replyVal = val;
         }
 
-		inline void setReply( long val )
-		{
-			replyVal = val;
-		}
-
         inline void setIgnoreAddrMode( bool state )
         {
             if( sslot )
@@ -80,9 +75,6 @@ class MBTCPServer
         ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
                                                         ModbusRTU::MEIMessageRetRDI& reply );
 
-		ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
-														ModbusRTU::MEIMessageRetRDI& reply );
-
         /*! обработка запросов на чтение ошибок */
         ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query,
                                                             ModbusRTU::JournalCommandRetMessage& reply );

Utilities/codegen/ctl-cpp-common.xsl

@@ -611,6 +611,7 @@ end_private(false)
 	<xsl:if test="normalize-space(@no_check_id)!='1'">
 	if( <xsl:value-of select="normalize-space(@name)"/> == UniSetTypes::DefaultObjectId )
 		throw Exception( myname + ": Not found ID for (<xsl:value-of select="@name"/>) " + conf->getProp(cnode,"<xsl:value-of select="@name"/>") );
+
 	</xsl:if>
 
 	if( node_<xsl:value-of select="normalize-space(@name)"/> == UniSetTypes::DefaultObjectId )

Utilities/codegen/tests/TestGen.cc

-#include <iomanip>
 #include "Exceptions.h"
-#include "TestProc.h"
+#include "TestGen.h"
 // -----------------------------------------------------------------------------
 using namespace std;
 using namespace UniSetTypes;
 // -----------------------------------------------------------------------------
-TestProc::TestProc( UniSetTypes::ObjectId id, xmlNode* confnode ):
-	TestProc_SK( id, confnode ),
-	state(false)
+TestGen::TestGen( UniSetTypes::ObjectId id, xmlNode* confnode ):
+    TestGen_SK( id, confnode )
 {
-	loglevels.push_back(Debug::INFO);
-	loglevels.push_back(Debug::WARN);
-	loglevels.push_back(Debug::CRIT);
-	loglevels.push_back(Debug::LEVEL1);
-	loglevels.push_back(Debug::LEVEL2);
-	loglevels.push_back( Debug::type(Debug::LEVEL2 | Debug::INFO) );
-	loglevels.push_back( Debug::type(Debug::LEVEL2 | Debug::INFO | Debug::WARN | Debug::CRIT) );
-
-	lit = loglevels.begin();
-	out_log_c = (*lit);
 }
 // -----------------------------------------------------------------------------
-TestProc::~TestProc()
+TestGen::~TestGen()
 {
 }
 // -----------------------------------------------------------------------------
-TestProc::TestProc():
-	state(false)
+TestGen::TestGen()
 {
     cerr << ": init failed!!!!!!!!!!!!!!!"<< endl;
     throw Exception();
 }
 // -----------------------------------------------------------------------------
-void TestProc::step()
+void TestGen::step()
 {
+    cout << "input2 state=" << in_input2_s << endl;
 }
 // -----------------------------------------------------------------------------
-void TestProc::sysCommand( UniSetTypes::SystemMessage* sm )
+void TestGen::sensorInfo( SensorMessage *sm )
 {
-	TestProc_SK::sysCommand(sm);
-    if( sm->command == SystemMessage::StartUp || sm->command == SystemMessage::WatchDog )
-    {
-        askTimer(tmCheck,checkTime);
-        askTimer(tmCheckWorking,checkWorkingTime);
-		askTimer(tmLogControl,checkLogTime);
-
-        // В начальный момент времени блокирующий датчик =0, поэтому d2_check_s должен быть равен depend_off_value (-50).
-       cerr << myname << "(startup): check init depend: " << ( getValue(d2_check_s) == -50 ? "OK" : "FAIL" ) << endl;
-    }
+    if( sm->id == input1_s )
+        out_output1_c = in_input1_s; // sm->state
 }
 // -----------------------------------------------------------------------------
-void TestProc::sensorInfo( SensorMessage *sm )
+void TestGen::timerInfo( TimerMessage *tm )
 {
-/*
-	dlog.level2() << myname << "(sensorInfo): id=" << sm->id << " val=" << sm->value
-			<< "  " << timeToString(sm->sm_tv_sec,":")
-			<< "(" << setw(6) << sm->sm_tv_usec << "): "
-			<< endl;
-*/
-	if( sm->id == on_s )
-	{
-		if( sm->value )
-		{
-			cerr << myname << "(sensorInfo): START WORKING.." << endl;
-			askTimer(tmChange,changeTime);
-		}
-	    else
-	    {
-			askTimer(tmChange,0);
-			cerr << myname << "(sensorInfo): STOP WORKING.." << endl;
-		}
-	}
-	else if( sm->id == check_undef_s )
-	{
-		cerr << myname << "(sensorInfo): CHECK UNDEFINED STATE ==> " << (sm->undefined==undef ? "OK" : "FAIL") << endl;
-	}
 }
 // -----------------------------------------------------------------------------
-void TestProc::timerInfo( TimerMessage *tm )
+void TestGen::sigterm( int signo )
 {
-	if( tm->id == tmChange )
-	{
-		state^=true;
-		out_lamp_c = ( state ? lmpBLINK : lmpOFF );
-		dlog.level2() << myname << ": state=" << state << " lmp=" << out_lamp_c << endl;
-        askTimer(tmCheckWorking,checkTime); // reset timer
-	}
-	else if( tm->id == tmCheckWorking )
-       cerr << myname << ": WORKING FAIL!" << endl;
-	else if( tm->id == tmCheck )
-	{
-		cerr << endl << endl << "--------" << endl;
-        test_depend();
-        test_undefined_state();
-        test_thresholds();
-        test_loglevel();
-	}
-	else if( tm->id == tmLogControl )
-	{
-		cerr << endl;
-		cerr << "======= TEST LOG PRINT ======" << endl;
-		cerr << "LOGLEVEL: [" << (int)(*lit) << "] " << (*lit) << endl;
-		for( std::vector<Debug::type>::iterator it=loglevels.begin(); it!=loglevels.end(); ++it )
-			dlog[*it] << myname << ": test log print..." << endl;
-
-		cerr << "======= END LOG PRINT ======" << endl;
-	}
-}
-// -----------------------------------------------------------------------------
-void TestProc::test_depend()
-{
-    cerr << myname << ": Check depend..." << endl;
-
-    long test_val = 100;
-
-    // set depend 0...
-    setValue(depend_c,0);
-    setValue(set_d1_check_s,test_val);
-    setValue(set_d2_check_s,test_val);
-    cerr << myname << ": check depend OFF: d1: " << ( getValue(d1_check_s) == 0 ? "OK" : "FAIL" ) << endl;
-    cerr << myname << ": check depend OFF: d2: " << ( getValue(d2_check_s) == -50 ? "OK" : "FAIL" ) << endl;
-
-    // set depend 1
-    setValue(depend_c,1);
-    cerr << myname << ": check depend ON: d1: " << ( getValue(d1_check_s) == test_val ? "OK" : "FAIL" ) << endl;
-    cerr << myname << ": check depend ON: d2: " << ( getValue(d2_check_s) == test_val ? "OK" : "FAIL" ) << endl;
-}
-// -----------------------------------------------------------------------------
-void TestProc::test_undefined_state()
-{
-    // ---------------- Проверка выставления неопределённого состояния ---------------------
-    cerr << myname << ": Check undef state..." << endl;
-    undef ^= true;
-
-    si.id = undef_c;
-    si.node = conf->getLocalNode();
-    cerr << myname << ": set undefined=" << undef << endl;
-    ui.setUndefinedState( si, undef, getId() );
-}
-// -----------------------------------------------------------------------------
-void TestProc::test_thresholds()
-{
-    // ---------------- Проверка работы порогов ---------------------
-    cerr << myname << ": Check thresholds..." << endl;
-
-    setValue(t_set_c,0);
-    cerr << myname << ": check threshold OFF value: " << ( getValue(t_check_s) == 0 ? "OK" : "FAIL" ) << endl;
-
-    setValue(t_set_c,378);
-    cerr << myname << ": check threshold ON value: " << ( getValue(t_check_s) == 1 ? "OK" : "FAIL" ) << endl;
-
-	cerr << myname << ": ask threshold and check.. " << endl;
-
-	try
-	{
-		setValue(t_set_c, 0);
-		UniSetTypes::ThresholdId tid = 100;
-		ui.askThreshold( t_set_c, tid, UniversalIO::UIONotify, 10, 20 );
-
-		IONotifyController_i::ThresholdInfo ti = ui.getThresholdInfo(t_set_c,tid);
-		cerr << myname << ": ask OFF threshold: " << ( ti.state == IONotifyController_i::NormalThreshold  ? "OK" : "FAIL" ) << endl;
-		setValue(t_set_c, 25);
-		ti = ui.getThresholdInfo(t_set_c,tid);
-		cerr << myname << ": ask ON threshold: " << ( ti.state == IONotifyController_i::HiThreshold  ? "OK" : "FAIL" ) << endl;
-	}
-	catch( Exception& ex )
-	{
-		dlog.level2() << myname << ": CHECK 'ask and get threshold' FAILED: " << ex << endl;
-	}
-}
-// -----------------------------------------------------------------------------
-void TestProc::test_loglevel()
-{
-	lit++;
-	if( lit == loglevels.end() )
-		lit = loglevels.begin();
-
-	cerr << "SET LOGLEVEL: [" << (int)(*lit) << "] " << (*lit) << endl;
-	setValue(log_c, (*lit));
-	askTimer(tmLogControl,checkLogTime);
+    TestGen_SK::sigterm(signo);
 }
 // -----------------------------------------------------------------------------

Utilities/codegen/tests/TestGen.h

 // -----------------------------------------------------------------------------
-#ifndef TestProc_H_
-#define TestProc_H_
+#ifndef TestGen_H_
+#define TestGen_H_
 // -----------------------------------------------------------------------------
-#include <vector>
-#include "Debug.h"
-#include "TestProc_SK.h"
+#include "TestGen_SK.h"
 // -----------------------------------------------------------------------------
-class TestProc:
-	public TestProc_SK
+class TestGen:
+    public TestGen_SK
 {
     public:
-		TestProc( UniSetTypes::ObjectId id, xmlNode* confnode = UniSetTypes::conf->getNode("TestProc") );
-		virtual ~TestProc();
+        TestGen( UniSetTypes::ObjectId id, xmlNode* confnode = UniSetTypes::conf->getNode("TestGen") );
+        virtual ~TestGen();
 
-	protected:
-		TestProc();
 
-		enum Timers
-		{
-			tmChange,
-			tmCheckWorking,
-			tmCheck,
-			tmLogControl
-		};
+    protected:
+        TestGen();
 
         virtual void step();
-		virtual void sensorInfo( UniSetTypes::SensorMessage *sm );
-		virtual void timerInfo( UniSetTypes::TimerMessage *tm );
-        virtual void sysCommand( UniSetTypes::SystemMessage* sm );
-		
-        void test_depend();
-        void test_undefined_state();
-        void test_thresholds();
-        void test_loglevel();
+        void sensorInfo( UniSetTypes::SensorMessage *sm );
+        void timerInfo( UniSetTypes::TimerMessage *tm );
+        virtual void sigterm( int signo );
 
     private:
-		bool state;
-		bool undef;
-
-		std::vector<Debug::type> loglevels;
-		std::vector<Debug::type>::iterator lit;
 };
 // -----------------------------------------------------------------------------
-#endif // TestProc_H_
+#endif // TestGen_H_
 // -----------------------------------------------------------------------------

conf/test.xml

@@ -148,7 +148,7 @@
 			</rrd>
 		</RRDServer1>
 	</settings>
-	<ObjectsMap idfromfile="0">
+	<ObjectsMap idfromfile="1">
 		<!--
 	Краткие пояснения к полям секции 'sensors'
 	==========================================
@@ -273,7 +273,6 @@
 	</messages>
 	<!-- <xi:include href="testID.xml"/> -->
 	<!-- <xi:include href="testIDnon-exist.xml"/> -->
-
 	<Calibrations name="Calibrations">
 		<diagram name="testcal">
 			<point x="-200" y="-60"/>

extensions/DBServer-MySQL/DBInterface.cc

@@ -54,7 +54,6 @@ bool DBInterface::connect( const string& host, const string& user, const string&
         connected = false;
         return false;
     }
-
     connected = true;
     return true;
 }
@@ -219,10 +218,9 @@ bool DBInterface::moveToRow(int ind)
 // -----------------------------------------------------------------------------------------
 bool DBInterface::ping()
 {
-	if(!mysql)
-		return false;
-	if(!connected)
+    if( !mysql || !connected )
         return false;
+
     // внимание mysql_ping возвращает 0
     // если всё хорошо.... (поэтому мы инвертируем)
     return !mysql_ping(mysql);

extensions/IOControl/IOControl.h

@@ -84,6 +84,10 @@
     <br>\b jardelay        - защита от дребезга. Задержка на дребезг, мсек.
     <br>\b ondelay         - задержка на срабатывание, мсек.
     <br>\b offdelay        - задержка на отпускание, мсек.
+    <br>\b iofront         - работа по фронту сигнала (для DI).
+    <br>                        "01" - срабатывание (и отпускание) по переходу "0 --> 1"
+    <br>                        "10" - срабатывание (и отпускание) по переходу "1 --> 0"
+
     <br>\b safety          - безопасное значение. Значение которое сохраняется в случае аварийного
                       завершения процесса.
 

extensions/LogicProcessor/TDelay.cc

@@ -30,10 +30,8 @@ void TDelay::setIn( int num, bool state )
     {
         pt.setTiming(0); // reset timer
         myout = false;
-
         if( dlog.is_info() )
             dlog.info() << this << ": set " << myout << endl;
-
         if( prev != myout )
             Element::setChildOut();
         return;
@@ -46,10 +44,8 @@ void TDelay::setIn( int num, bool state )
     {
         pt.setTiming(0); // reset timer
         myout = true;
-
         if( dlog.is_info() )
             dlog.info() << this << ": set " << myout << endl;
-
         if( prev != myout )
             Element::setChildOut();
         return;
@@ -60,7 +56,6 @@ void TDelay::setIn( int num, bool state )
     {
         if( dlog.is_info() )
             dlog.info() << this << ": set timer " << delay << " [msec]" << endl;
-
         pt.setTiming(delay);
     }
 }

extensions/LogicProcessor/TOR.cc

@@ -62,7 +62,6 @@ void TOR::setIn( int num, bool state )
 
     if( dlog.is_info() )
         dlog.info() << this << ": myout " << myout << endl;
-
     if( prev != myout )
         Element::setChildOut();
 }

extensions/ModbusMaster/MBExchange.cc

@@ -2411,7 +2411,11 @@ std::ostream& operator<<( std::ostream& os, const MBExchange::RSProperty& p )
 // -----------------------------------------------------------------------------
 void MBExchange::initDeviceList()
 {
-	xmlNode* respNode = conf->findNode(cnode,"DeviceList");
+    xmlNode* respNode = 0;
+    UniXML* xml = conf->getConfXML();
+    if( xml )
+        respNode = xml->extFindNode(cnode,1,1,"DeviceList");
+
     if( respNode )
     {
         UniXML_iterator it1(respNode);
@@ -2480,7 +2484,6 @@ bool MBExchange::initDeviceInfo( RTUDeviceMap& m, ModbusRTU::ModbusAddr a, UniXM
 
     if( dlog.is_info() )
         dlog.info() << myname << "(initDeviceInfo): add addr=" << ModbusRTU::addr2str(a) << endl;
-
     int tout = it.getPIntProp("timeout",5000);
     d->second->resp_ptTimeout.setTiming(tout);
     d->second->resp_invert = it.getIntProp("invert");

extensions/ModbusMaster/MBExchange.h

@@ -325,16 +325,6 @@ class MBExchange:
         PassiveTimer ptReopen; /*!< таймер для переоткрытия соединения */
         Trigger trReopen;
 
-		// т.к. пороговые датчики не связаны напрямую с обменом, создаём для них отдельный список
-		// и отдельно его проверяем потом
-		typedef std::list<IOBase> ThresholdList;
-		ThresholdList thrlist;
-
-		int aftersend_pause;
-
-		PassiveTimer ptReopen; /*!< таймер для переоткрытия соединения */
-		Trigger trReopen;
-
      private:
         MBExchange();
 

extensions/ModbusMaster/mtr-setup.cc

@@ -363,6 +363,7 @@ int main( int argc, char **argv )
                 return 1;
         }
 
+        return 0;
     }
     catch( ModbusRTU::mbException& ex )
     {
@@ -381,7 +382,7 @@ int main( int argc, char **argv )
         cerr << "(mtr-setup): catch(...)" << endl;
     }
 
-	return 0;
+    return 1;
 }
 // --------------------------------------------------------------------------
 char* checkArg( int i, int argc, char* argv[] )

extensions/ModbusMaster/start_fg_mbtcp.sh

@@ -5,10 +5,18 @@
 --mbtcp-name MBMaster1 \
 --smemory-id SharedMemory \
 --dlog-add-levels info,crit,warn,level4,level3 \
---mbtcp-filter-field mbtcp \
---mbtcp-filter-value 1 \
+--mbtcp-set-prop-prefix \
+--mbtcp-filter-field rs \
+--mbtcp-filter-value 5 \
 --mbtcp-gateway-iaddr 127.0.0.1 \
 --mbtcp-gateway-port 2048 \
 --mbtcp-recv-timeout 5000 \
---mbtcp-force-disconnect 1
+--mbtcp-force-disconnect 1 \
+--mbtcp-polltime 3000 \
+--mbtcp-force-out 1 \
+$*
+
+#--mbtcp-exchange-mode-id MB1_Mode_AS \
 #--mbtcp-filter-field mbtcp --mbtcp-filter-value 1
+#--mbtcp-set-prop-prefix rs_ \
+

extensions/ModbusMaster/vtconv.cc

@@ -14,7 +14,7 @@ static void print_help()
 // --------------------------------------------------------------------------
 int main( int argc, const char **argv )
 {
-
+/*
     VTypes::F2 f2;
     f2.raw.val = 2.345;
 
@@ -58,8 +58,7 @@ int main( int argc, const char **argv )
     cout << "-------------" << endl << endl;
 
 //    return 0;
-
-
+*/
     unsigned short v[4];
     memset(v,0,sizeof(v));
 

extensions/ModbusSlave/MBSlave.cc

@@ -1490,7 +1490,6 @@ ModbusRTU::mbErrCode MBSlave::readInputStatus( ReadInputStatusMessage& query,
     {
          if( dlog.is_warn() )
             dlog.warn() << myname << "(readInputStatus): " << ex << endl;
-
         return ModbusRTU::erBadDataAddress;
     }
     catch( Exception& ex )

extensions/SharedMemory/SharedMemory.cc

@@ -4,6 +4,7 @@
 #include "NCRestorer.h"
 #include "SharedMemory.h"
 #include "Extensions.h"
+#include "ORepHelpers.h"
 // -----------------------------------------------------------------------------
 using namespace std;
 using namespace UniSetTypes;
@@ -55,11 +56,9 @@ SharedMemory::SharedMemory( ObjectId id, string datafile, std::string confname )
 
     // ----------------------
     buildHistoryList(cnode);
-
     signal_change_value().connect(sigc::mem_fun(*this, &SharedMemory::updateHistory));
     for( History::iterator i=hist.begin(); i!=hist.end(); ++i )
         histmap[i->fuse_id].push_back(i);
-
     // ----------------------
     restorer = NULL;
     NCRestorer_XML* rxml = new NCRestorer_XML(datafile);
@@ -814,8 +813,7 @@ void SharedMemory::updateHistory( IOStateList::iterator& s_it, IOController* )
         else if( s_it->second.type == UniversalIO::AI ||
                  s_it->second.type == UniversalIO::AO )
         {
-			if( sm->sensor_type == UniversalIO::DigitalInput ||
-				sm->sensor_type == UniversalIO::DigitalOutput )
+            if( !it->fuse_use_val )
             {
                 bool st = (bool)value;
 
@@ -832,8 +830,7 @@ void SharedMemory::updateHistory( IOStateList::iterator& s_it, IOController* )
                     m_historySignal.emit( &(*it) );
                 }
             }
-			else if( sm->sensor_type == UniversalIO::AnalogInput ||
-					 sm->sensor_type == UniversalIO::AnalogOutput )
+            else
             {
                 if( value == it->fuse_val )
                 {

extensions/SharedMemory/SharedMemory.h

@@ -432,8 +432,6 @@ class SharedMemory:
         IOController_i::SensorInfo siPulsar;
         int msecPulsar;
 
-		UniSetTypes::uniset_mutex act_mutex;
-
         UniSetTypes::uniset_rwmutex mutex_act;
 
     private:

extensions/UNetUDP/UNetExchange.cc

@@ -123,7 +123,6 @@ sender2(0)
 
             if( dlog.is_info() )
                 dlog.info() << myname << "(init): init sender.. my node " << n_it.getProp("name") << endl;
-
             sender = new UNetSender(h,p,shm,s_field,s_fvalue,ic);
             sender->setSendPause(sendpause);
 
@@ -254,7 +253,6 @@ sender2(0)
         if( dlog.is_info() )
             dlog.info() << myname << "(init): (node='" << n << "') add receiver "
                         << h2 << ":" << p2 << endl;
-
         UNetReceiver* r = new UNetReceiver(h,p,shm);
 
         // на всякий принудительно разблокируем,
@@ -627,7 +625,6 @@ void UNetExchange::askSensors( UniversalIO::UIOCommand cmd )
 
         if( dlog.is_crit() )
             dlog.crit() << err.str() << endl;
-
         kill(SIGTERM,getpid());    // прерываем (перезапускаем) процесс...
         throw SystemError(err.str());
     }

extensions/include/Extensions.h

@@ -13,6 +13,9 @@ namespace UniSetExtensions
     /*! Получение идентификатора объекта(процесса) разделяемой памяти */
     UniSetTypes::ObjectId getSharedMemoryID();
 
+    /*! Получение времени для подтверждения "живости" */
+    int getHeartBeatTime();
+
     xmlNode* findNode( xmlNode* node, const std::string& snode, const std::string& field );
 
     xmlNode* getCalibrationsSection();

extensions/include/IOBase.h

-// $Id: IOBase.h,v 1.3 2009/01/23 23:56:54 vpashka Exp $
 // -----------------------------------------------------------------------------
 #ifndef IOBase_H_
 #define IOBase_H_

extensions/include/MTR.h

 // --------------------------------------------------------------------------
-//!  \version $Id: MTR.h,v 1.1 2008/12/14 21:57:50 vpashka Exp $
 // --------------------------------------------------------------------------
 #ifndef _MTR_H_
 #define _MTR_H_
@@ -665,12 +664,13 @@ namespace MTR
             T_Str16():sval(""){}
             T_Str16( const ModbusRTU::ReadInputRetMessage& ret )
             {
-				char c[16];
+                char c[17];
                 ModbusRTU::ModbusData data[8];
                 for( int i=0; i<8; i++ )
                     data[i] = ModbusRTU::SWAPSHORT(ret.data[i]);
 
-				memcpy(c,&data,sizeof(c));
+                memcpy(c,&data,16);
+                c[16] = '\0';
                 sval = std::string(c);
             }
 
@@ -694,11 +694,12 @@ namespace MTR
             T_Str8():sval(""){}
             T_Str8( const ModbusRTU::ReadInputRetMessage& ret )
             {
-				char c[8];
+                char c[9];
                 ModbusRTU::ModbusData data[4];
                 for( int i=0; i<4; i++ )
                     data[i] = ModbusRTU::SWAPSHORT(ret.data[i]);
-				memcpy(c,&data,sizeof(c));
+                memcpy(c,&data,8);
+                c[8] = '\0';
                 sval = std::string(c);
             }
 

extensions/include/SMInterface.h

@@ -58,7 +58,7 @@ class SMInterface
         CORBA::Object_var oref;
         UniSetTypes::ObjectId shmID;
         UniSetTypes::ObjectId myid;
-		UniSetTypes::uniset_mutex shmMutex;
+        UniSetTypes::uniset_rwmutex shmMutex;
 };
 
 //--------------------------------------------------------------------------

extensions/include/UObject_SK.h

+
 // --------------------------------------------------------------------------
 /*
  DO NOT EDIT THIS FILE. IT IS AUTOGENERATED FILE.
@@ -12,19 +13,19 @@
 #ifndef UObject_SK_H_
 #define UObject_SK_H_
 // -----------------------------------------------------------------------------
+#include <string>
 #include "UniSetObject.h"
 #include "LT_Object.h"
 #include "UniXML.h"
 #include "Trigger.h"
-#include "SMInterface.h"
+#include "DebugStream.h"
 // -----------------------------------------------------------------------------
 class UObject_SK:
     public UniSetObject,
     public LT_Object
 {
     public:
-		UObject_SK( UniSetTypes::ObjectId id, xmlNode* node=UniSetTypes::conf->getNode("UObject"),
-					 UniSetTypes::ObjectId shmID = UniSetTypes::DefaultObjectId );
+        UObject_SK( UniSetTypes::ObjectId id, xmlNode* node=UniSetTypes::conf->getNode("UObject"), const std::string& argprefix="" );
         UObject_SK();
         virtual ~UObject_SK();
 
@@ -39,27 +40,45 @@ class UObject_SK:
         DebugStream dlog;
         void init_dlog(DebugStream& dlog);
 
-		void updateValues();
-		void setInfo( UniSetTypes::ObjectId code, bool state );		
+
+        // Используемые идентификаторы
+
+
+        // Используемые идентификаторы сообщений
+
+
+        // Текущее значение и предыдущее значение
+
+
+        // --- public variables ---
+
+
+        // --- end of public variables ---
 
     protected:
+        // --- protected variables ---
+
+
+        // ---- end of protected variables ----
+
 
         virtual void callback();
         virtual void processingMessage( UniSetTypes::VoidMessage* msg );
         virtual void sysCommand( UniSetTypes::SystemMessage* sm );
-		virtual void askSensors( UniversalIO::UIOCommand cmd );
-		virtual void sensorInfo( UniSetTypes::SensorMessage* sm ){};
-		virtual void timerInfo( UniSetTypes::TimerMessage* tm ){};
+        virtual void askSensors( UniversalIO::UIOCommand cmd ){}
+        virtual void sensorInfo( UniSetTypes::SensorMessage* sm ){}
+        virtual void timerInfo( UniSetTypes::TimerMessage* tm ){}
         virtual void sigterm( int signo );
         virtual bool activateObject();
         virtual void testMode( bool state );
         void updatePreviousValues();
         void checkSensors();
         void updateOutputs( bool force );
-		bool checkTestMode();
+
+        void preAskSensors( UniversalIO::UIOCommand cmd );
         void preSensorInfo( UniSetTypes::SensorMessage* sm );
         void preTimerInfo( UniSetTypes::TimerMessage* tm );
-		void waitSM( int wait_msec );
+        void waitSM( int wait_msec, UniSetTypes::ObjectId testID = UniSetTypes::DefaultObjectId );
 
         void resetMsg();
         Trigger trResetMsg;
@@ -71,24 +90,37 @@ class UObject_SK:
 
         int sleep_msec; /*!< пауза между итерациями */
         bool active;
-		bool isTestMode;
-		Trigger trTestMode;
-		UniSetTypes::ObjectId idTestMode_S;		  	/*!< идентификатор для флага тестовго режима (для всех) */
-		UniSetTypes::ObjectId idLocalTestMode_S;	/*!< идентификатор для флага тестовго режима (для данного узла) */
-		bool in_TestMode_S;
-		bool in_LocalTestMode_S;
+
+        UniSetTypes::ObjectId smTestID; /*!< идентификатор датчика для тестирования готовности SM */
+
+        // управление датчиком "сердцебиения"
+        PassiveTimer ptHeartBeat;                /*! < период "сердцебиения" */
+        UniSetTypes::ObjectId idHeartBeat;        /*! < идентификатор датчика (AI) "сердцебиения" */
+        int maxHeartBeat;                        /*! < сохраняемое значение */
 
         xmlNode* confnode;
-		SMInterface shm;
+        /*! получить числовое свойство из конф. файла по привязанной confnode */
+        int getIntProp(const std::string& name) { return UniSetTypes::conf->getIntProp(confnode, name); }
+        /*! получить текстовое свойство из конф. файла по привязанной confnode */
+        inline const std::string getProp(const std::string& name) { return UniSetTypes::conf->getProp(confnode, name); }
+
         int smReadyTimeout;     /*!< время ожидания готовности SM */
         bool activated;
         int activateTimeout;    /*!< время ожидания готовности UniSetObject к работе */
         PassiveTimer ptStartUpTimeout;    /*!< время на блокировку обработки WatchDog, если недавно был StartUp */
+        int askPause; /*!< пауза между неудачными попытками заказать датчики */
+
+        IOController_i::SensorInfo si;
 
 
     private:
 
-		IOController_i::SensorInfo si;
+        // --- private variables ---
+        // --- end of private variables ---
+
+
+
+        bool end_private; // вспомогательное поле (для внутреннего использования при генерировании кода)
 };
 
 // -----------------------------------------------------------------------------

extensions/include/VTypes.h

@@ -16,15 +16,12 @@ namespace VTypes
         {
             vtUnknown,
             vtF2,        /*!< двойное слово float(4 байта). В виде строки задаётся как \b "F2". */
-			vtF2r,		/*!< двойное слово float(4 байта). С перевёрнутой (reverse) последовательностью слов. \b "F2r". */
             vtF4,        /*!< 8-х байтовое слово (double). В виде строки задаётся как \b "F4". */
             vtByte,        /*!< байт.  В виде строки задаётся как \b "byte". */
             vtUnsigned,    /*!< беззнаковое целое (2 байта).  В виде строки задаётся как \b "unsigned". */
             vtSigned,    /*!< знаковое целое (2 байта). В виде строки задаётся как \b "signed". */
             vtI2,        /*!< целое (4 байта). В виде строки задаётся как \b "I2".*/
-			vtI2r,		/*!< целое (4 байта). С перевёрнутой (reverse) последовательностью слов. В виде строки задаётся как \b "I2r".*/
-			vtU2,		/*!< беззнаковое целое (4 байта). В виде строки задаётся как \b "U2".*/
-			vtU2r		/*!< беззнаковое целое (4 байта). С перевёрнутой (reverse) последовательностью слов. В виде строки задаётся как \b "U2r".*/
+            vtU2        /*!< беззнаковое целое (4 байта). В виде строки задаётся как \b "U2".*/
         };
 
         std::ostream& operator<<( std::ostream& os, const VType& vt );
@@ -70,24 +67,6 @@ namespace VTypes
             F2mem raw;
     };
     // --------------------------------------------------------------------------
-	class F2r:
-		public F2
-	{
-		public:
-		
-			// ------------------------------------------
-			// конструкторы на разные случаи...
-			F2r(){}
-			
-			F2r( float f ):F2(f){}
-			F2r( const ModbusRTU::ModbusData* data, int size ):F2(data,size)
-			{
-				std::swap(raw.v[0],raw.v[1]);
-			}
-
-			~F2r(){}
-	};
-	// --------------------------------------------------------------------------
     class F4
     {
         public:
@@ -260,21 +239,6 @@ namespace VTypes
             I2mem raw;
     };
     // --------------------------------------------------------------------------
-	class I2r:
-		public I2
-	{
-		public:
-			I2r(){}
-			
-			I2r( int v ):I2(v){}
-			I2r( const ModbusRTU::ModbusData* data, int size ):I2(data,size)
-			{
-				std::swap(raw.v[0],raw.v[1]);
-			}
-
-			~I2r(){}
-	};
-	// --------------------------------------------------------------------------
     class U2
     {
         public:
@@ -310,21 +274,6 @@ namespace VTypes
             U2mem raw;
     };
     // --------------------------------------------------------------------------
-	class U2r:
-		public U2
-	{
-		public:
-			U2r(){}
-			
-			U2r( int v ):U2(v){}
-			U2r( const ModbusRTU::ModbusData* data, int size ):U2(data,size)
-			{
-				std::swap(raw.v[0],raw.v[1]);
-			}
-
-			~U2r(){}
-	};
-	// --------------------------------------------------------------------------
 
 } // end of namespace VTypes
 // --------------------------------------------------------------------------

extensions/lib/MTR.cc

@@ -432,25 +432,11 @@ bool send_param( ModbusRTUMaster* mb, DataMap& dmap, ModbusRTU::ModbusAddr addr,
 //            return false;
     }
 
-  try
-  {
-    ModbusRTU::ModbusData dat = 1;
-    ModbusRTU::WriteSingleOutputRetMessage ret = mb->write06( addr, regUpdateConfiguration, dat);
-    if( ret.start == regUpdateConfiguration && ret.data == dat )
-    {
+    ModbusRTU::WriteSingleOutputRetMessage ret = mb->write06(addr,regUpdateConfiguration,1);
     if( verb )
       cout << "(mtr-setup): save parameters " << endl;
-      return true;
-    }
-  }
-  catch(  ModbusRTU::mbException& ex )
-  {
-  }
-
-  if( verb )
-    cout << "(mtr-setup): not save parameters " << endl;
 
-	return false;
+    return true;
 }
 // ------------------------------------------------------------------------------------------
 MTR::MTRError update_configuration( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr slaveaddr,
@@ -568,76 +554,5 @@ std::ostream& operator<<(std::ostream& os, MTR::T_Str16& t )
     return os << t.sval;
 }
 // ------------------------------------------------------------------------------------------
-std::ostream& operator<<(std::ostream& os, MTR::T1& t )
-{
-	return os << t.val;
-}
-std::ostream& operator<<(std::ostream& os, MTR::T2& t )
-{
-	return os << t.val;
-}
-std::ostream& operator<<(std::ostream& os, MTR::T3& t )
-{
-	return os << (long)(t);
-}
-std::ostream& operator<<(std::ostream& os, MTR::T4& t )
-{
-	return os << t.sval;
-}
-std::ostream& operator<<(std::ostream& os, MTR::T5& t )
-{
-	return os << t.raw.u2.val << " * 10^" << (int)t.raw.u2.exp
-			<< " [" << t.val << "]";
-}
-std::ostream& operator<<(std::ostream& os, MTR::T6& t )
-{
-	return os << t.raw.u2.val << " * 10^" << (int)t.raw.u2.exp
-			<< " [" << t.val << "]";
-}
-std::ostream& operator<<(std::ostream& os, MTR::T7& t )
-{
-	return os << t.val
-			<< " [" << ( t.raw.u2.ic == 0xFF ? "CAP" : "IND" ) << "|"
-			<< ( t.raw.u2.ie == 0xFF ? "EXP" : "IMP" ) << "]";
-}
-std::ostream& operator<<(std::ostream& os, MTR::T8& t )
-{
-	return os << setfill('0') << hex
-			<< setw(2) << t.hour() << ":" << setw(2) << t.min()
-			<< " " << setw(2) << t.day() << "/" << setw(2) << t.mon();
-}
-std::ostream& operator<<(std::ostream& os, MTR::T9& t )
-{
-	return os << setfill('0') << hex
-			<< setw(2) << t.hour() << ":" << setw(2) << t.min()
-			<< ":" << setw(2) << t.sec() << "." << setw(2) << t.ssec();
-}
-std::ostream& operator<<(std::ostream& os, MTR::T10& t )
-{
-	return os << setfill('0') << dec
-			<< setw(4) << t.year() << "/" << setw(2) << t.mon()
-			<< "/" << setw(2) << t.day();
-}
-std::ostream& operator<<(std::ostream& os, MTR::T16& t )
-{
-	return os << t.fval;
-}
-std::ostream& operator<<(std::ostream& os, MTR::T17& t )
-{
-	return os << t.fval;
-}
-std::ostream& operator<<(std::ostream& os, MTR::F1& t )
-{
-	return os << t.raw.val;
-}
-std::ostream& operator<<(std::ostream& os, MTR::T_Str8& t )
-{
-	return os << t.sval;
-}
-std::ostream& operator<<(std::ostream& os, MTR::T_Str16& t )
-{
-	return os << t.sval;
-}
-// ------------------------------------------------------------------------------------------
 } // end of namespace MTR
 // -----------------------------------------------------------------------------

extensions/lib/UObject_SK.cc

@@ -188,9 +188,10 @@ bool UObject_SK::alarm( UniSetTypes::ObjectId _code, bool _state )
         ulog.level1(false) << endl;
     }
 
+
+
     if( ulog.is_level1() )
         ulog.level1() << " not found MessgeOID?!!" << endl;
-
     return false;
 }
 // -----------------------------------------------------------------------------

extensions/lib/VTypes.cc

@@ -18,8 +18,6 @@ VType str2type( const std::string& s )
         return vtByte;
     if( s == "F2" || s == "f2" )
         return vtF2;
-	if( s == "F2r" || s == "f2r" )
-		return vtF2r;
     if( s == "F4" || s == "f4" )
         return vtF4;
     if( s == "Unsigned" || s == "unsigned" )
@@ -28,12 +26,8 @@ VType str2type( const std::string& s )
         return vtSigned;
     if( s == "I2" || s == "i2" )
         return vtI2;
-	if( s == "I2r" || s == "i2r" )
-		return vtI2r;
     if( s == "U2" || s == "u2" )
         return vtU2;
-	if( s == "U2r" || s == "u2r" )
-		return vtU2r;
 
     return vtUnknown;
 }
@@ -44,8 +38,6 @@ string type2str( VType t )
         return "Byte";
     if( t == vtF2 )
         return "F2";
-	if( t == vtF2r )
-		return "F2r";
     if( t == vtF4 )
         return "F4";
     if( t == vtUnsigned )
@@ -54,12 +46,8 @@ string type2str( VType t )
         return "Signed";
     if( t == vtI2 )
         return "I2";
-	if( t == vtI2r )
-		return "I2r";
     if( t == vtU2 )
         return "U2";
-	if( t == vtU2r )
-		return "U2r";
 
     return "vtUnknown";
 }
@@ -68,7 +56,7 @@ int wsize(  VType t )
 {
     if( t == vtByte )
         return Byte::wsize();
-	if( t == vtF2 || t == vtF2r )
+    if( t == vtF2 )
         return F2::wsize();
     if( t == vtF4 )
         return F4::wsize();
@@ -76,9 +64,9 @@ int wsize(  VType t )
         return Unsigned::wsize();
     if( t == vtSigned )
         return Signed::wsize();
-	if( t == vtI2 || t == vtI2r )
+    if( t == vtI2 )
         return I2::wsize();
-	if( t == vtU2 || t == vtU2r )
+    if( t == vtU2 )
         return U2::wsize();
 
     return 1;

extensions/tests/SMemoryTest/TestProc.cc

+#include <iomanip>
+#include "Exceptions.h"
+#include "TestProc.h"
+// -----------------------------------------------------------------------------
+using namespace std;
+using namespace UniSetTypes;
+// -----------------------------------------------------------------------------
+TestProc::TestProc( UniSetTypes::ObjectId id, xmlNode* confnode ):
+    TestProc_SK( id, confnode ),
+    state(false)
+{
+    loglevels.push_back(Debug::INFO);
+    loglevels.push_back(Debug::WARN);
+    loglevels.push_back(Debug::CRIT);
+    loglevels.push_back(Debug::LEVEL1);
+    loglevels.push_back(Debug::LEVEL2);
+    loglevels.push_back( Debug::type(Debug::LEVEL2 | Debug::INFO) );
+    loglevels.push_back( Debug::type(Debug::LEVEL2 | Debug::INFO | Debug::WARN | Debug::CRIT) );
+
+    lit = loglevels.begin();
+    out_log_c = (*lit);
+}
+// -----------------------------------------------------------------------------
+TestProc::~TestProc()
+{
+}
+// -----------------------------------------------------------------------------
+TestProc::TestProc():
+    state(false)
+{
+    cerr << ": init failed!!!!!!!!!!!!!!!"<< endl;
+    throw Exception();
+}
+// -----------------------------------------------------------------------------
+void TestProc::step()
+{
+}
+// -----------------------------------------------------------------------------
+void TestProc::sysCommand( UniSetTypes::SystemMessage* sm )
+{
+    TestProc_SK::sysCommand(sm);
+    if( sm->command == SystemMessage::StartUp || sm->command == SystemMessage::WatchDog )
+    {
+        askTimer(tmCheck,checkTime);
+        askTimer(tmCheckWorking,checkWorkingTime);
+        askTimer(tmLogControl,checkLogTime);
+
+        // В начальный момент времени блокирующий датчик =0, поэтому d2_check_s должен быть равен depend_off_value (-50).
+       cerr << myname << "(startup): check init depend: " << ( getValue(d2_check_s) == -50 ? "OK" : "FAIL" ) << endl;
+    }
+}
+// -----------------------------------------------------------------------------
+void TestProc::sensorInfo( SensorMessage *sm )
+{
+/*
+    dlog.level2() << myname << "(sensorInfo): id=" << sm->id << " val=" << sm->value
+            << "  " << timeToString(sm->sm_tv_sec,":")
+            << "(" << setw(6) << sm->sm_tv_usec << "): "
+            << endl;
+*/
+    if( sm->id == on_s )
+    {
+        if( sm->value )
+        {
+            cerr << myname << "(sensorInfo): START WORKING.." << endl;
+            askTimer(tmChange,changeTime);
+        }
+        else
+        {
+            askTimer(tmChange,0);
+            cerr << myname << "(sensorInfo): STOP WORKING.." << endl;
+        }
+    }
+    else if( sm->id == check_undef_s )
+    {
+        cerr << myname << "(sensorInfo): CHECK UNDEFINED STATE ==> " << (sm->undefined==undef ? "OK" : "FAIL") << endl;
+    }
+}
+// -----------------------------------------------------------------------------
+void TestProc::timerInfo( TimerMessage *tm )
+{
+    if( tm->id == tmChange )
+    {
+        state^=true;
+        out_lamp_c = ( state ? lmpBLINK : lmpOFF );
+        dlog.level2() << myname << ": state=" << state << " lmp=" << out_lamp_c << endl;
+        askTimer(tmCheckWorking,checkTime); // reset timer
+    }
+    else if( tm->id == tmCheckWorking )
+       cerr << myname << ": WORKING FAIL!" << endl;
+    else if( tm->id == tmCheck )
+    {
+        cerr << endl << endl << "--------" << endl;
+        test_depend();
+        test_undefined_state();
+        test_thresholds();
+        test_loglevel();
+    }
+    else if( tm->id == tmLogControl )
+    {
+        cerr << endl;
+        cerr << "======= TEST LOG PRINT ======" << endl;
+        cerr << "LOGLEVEL: [" << (int)(*lit) << "] " << (*lit) << endl;
+        for( std::vector<Debug::type>::iterator it=loglevels.begin(); it!=loglevels.end(); ++it )
+            dlog[*it] << myname << ": test log print..." << endl;
+
+        cerr << "======= END LOG PRINT ======" << endl;
+    }
+}
+// -----------------------------------------------------------------------------
+void TestProc::test_depend()
+{
+    cerr << myname << ": Check depend..." << endl;
+
+    long test_val = 100;
+
+    // set depend 0...
+    setValue(depend_c,0);
+    setValue(set_d1_check_s,test_val);
+    setValue(set_d2_check_s,test_val);
+    cerr << myname << ": check depend OFF: d1: " << ( getValue(d1_check_s) == 0 ? "OK" : "FAIL" ) << endl;
+    cerr << myname << ": check depend OFF: d2: " << ( getValue(d2_check_s) == -50 ? "OK" : "FAIL" ) << endl;
+
+    // set depend 1
+    setValue(depend_c,1);
+    cerr << myname << ": check depend ON: d1: " << ( getValue(d1_check_s) == test_val ? "OK" : "FAIL" ) << endl;
+    cerr << myname << ": check depend ON: d2: " << ( getValue(d2_check_s) == test_val ? "OK" : "FAIL" ) << endl;
+}
+// -----------------------------------------------------------------------------
+void TestProc::test_undefined_state()
+{
+    // ---------------- Проверка выставления неопределённого состояния ---------------------
+    cerr << myname << ": Check undef state..." << endl;
+    undef ^= true;
+
+    si.id = undef_c;
+    si.node = conf->getLocalNode();
+    cerr << myname << ": set undefined=" << undef << endl;
+    ui.setUndefinedState( si, undef, getId() );
+}
+// -----------------------------------------------------------------------------
+void TestProc::test_thresholds()
+{
+    // ---------------- Проверка работы порогов ---------------------
+    cerr << myname << ": Check thresholds..." << endl;
+
+    setValue(t_set_c,0);
+    cerr << myname << ": check threshold OFF value: " << ( getValue(t_check_s) == 0 ? "OK" : "FAIL" ) << endl;
+
+    setValue(t_set_c,378);
+    cerr << myname << ": check threshold ON value: " << ( getValue(t_check_s) == 1 ? "OK" : "FAIL" ) << endl;
+
+    cerr << myname << ": ask threshold and check.. " << endl;
+
+    try
+    {
+        setValue(t_set_c, 0);
+        UniSetTypes::ThresholdId tid = 100;
+        ui.askThreshold( t_set_c, tid, UniversalIO::UIONotify, 10, 20 );
+
+        IONotifyController_i::ThresholdInfo ti = ui.getThresholdInfo(t_set_c,tid);
+        cerr << myname << ": ask OFF threshold: " << ( ti.state == IONotifyController_i::NormalThreshold  ? "OK" : "FAIL" ) << endl;
+        setValue(t_set_c, 25);
+        ti = ui.getThresholdInfo(t_set_c,tid);
+        cerr << myname << ": ask ON threshold: " << ( ti.state == IONotifyController_i::HiThreshold  ? "OK" : "FAIL" ) << endl;
+    }
+    catch( Exception& ex )
+    {
+        dlog.level2() << myname << ": CHECK 'ask and get threshold' FAILED: " << ex << endl;
+    }
+}
+// -----------------------------------------------------------------------------
+void TestProc::test_loglevel()
+{
+    lit++;
+    if( lit == loglevels.end() )
+        lit = loglevels.begin();
+
+    cerr << "SET LOGLEVEL: [" << (int)(*lit) << "] " << (*lit) << endl;
+    setValue(log_c, (*lit));
+    askTimer(tmLogControl,checkLogTime);
+}
+// -----------------------------------------------------------------------------

extensions/tests/SMemoryTest/TestProc.h

+// -----------------------------------------------------------------------------
+#ifndef TestProc_H_
+#define TestProc_H_
+// -----------------------------------------------------------------------------
+#include <vector>
+#include "Debug.h"
+#include "TestProc_SK.h"
+// -----------------------------------------------------------------------------
+class TestProc:
+    public TestProc_SK
+{
+    public:
+        TestProc( UniSetTypes::ObjectId id, xmlNode* confnode = UniSetTypes::conf->getNode("TestProc") );
+        virtual ~TestProc();
+
+    protected:
+        TestProc();
+
+        enum Timers
+        {
+            tmChange,
+            tmCheckWorking,
+            tmCheck,
+            tmLogControl
+        };
+
+        virtual void step();
+        virtual void sensorInfo( UniSetTypes::SensorMessage *sm );
+        virtual void timerInfo( UniSetTypes::TimerMessage *tm );
+        virtual void sysCommand( UniSetTypes::SystemMessage* sm );
+
+        void test_depend();
+        void test_undefined_state();
+        void test_thresholds();
+        void test_loglevel();
+
+    private:
+        bool state;
+        bool undef;
+
+        std::vector<Debug::type> loglevels;
+        std::vector<Debug::type>::iterator lit;
+};
+// -----------------------------------------------------------------------------
+#endif // TestProc_H_
+// -----------------------------------------------------------------------------

extensions/tests/SMemoryTest/stop.sh

+../../../Utilities/scripts/uniset-stop.sh
\ No newline at end of file

extensions/tests/SMemoryTest/uniset-functions.sh

+../../../Utilities/scripts/uniset-functions.sh
\ No newline at end of file

extensions/tests/SMemoryTest/uniset-start.sh

+../../../Utilities/scripts/uniset-start.sh
\ No newline at end of file

include/ComPort.h

@@ -82,9 +82,9 @@ public:
     void setCharacterSize(CharacterSize);
     void setStopBits(StopBits sBit);
 
-	virtual void setTimeout( int msec );
-	inline int getTimeout(){ return uTimeout/1000; } // msec
-	void setWaiting( bool waiting );
+    virtual void setTimeout(int timeout);
+    void setWaiting(bool waiting);
+    inline int getTimeout(){ return uTimeout*1000; } // msec
 
     virtual unsigned char receiveByte();
     virtual void sendByte(unsigned char x);
@@ -97,8 +97,6 @@ public:
     virtual void cleanupChannel();
     virtual void reopen();
 
-	virtual void reopen();
-
 protected:
     void openPort();
 

include/DelayTimer.h

@@ -34,7 +34,6 @@ class DelayTimer
                 onDelay(0),offDelay(0),waiting_on(false),waiting_off(false){}
 
         DelayTimer( timeout_t on_msec, timeout_t off_msec ):prevState(false),state(false),
-
                 onDelay(on_msec),offDelay(off_msec),waiting_on(false),waiting_off(false)
         {
         }
@@ -45,33 +44,25 @@ class DelayTimer
         {
             onDelay = on_msec;
             offDelay = off_msec;
-			waiting_on = false;
-			waiting_off = false;
-			state = false;
         }
 
         // запустить часы (заново)
         inline void reset()
         {
             pt.reset();
-			waiting_on = false;
-			waiting_off = false;
-			state = false;
         }
 
         inline bool check( bool st )
         {
             if( waiting_off )
             {
-				if( pt.checkTime() )
+                if( !st && pt.checkTime() )
                 {
                     waiting_off = false;
-					if( !st )
                     state = false;
-
                     return state;
                 }
-				else if( st != prevState && !st )
+                else if( st != prevState )
                     pt.reset();
 
                 prevState = st;
@@ -80,16 +71,13 @@ class DelayTimer
 
             if( waiting_on )
             {
-				if( pt.checkTime() )
+                if( st && pt.checkTime() )
                 {
                     waiting_on = false;
-					if( st )
                     state = true;
-					else
-
                     return state;
                 }
-				else if( st != prevState && st )
+                else if( st != prevState )
                     pt.reset();
 
                 prevState = st;

include/MessageType.h

@@ -81,6 +81,10 @@ namespace UniSetTypes
     class VoidMessage : public Message
     {
         public:
+           // для оптимизации, делаем конструктор который не будет инициализировать свойства класса
+           // это необходимо для VoidMessage, который конструируется при помощи memcpy
+            VoidMessage( int dummy ):Message(dummy){}
+
             VoidMessage( const TransportMessage& tm );
             VoidMessage();
             inline bool operator < ( const VoidMessage& msg ) const

include/NCRestorer.h

@@ -175,7 +175,7 @@ class NCRestorer_XML:
         std::string t_filterValue;
 
         std::string fname;
-		UniXML uxml;
+        UniXML* uxml;
         ReaderSlot rtslot;
         NCReaderSlot ncrslot;
 

include/PassiveTimer.h

@@ -84,6 +84,7 @@ class PassiveTimer:
 public:
     PassiveTimer();
     PassiveTimer( timeout_t timeMS );             /*!< установить таймер */
+    ~PassiveTimer();
 
 
     virtual bool checkTime();                /*!< проверка наступления заданного времени */

include/RepositoryAgent.h

@@ -18,44 +18,47 @@
  */
 // --------------------------------------------------------------------------
 /*! \file
- * \brief Реализация RepositoryAgent
  * \author Pavel Vainerman
 */
 // -------------------------------------------------------------------------- 
-#ifndef RepositoryAgent_H_
-#define RepositoryAgent_H_
+#ifndef ProxyManager_H_
+#define ProxyManager_H_
 //---------------------------------------------------------------------------
-#include "RepositoryAgent_i.hh"
-#include "BaseProcess_i.hh"
-#include "BaseProcess.h"
-#include "UniSetTypes.h"
-#include "ObjectIndex.h"
-//----------------------------------------------------------------------------------------
-/*! \class RepositoryAgent
-*/
-class RepositoryAgent:
-		public POA_RepositoryAgent_i,
-		public BaseProcess
-{
-	public:
+#include <map>
+#include "UniSetObject.h"
 
-		RepositoryAgent( ObjectId id, const UniSetTypes::ObjectInfo *pObjectsMap );
-		~RepositoryAgent();
+//----------------------------------------------------------------------------
+class PassiveObject;
+//----------------------------------------------------------------------------
 
+/*! \class ProxyManager
+ *    Менеджер пассивных объектов, который выступает вместо них во всех внешних связях....
+*/ 
+class ProxyManager: 
+    public UniSetObject
+{   
 
-//	  virtual void registration(const char* name, ::CORBA::Object_ptr ref);
-//	  virtual void unregistration(const char* name, ::CORBA::Object_ptr ref);
+    public:
+        ProxyManager( UniSetTypes::ObjectId id );
+        ~ProxyManager();
 
-	  virtual CORBA::Object_ptr resolve(const char* name);
-	  virtual CORBA::Object_ptr resolveid( UniSetTypes::ObjectId id);
+        void attachObject( PassiveObject* po, UniSetTypes::ObjectId id );
+        void detachObject( UniSetTypes::ObjectId id );
 
-	  virtual void execute();
+        UInterface* uin;
 
     protected:
-			RepositoryAgent();
-			ObjectIndex oind;
+        ProxyManager();
+        virtual void processingMessage( UniSetTypes::VoidMessage* msg );
+        virtual void allMessage( UniSetTypes::VoidMessage* msg );
+
+        virtual bool activateObject();
+        virtual bool disactivateObject();
 
     private:
+        typedef std::map<UniSetTypes::ObjectId, PassiveObject*> PObjectMap;
+        PObjectMap omap;
 };
-
-#endif
+//----------------------------------------------------------------------------------------
+#endif // ProxyManager
+//----------------------------------------------------------------------------------------

include/ThreadCreator.h

@@ -25,7 +25,8 @@
 #ifndef ThreadCreator_h_
 #define ThreadCreator_h_
 //----------------------------------------------------------------------------------------
-#include "PosixThread.h"
+#include <cc++/thread.h>
+#include <sys/resource.h>
 //----------------------------------------------------------------------------------------
 /*! \class ThreadCreator
  *    Шаблон для создания потоков с указанием функции вызова.
@@ -83,78 +84,119 @@
 //----------------------------------------------------------------------------------------
 template<class ThreadMaster>
 class ThreadCreator:
-	protected PosixThread
+    public ost::PosixThread
 {
     public:
 
         /*! прототип функции вызова */
         typedef void(ThreadMaster::* Action)(void);
 
-		pthread_t start();
-		pthread_t getTID(){ return PosixThread::getTID(); }
+        ThreadCreator( ThreadMaster* m, Action a );
+        ~ThreadCreator();
+
+        inline pid_t getTID(){ return pid; }
+
+        /*! \return 0 - sucess */
+        int setPriority( int prior );
 
-		inline void stop()
+        /*! \return < 0 - fail */
+        int getPriority();
+
+        void stop();
+
+        inline void setName( const std::string& name )
         {
-			PosixThread::stop();
+            ost::PosixThread::setName( name.c_str() );
         }
 
-		inline void kill( int signo )		/*!< послать сигнал signo */	
+        inline void setName( const char* name )
         {
-			PosixThread::thrkill(signo);
+            ost::PosixThread::setName( name );
         }
 
-		inline void setPriority( int priority )
+        inline void setCancel( ost::Thread::Cancel mode )
         {
-			PosixThread::setPriority(priority);
+            ost::PosixThread::setCancel(mode);
         }
 
-		inline void setPriority( int priority )
+        inline void setFinalAction( ThreadMaster* m, Action a )
         {
-			PosixThread::setPriority(priority);
+            finm = m;
+            finact = a;
         }
 
-		ThreadCreator( ThreadMaster* m, Action a );
-		~ThreadCreator();
+        inline void setInitialAction( ThreadMaster* m, Action a )
+        {
+            initm = m;
+            initact = a;
+        }
 
     protected:
-		virtual void work(); /*!< Функция выполняемая в потоке */
+        virtual void run();
+        virtual void final()
+        {
+            if( finm )
+                (finm->*finact)();
+        }
+
+        virtual void initial()
+        {
+            if( initm )
+                (initm->*initact)();
+        }
 
     private:
         ThreadCreator();
 
+        pid_t pid;
+
         ThreadMaster* m;
         Action act;
 
+        ThreadMaster* finm;
+        Action finact;
+
+        ThreadMaster* initm;
+        Action initact;
 };
 
 //----------------------------------------------------------------------------------------
 template <class ThreadMaster>
 ThreadCreator<ThreadMaster>::ThreadCreator( ThreadMaster* m, Action a ):
+    pid(-1),
     m(m),
-	act(a)
+    act(a),
+    finm(0),
+    finact(0),
+    initm(0),
+    initact(0)
 {
 }
 //----------------------------------------------------------------------------------------
 template <class ThreadMaster>
-void ThreadCreator<ThreadMaster>::work()
+void ThreadCreator<ThreadMaster>::run()
 {
+    pid = getpid();
     if(m)
         (m->*act)();
 //    PosixThread::stop()
 }
 //----------------------------------------------------------------------------------------
 template <class ThreadMaster>
-pthread_t ThreadCreator<ThreadMaster>::start()
+void ThreadCreator<ThreadMaster>::stop()
 {
-	PosixThread::start( static_cast<PosixThread*>(this) );
-	return getTID();
+    terminate();
 }
-
 //----------------------------------------------------------------------------------------
 template <class ThreadMaster>
 ThreadCreator<ThreadMaster>::ThreadCreator():
+    pid(-1),
     m(0),
-	act(0)
+    act(0),
+    finm(0),
+    finact(0),
+    initm(0),
+    initact(0)
 {
 }
 //----------------------------------------------------------------------------------------
@@ -163,4 +205,16 @@ ThreadCreator<ThreadMaster>::~ThreadCreator()
 {
 }
 //----------------------------------------------------------------------------------------
+template <class ThreadMaster>
+int ThreadCreator<ThreadMaster>::setPriority( int prior )
+{
+    return setpriority(PRIO_PROCESS, pid, prior );
+}
+//----------------------------------------------------------------------------------------
+template <class ThreadMaster>
+int ThreadCreator<ThreadMaster>::getPriority()
+{
+    return getpriority(PRIO_PROCESS, pid);
+}
+//----------------------------------------------------------------------------------------
 #endif // ThreadCreator_h_

include/modbus/ModbusClient.h

@@ -201,8 +201,6 @@ class ModbusClient
 
 
 
-
-
     private:
 };
 // -------------------------------------------------------------------------

include/modbus/ModbusRTUSlaveSlot.h

@@ -57,12 +57,6 @@ class ModbusRTUSlaveSlot:
         virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
                                                         ModbusRTU::MEIMessageRetRDI& reply );
 
-		virtual ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query,
-														ModbusRTU::DiagnosticRetMessage& reply );
-
-		virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
-														ModbusRTU::MEIMessageRetRDI& reply );
-
         virtual ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query,
                                                         ModbusRTU::JournalCommandRetMessage& reply );
 

include/modbus/ModbusServer.h

@@ -159,23 +159,6 @@ class ModbusServer
                                                         ModbusRTU::MEIMessageRetRDI& reply )=0;
 
 
-		/*! Обработка запроса на запись данных (0x08).
-			\param query - запрос
-			\param reply - ответ. Заполняется в обработчике.
-			\return Результат обработки
-		*/
-		virtual ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query,
-														ModbusRTU::DiagnosticRetMessage& reply )=0;
-
-		/*! Обработка запроса 43(0x2B).
-			\param query - запрос
-			\param reply - ответ. Заполняется в обработчике.
-			\return Результат обработки
-		*/
-		virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
-														ModbusRTU::MEIMessageRetRDI& reply )=0;
-
-
         /*! Обработка запроса по журналу (0x65)
             \param query - запрос
             \param reply - ответ. Заполняется в обработчике.

include/modbus/ModbusTCPMaster.h

@@ -6,7 +6,6 @@
 #include <cc++/socket.h>
 #include "ModbusTypes.h"
 #include "ModbusClient.h"
-#include "UTCPStream.h"
 // -------------------------------------------------------------------------
 /*!    Modbus TCP master interface */
 class ModbusTCPMaster:
@@ -43,12 +42,11 @@ class ModbusTCPMaster:
                                             ModbusRTU::ModbusMessage& reply, timeout_t timeout );
 
     private:
-		UTCPStream* tcp;
+        ost::TCPStream* tcp;
         ModbusRTU::ModbusData nTransaction;
         std::queue<unsigned char> qrecv;
         PassiveTimer ptTimeout;
         std::string iaddr;
-		int port;
         bool force_disconnect;
 };
 // -------------------------------------------------------------------------

include/modbus/TCPCheck.h

+#ifndef _TCPCheck_H_
+#define _TCPCheck_H_
+// -----------------------------------------------------------------------------
+#include <cc++/socket.h>
+#include "Mutex.h"
+#include "ThreadCreator.h"
+// -----------------------------------------------------------------------------
+/*! Вспомогательный класс для проверки связи, реализованный через создание потока,
+чтобы при проверке не было "зависания" при недоступности адреса.
+Смысл: создаётся поток, в нём происходит проверка, а в вызвавший поток приостанавливается
+на время timeout, по истечении которого созданный поток "принудительно"(в любом случае)
+уничтожается..
+*/
+class TCPCheck
+{
+    public:
+        TCPCheck();
+        ~TCPCheck();
+
+        bool check( const std::string& _ip, int _port, timeout_t tout, timeout_t sleep_msec );
+
+        /*! \param iaddr - 'ip:port' */
+        bool check( const std::string& iaddr, timeout_t tout, timeout_t sleep_msec );
+
+    protected:
+        void check_thread();
+        inline void setResult( bool res )
+        {
+            UniSetTypes::uniset_rwmutex_wrlock l(m);
+            result = res;
+        }
+
+        inline bool getResult()
+        {
+            bool res = false;
+            {
+                UniSetTypes::uniset_rwmutex_rlock l(m);
+                res = result;
+            }
+            return res;
+        }
+
+        bool result;
+        std::string iaddr;
+        int tout_msec;
+        UniSetTypes::uniset_rwmutex m;
+};
+// -----------------------------------------------------------------------------
+#endif // _TCPCheck_H_
+// -----------------------------------------------------------------------------

python/lib/pyUniSet/UModbus.h

@@ -32,9 +32,10 @@ class UModbus
 
       inline void setTimeout( int msec ){ tout_msec = msec; }
 
-	  /* Если не указывать ip и порт, будут использованы, те
-	   * чтобы были заданы в connect(). Если заданы другие ip и port,
-	   * будет сделана переподключение..
+      /*! Универсальная функция для чтения регистров.
+       * Если не указывать ip и порт, будут использованы, те
+       * чтобы были заданы в UModbus::connect(). Если заданы другие ip и port,
+       * будет сделано переподключение..
        */
       long mbread( int addr, int mbreg, int mbfunc,
                     const char* vtype, int nbit=-1,
@@ -44,6 +45,11 @@ class UModbus
       long getByte( int addr, int mbreg, int mbfunc=0x4 )throw(UException);
       bool getBit( int addr, int mbreg, int mbfunc=0x2 )throw(UException);
 
+      /*! Функция записи регистров 0x06 или 0x10 задаётся параметром \a mbfunc.
+       * Если не указывать ip и порт, будут использованы, те
+       * чтобы были заданы в UModbus::connect(). Если заданы другие ip и port,
+       * будет сделана переподключение..
+      */
       void mbwrite( int addr, int mbreg, int val, int mbfunc, const char* ip=0, int port=-1 )throw(UException);
 
     protected:

src/Communications/ComPort.cc

@@ -257,9 +257,9 @@ void ComPort::sendByte(unsigned char x)
 }
 // --------------------------------------------------------------------------------
 // Lav: убрать, переделать в receiveBlock
-void ComPort::setTimeout( int msec )
+void ComPort::setTimeout(int timeout)
 {
-	uTimeout = msec * 1000;
+    uTimeout=timeout;
 }
 // --------------------------------------------------------------------------------
 // Lav: ситуация, когда отправлено меньше запрошенного, не типична и должна

src/Communications/ComPort485F.cc

@@ -73,10 +73,10 @@ ComPort485F::ComPort485F( string dev, int gpio_num, bool tmit_ctrl ):
     }
 }
 // --------------------------------------------------------------------------------
-void ComPort485F::setTimeout( int msec )
+void ComPort485F::setTimeout(int timeout)
 {
-	tout_msec = msec;
-	ComPort::setTimeout(msec);
+    tout_msec = timeout / 1000;
+    ComPort::setTimeout(timeout);
 }
 // --------------------------------------------------------------------------------
 unsigned char ComPort485F::m_receiveByte( bool wait )

src/Communications/Modbus/ModbusRTUMaster.cc

@@ -35,7 +35,7 @@ ModbusRTUMaster::ModbusRTUMaster( const string dev, bool use485, bool tr_ctl ):
     port->setCharacterSize(ComPort::CSize8);
     port->setStopBits(ComPort::OneBit);
     port->setWaiting(true);
-	port->setTimeout(replyTimeOut_ms);
+    port->setTimeout(replyTimeOut_ms*1000);
 //    port->setBlocking(false);
 }
 // -------------------------------------------------------------------------
@@ -51,7 +51,7 @@ ModbusRTUMaster::ModbusRTUMaster( ComPort* com ):
     port->setCharacterSize(ComPort::CSize8);
     port->setStopBits(ComPort::OneBit);
     port->setWaiting(true);
-	port->setTimeout(replyTimeOut_ms);
+    port->setTimeout(replyTimeOut_ms*1000);
 //    port->setBlocking(false);
 }
 // -------------------------------------------------------------------------
@@ -116,7 +116,7 @@ int ModbusRTUMaster::getNextData( unsigned char* buf, int len )
 void ModbusRTUMaster::setChannelTimeout( timeout_t msec )
 {
     if( port )
-		port->setTimeout(msec);
+        port->setTimeout(msec*1000);
 }
 // --------------------------------------------------------------------------------
 mbErrCode ModbusRTUMaster::sendData( unsigned char* buf, int len )

src/Communications/Modbus/TCPCheck.cc

+// -----------------------------------------------------------------------------
+#include <sstream>
+#include "UniSetTypes.h"
+#include "PassiveTimer.h"
+#include "modbus/TCPCheck.h"
+// -----------------------------------------------------------------------------
+using namespace std;
+// -----------------------------------------------------------------------------
+TCPCheck::TCPCheck():
+    iaddr(""),tout_msec(0)
+{
+}
+// -----------------------------------------------------------------------------
+TCPCheck::~TCPCheck()
+{
+
+}
+// -----------------------------------------------------------------------------
+bool TCPCheck::check( const std::string& ip, int port, timeout_t tout, timeout_t sleep_msec )
+{
+    ostringstream s;
+    s << ip << ":" << port;
+    return check(s.str(), tout, sleep_msec);
+}
+// -----------------------------------------------------------------------------
+bool TCPCheck::check( const std::string& _iaddr, timeout_t tout, timeout_t sleep_msec )
+{
+    iaddr = iaddr;
+    tout_msec = tout;
+
+    setResult(false);
+    ThreadCreator<TCPCheck> t(this, &TCPCheck::check_thread);
+    t.setCancel(ost::Thread::cancelDeferred);
+    t.start();
+
+    PassiveTimer pt(tout);
+    while( !pt.checkTime() && t.isRunning() )
+        msleep(sleep_msec);
+
+    if( t.isRunning() ) // !getResult() )
+        t.stop();
+
+    return getResult();
+}
+// -----------------------------------------------------------------------------
+void TCPCheck::check_thread()
+{
+    setResult(false);
+    try
+    {
+        ost::Thread::setException(ost::Thread::throwException);
+        ost::TCPStream t(iaddr.c_str(),ost::Socket::IPV4,536,true,tout_msec);
+        setResult(true);
+        t.disconnect();
+    }
+    catch(...){}
+}
+// -----------------------------------------------------------------------------

src/Processes/IONotifyController.cc

@@ -333,7 +333,6 @@ void IONotifyController::localSetValue( IOController::IOStateList::iterator& li,
 
         if( ulog.is_info() )
             ulog.info() << err.str() << endl;
-
         throw IOController_i::NameNotFound(err.str().c_str());
     }
 
@@ -382,7 +381,6 @@ void IONotifyController::localSetValue( IOController::IOStateList::iterator& li,
         checkThreshold(li,si,true);
     }
     catch(...){}
->>>>>>> (2.0): Поменял механизм "зависимостей". Реализовал на освное сигналов(sigc), сменил формат. Теперь задаётся свойством depend='', depend_value='', depend_off_value=''
 }
 // ------------------------------------------------------------------------------------------
 /*!

src/Processes/NCRestorer_XML.cc

@@ -53,21 +53,27 @@ c_filterField(""),
 c_filterValue(""),
 t_filterField(""),
 t_filterValue(""),
-fname(fname)
+fname(fname),
+uxml(0)
 {
     init(fname);
     setItemFilter(f_field,f_value);
 }
 
 NCRestorer_XML::NCRestorer_XML():
-fname("")
+fname(""),
+uxml(0)
 {
 }
 
 // ------------------------------------------------------------------------------------------
 NCRestorer_XML::~NCRestorer_XML()
 {
-	uxml.close();
+    if( uxml)
+    {
+        uxml->close();
+        delete uxml;
+    }
 }
 // ------------------------------------------------------------------------------------------
 void NCRestorer_XML::init( const std::string& fname )
@@ -78,7 +84,10 @@ void NCRestorer_XML::init( const std::string& fname )
     */
     try
     {
-		uxml.open(fname);
+        if( fname == conf->getConfFileName() )
+            uxml = conf->getConfXML();
+        else
+            uxml = new UniXML(fname);
     }
     catch(UniSetTypes::NameNotFound& ex)
     {
@@ -175,11 +184,13 @@ void NCRestorer_XML::read( IONotifyController* ic, const string& fn )
         // оптимизация (не загружаем второй раз xml-файл)
         if( fname == conf->getConfFileName() && confxml )
             read( ic, *confxml );
+        else if( uxml && uxml->isOpen() && uxml->filename == fn )
+            read(ic,*uxml);
         else
         {
-			uxml.close();
-			uxml.open(fname);
-			read(ic,uxml);
+            uxml->close();
+            uxml->open(fname);
+            read(ic,*uxml);
         }
     }
 }

src/Various/MessageType.cc

@@ -58,7 +58,7 @@ TransportMessage Message::transport(const In &msg)
 //--------------------------------------------------------------------------------------------
 
 VoidMessage::VoidMessage( const TransportMessage& tm ):
-    Message(1) // вызываем dummy-конструктор
+    Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
 {
     assert(sizeof(VoidMessage)>=sizeof(UniSetTypes::RawDataOfTransportMessage));
     memcpy(this,&tm.data,sizeof(tm.data));
@@ -107,7 +107,8 @@ tid(UniSetTypes::DefaultThresholdId)
     sm_tv_usec         = tm.tv_usec;
 }
 
-SensorMessage::SensorMessage(const VoidMessage *msg)
+SensorMessage::SensorMessage(const VoidMessage *msg):
+    Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
 {
     memcpy(this,msg,sizeof(*this));
     assert(this->type == Message::SensorInfo);
@@ -127,14 +128,15 @@ SystemMessage::SystemMessage(Command command, Priority priority, ObjectId consum
     this->consumer = consumer;
 }
 
-SystemMessage::SystemMessage(const VoidMessage *msg)
+SystemMessage::SystemMessage(const VoidMessage *msg):
+    Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
 {
     memcpy(this,msg,sizeof(*this));
     assert(this->type == Message::SysCommand);
 }
 //--------------------------------------------------------------------------------------------
 TimerMessage::TimerMessage():
-id(UniSetTypes::DefaultTimerId)
+    id(UniSetTypes::DefaultTimerId)
 {
     type = Message::Timer;
 }
@@ -146,13 +148,15 @@ id(id)
     this->consumer = cons;
 }
 
-TimerMessage::TimerMessage(const VoidMessage *msg)
+TimerMessage::TimerMessage(const VoidMessage *msg):
+    Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
 {
     memcpy(this,msg,sizeof(*this));
     assert(this->type == Message::Timer);
 }
 //--------------------------------------------------------------------------------------------
-ConfirmMessage::ConfirmMessage( const VoidMessage *msg )
+ConfirmMessage::ConfirmMessage( const VoidMessage *msg ):
+    Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
 {
     memcpy(this,msg,sizeof(*this));
     assert(this->type == Message::Confirm);

tests/conftest.cc

@@ -51,6 +51,7 @@ int main(int argc, const char **argv)
         UniversalIO::IOType t3=conf->getIOType("Input1_S");
         cout << "**** check getIOType(name): for short name 'Input1_S': (" << t3 << ") " << ( t3 == UniversalIO::UnknownIOType ?  "FAILED" : "OK" ) << endl;
 
+
         int i1 = uni_atoi("-100");
         cout << "**** check uni_atoi: '-100' " << ( ( i1 != -100 ) ? "FAILED" : "OK" ) << endl;
 

tests/ui.cc

@@ -49,11 +49,10 @@ int main( int argc, const char **argv )
             << " value=" << inf.value
             << " last changed: " << string(t_str) << endl;
 
-
         cout << "check getValue: " << ui.getValue(id1) << endl;
-		cout << "check setValue: id='" << id1 << "' val=2" << endl;
-		ui.setValue(id1,2,DefaultObjectId);
-		cout << "OK" << endl;
+        cout << "check setValue: id='" << id1 << "' val=2 ...";
+        ui.setValue(id1,2);
+        cout << ( ui.getValue(id1) == 2 ? "OK" : "FAIL" ) << endl;
     }
     catch( Exception& ex )
     {