Merge branch 'unet2'

conf/libuniset.spec

@@ -154,6 +154,7 @@ rm -f %buildroot%_libdir/*.la
 %_bindir/%oname-smemory
 %_bindir/%oname-smviewer
 %_bindir/%oname-network
+%_bindir/%oname-unet*
 #%_bindir/%oname-smdbserver
 
 %_libdir/*Extensions.so.*
@@ -163,6 +164,7 @@ rm -f %buildroot%_libdir/*.la
 %_libdir/libUniSetRT*.so.*
 %_libdir/libUniSetShared*.so.*
 %_libdir/libUniSetNetwork*.so.*
+%_libdir/libUniSetUNet2*.so.*
 #%_libdir/libUniSetSMDBServer*.so.*
 
 %files extensions-devel
@@ -182,6 +184,7 @@ rm -f %buildroot%_libdir/*.la
 %_pkgconfigdir/libUniSetRT*.pc
 %_pkgconfigdir/libUniSetShared*.pc
 %_pkgconfigdir/libUniSetNetwork*.pc
+%_pkgconfigdir/libUniSetUNet*.pc
 #%_pkgconfigdir/libUniSetSMDBServer.pc
 #%_pkgconfigdir/libUniSet*.pc
 %exclude %_pkgconfigdir/libUniSet.pc

conf/test.xml

@@ -70,6 +70,7 @@
 	</RTUExchange>
 	<UDPExchange name="UDPExchange"/>
 	<UDPExchange2 name="UDPExchange2"/>
+	<UNetExchange name="UNetExchange"/>
 	<HeartBeatTime time_msec="5000"/>
 	<ObjectsMap idfromfile="0">
 		<!--
@@ -81,15 +82,15 @@
 	textname 	- текстовое имя датчика
 -->
 		<nodes port="2809">
-			<item infserver="InfoServer" ip="127.0.0.1" name="LocalhostNode" textname="Локальный узел" udp_port="3000">
+			<item infserver="InfoServer" ip="127.0.0.1" name="LocalhostNode" textname="Локальный узел" unet_ignore="1" unet_port="3000" unet_ip="192.168.56.255">
 				<iocards>
 					<item card="1" name="DI32"/>
 					<item card="2" name="DO32"/>
 					<item baddr="0x110" card="3" dev="/dev/comedi1" name="UNIO48" subdev1="TBI24_0" subdev2="TBI16_8"/>
 				</iocards>
 			</item>
-			<item ip="192.168.56.10" name="Node1" textname="Node1" udp_port="3001"/>
-			<item ip="192.168.56.11" name="Node2" textname="Node2" udp_port="3002"/>
+			<item ip="192.168.56.10" name="Node1" textname="Node1" unet_port="3001" unet_ip="192.168.56.255"/>
+			<item ip="192.168.56.11" name="Node2" textname="Node2" unet_port="3002" unet_ip="192.168.56.255"/>
 		</nodes>
 		<!-- ************************ Датчики ********************** -->
 		<sensors name="Sensors">
@@ -162,6 +163,7 @@
 			<item name="MBMaster1"/>
 			<item name="UDPExchange"/>
 			<item name="UDPExchange2"/>
+			<item name="UNetExchange"/>
 		</objects>
 	</ObjectsMap>
 	<messages idfromfile="1" name="messages">

configure.ac

@@ -181,6 +181,8 @@ AC_CONFIG_FILES([Makefile
 				 extensions/RTUExchange/libUniSetRTU.pc
 				 extensions/UDPExchange/Makefile
 				 extensions/UDPExchange/libUniSetUDP.pc
+				 extensions/UNet2/Makefile
+				 extensions/UNet2/libUniSetUNet2.pc
 				 extensions/ModbusSlave/Makefile
 				 extensions/ModbusSlave/libUniSetMBSlave.pc
 				 extensions/MBTCPMaster/Makefile

extensions/Makefile.am

@@ -4,7 +4,7 @@
 
 if HAVE_EXTENTIONS
 SUBDIRS = lib include SharedMemory IOControl RTUExchange LogicProcessor \
-	ModbusSlave MBTCPMaster SMViewer UniNetwork
+	ModbusSlave MBTCPMaster SMViewer UniNetwork UNet2
 #SMDBServer
 #SharedMemoryPlus
 #UDPExchange

extensions/UNet2/Makefile.am

+bin_PROGRAMS 	= @PACKAGE@-unetexchange
+
+lib_LTLIBRARIES 			= libUniSetUNet2.la
+libUniSetUNet2_la_LIBADD		= $(top_builddir)/lib/libUniSet.la \
+								$(top_builddir)/extensions/SharedMemory/libUniSetSharedMemory.la \
+								$(top_builddir)/extensions/lib/libUniSetExtensions.la \
+								$(SIGC_LIBS) $(COMCPP_LIBS)
+libUniSetUNet2_la_CXXFLAGS	= -I$(top_builddir)/extensions/include -I$(top_builddir)/extensions/SharedMemory $(SIGC_CFLAGS) $(COMCPP_CFLAGS)
+libUniSetUNet2_la_SOURCES 	= UDPPacket.cc UNetReceiver.cc UNetSender.cc UNetExchange.cc
+
+@PACKAGE@_unetexchange_SOURCES 		= unetexchange.cc
+@PACKAGE@_unetexchange_LDADD 		= libUniSetUNet2.la $(top_builddir)/lib/libUniSet.la \
+									$(top_builddir)/extensions/SharedMemory/libUniSetSharedMemory.la \
+									$(top_builddir)/extensions/lib/libUniSetExtensions.la \
+									$(SIGC_LIBS) $(COMCPP_LIBS)
+@PACKAGE@_unetexchange_CXXFLAGS	= -I$(top_builddir)/extensions/include -I$(top_builddir)/extensions/SharedMemory $(SIGC_CFLAGS) $(COMCPP_CFLAGS)
+
+# install
+devel_include_HEADERS = *.h
+devel_includedir = $(pkgincludedir)/extensions
+
+pkgconfigdir 	= $(libdir)/pkgconfig
+pkgconfig_DATA 	= libUniSetUNet2.pc
+
+all-local:
+	ln -sf ../UDPExchange/$(devel_include_HEADERS) ../include

extensions/UNet2/UDPPacket.cc

+#include "UDPPacket.h"
+// -----------------------------------------------------------------------------
+using namespace std;
+using namespace UniSetUDP;
+// -----------------------------------------------------------------------------
+std::ostream& UniSetUDP::operator<<( std::ostream& os, UniSetUDP::UDPHeader& p )
+{
+	return os << "nodeID=" << p.nodeID 
+				<< " procID=" << p.procID 
+				<< " dcount=" << p.dcount
+				<< " pnum=" << p.num;
+}
+// -----------------------------------------------------------------------------
+std::ostream& UniSetUDP::operator<<( std::ostream& os, UniSetUDP::UDPData& p )
+{
+	return os << "id=" << p.id << " val=" << p.val;
+}
+// -----------------------------------------------------------------------------
+std::ostream& UniSetUDP::operator<<( std::ostream& os, UniSetUDP::UDPMessage& p )
+{
+	return os;
+}
+// -----------------------------------------------------------------------------
+UDPMessage::UDPMessage():
+count(0)
+{
+}
+// -----------------------------------------------------------------------------
+bool UDPMessage::addData( const UniSetUDP::UDPData& dat )
+{
+	if( count >= MaxDataCount )
+		return false;
+
+	msg.dat[count] = dat;
+	count++;
+	msg.header.dcount = count;
+	return true;
+}
+// -----------------------------------------------------------------------------
+bool UDPMessage::addData( long id, long val)
+{
+	UDPData d(id,val);
+	return addData(d);
+}
+// -----------------------------------------------------------------------------

extensions/UNet2/UDPPacket.h

+#ifndef UDPPacket_H_
+#define UDPPacket_H_
+// -----------------------------------------------------------------------------
+#include <list>
+#include <limits> 
+#include <ostream>
+#include "UniSetTypes.h"
+// -----------------------------------------------------------------------------
+namespace UniSetUDP
+{
+	struct UDPHeader
+	{
+		UDPHeader():num(0),nodeID(0),procID(0),dcount(0){}
+		unsigned long num;
+		long nodeID;
+		long procID;
+		size_t dcount;
+		
+		friend std::ostream& operator<<( std::ostream& os, UDPHeader& p );
+	}__attribute__((packed));
+
+	static unsigned long MaxPacketNum = std::numeric_limits<unsigned long>::max();
+	
+	struct UDPData
+	{
+		UDPData():id(UniSetTypes::DefaultObjectId),val(0){}
+		UDPData(long id, long val):id(id),val(val){}
+
+		long id;
+		long val;
+		
+		friend std::ostream& operator<<( std::ostream& os, UDPData& p );
+	}__attribute__((packed));
+
+	static const int MaxDataLen = 8192;
+	static const int MaxDataCount = ( MaxDataLen - sizeof(UniSetUDP::UDPHeader) ) / sizeof(UDPData);
+
+	 struct DataPacket
+	 {
+		UDPHeader header;
+		UDPData dat[MaxDataCount];
+	 }__attribute__((packed));
+
+
+	struct UDPMessage:
+		public UDPHeader
+	{
+		UDPMessage();
+
+		bool addData( const UDPData& dat );
+		bool addData( long id, long val );
+
+		inline bool isFull(){ return count<MaxDataCount; }
+		inline int size(){ return count; }
+		inline int byte_size(){ return count*sizeof(UDPData); }
+		
+		DataPacket msg;
+		int count;
+		
+		friend std::ostream& operator<<( std::ostream& os, UDPMessage& p );
+	};
+
+
+}
+// -----------------------------------------------------------------------------
+#endif // UDPPacket_H_
+// -----------------------------------------------------------------------------

extensions/UNet2/UNetExchange.cc

+#include <sstream>
+#include "Exceptions.h"
+#include "Extensions.h"
+#include "UNetExchange.h"
+// -----------------------------------------------------------------------------
+using namespace std;
+using namespace UniSetTypes;
+using namespace UniSetExtensions;
+UNetExchange::UNetExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, SharedMemory* ic ):
+UniSetObject_LT(objId),
+shm(0),
+initPause(0),
+activated(false),
+no_sender(false),
+sender(0)
+{
+	if( objId == DefaultObjectId )
+		throw UniSetTypes::SystemError("(UNetExchange): objId=-1?!! Use --unet-name" );
+
+//	xmlNode* cnode = conf->getNode(myname);
+	cnode = conf->getNode(myname);
+	if( cnode == NULL )
+		throw UniSetTypes::SystemError("(UNetExchange): Not found conf-node for " + myname );
+
+	shm = new SMInterface(shmId,&ui,objId,ic);
+
+	UniXML_iterator it(cnode);
+
+	// определяем фильтр
+	s_field = conf->getArgParam("--unet-filter-field");
+	s_fvalue = conf->getArgParam("--unet-filter-value");
+	dlog[Debug::INFO] << myname << "(init): read fileter-field='" << s_field
+						<< "' filter-value='" << s_fvalue << "'" << endl;
+
+	int recvTimeout = conf->getArgPInt("--unet-recv-timeout",it.getProp("recvTimeout"), 5000);
+	int lostTimeout = conf->getArgPInt("--unet-lost-timeout",it.getProp("lostTimeout"), recvTimeout);
+	int recvpause = conf->getArgPInt("--unet-recvpause",it.getProp("recvpause"), 10);
+	int sendpause = conf->getArgPInt("--unet-sendpause",it.getProp("sendpause"), 150);
+	int updatepause = conf->getArgPInt("--unet-updatepause",it.getProp("updatepause"), 100);
+	steptime = conf->getArgPInt("--unet-steptime",it.getProp("steptime"), 1000);
+	int maxDiff = conf->getArgPInt("--unet-maxdifferense",it.getProp("maxDifferense"), 1000);
+	int maxProcessingCount = conf->getArgPInt("--unet-maxprocessingcount",it.getProp("maxProcessingCount"), 100);
+
+	no_sender = conf->getArgInt("--unet-nosender",it.getProp("nosender"));
+
+	xmlNode* nodes = conf->getXMLNodesSection();
+	if( !nodes )
+	  throw UniSetTypes::SystemError("(UNetExchange): Not found <nodes>");
+
+	UniXML_iterator n_it(nodes);
+	if( !n_it.goChildren() )
+		throw UniSetTypes::SystemError("(UNetExchange): Items not found for <nodes>");
+
+	for( ; n_it.getCurrent(); n_it.goNext() )
+	{
+		string h(n_it.getProp("ip"));
+		if( !n_it.getProp("unet_ip").empty() )
+			h = n_it.getProp("unet_ip");
+
+		int p = n_it.getIntProp("id");
+		if( !n_it.getProp("unet_port").empty() )
+			p = n_it.getIntProp("unet_port");
+
+		string n(n_it.getProp("name"));
+		if( n == conf->getLocalNodeName() )
+		{
+			dlog[Debug::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);
+			continue;
+		}
+
+		if( !n_it.getProp("unet_ignore").empty() )
+		{
+			dlog[Debug::INFO] << myname << "(init): unet_ignore.. for " << n_it.getProp("name") << endl;
+			continue;
+		}
+
+		dlog[Debug::INFO] << myname << "(init): add UNetReceiver for " << h << ":" << p << endl;
+
+		if( checkExistUNetHost(h,p) )
+		{
+			dlog[Debug::INFO] << myname << "(init): " << h << ":" << p << " already added! Ignore.." << endl;
+			continue;
+		}
+		
+		UNetReceiver* r = new UNetReceiver(h,p,shm);
+
+		r->setReceiveTimeout(recvTimeout);
+		r->setLostTimeout(lostTimeout);
+		r->setReceivePause(recvpause);
+		r->setUpdatePause(updatepause);
+		r->setMaxDifferens(maxDiff);
+		r->setMaxProcessingCount(maxProcessingCount);
+		recvlist.push_back(r);
+	}
+	
+	// -------------------------------
+	// ********** HEARTBEAT *************
+	string heart = conf->getArgParam("--unet-heartbeat-id",it.getProp("heartbeat_id"));
+	if( !heart.empty() )
+	{
+		sidHeartBeat = conf->getSensorID(heart);
+		if( sidHeartBeat == DefaultObjectId )
+		{
+			ostringstream err;
+			err << myname << ": не найден идентификатор для датчика 'HeartBeat' " << heart;
+			dlog[Debug::CRIT] << myname << "(init): " << err.str() << endl;
+			throw SystemError(err.str());
+		}
+
+		int heartbeatTime = getHeartBeatTime();
+		if( heartbeatTime )
+			ptHeartBeat.setTiming(heartbeatTime);
+		else
+			ptHeartBeat.setTiming(UniSetTimer::WaitUpTime);
+
+		maxHeartBeat = conf->getArgPInt("--unet-heartbeat-max", it.getProp("heartbeat_max"), 10);
+		test_id = sidHeartBeat;
+	}
+	else
+	{
+		test_id = conf->getSensorID("TestMode_S");
+		if( test_id == DefaultObjectId )
+		{
+			ostringstream err;
+			err << myname << "(init): test_id unknown. 'TestMode_S' not found...";
+			dlog[Debug::CRIT] << myname << "(init): " << err.str() << endl;
+			throw SystemError(err.str());
+		}
+	}
+
+	dlog[Debug::INFO] << myname << "(init): test_id=" << test_id << endl;
+
+	activateTimeout	= conf->getArgPInt("--activate-timeout", 20000);
+
+	timeout_t msec = conf->getArgPInt("--unet-timeout",it.getProp("timeout"), 3000);
+
+	dlog[Debug::INFO] << myname << "(init): udp-timeout=" << msec << " msec" << endl;
+}
+// -----------------------------------------------------------------------------
+UNetExchange::~UNetExchange()
+{
+	for( ReceiverList::iterator it=recvlist.begin(); it!=recvlist.end(); ++it )
+		delete (*it);
+
+	delete sender;
+	delete shm;
+}
+// -----------------------------------------------------------------------------
+bool UNetExchange::checkExistUNetHost( const std::string addr, ost::tpport_t port )
+{
+	ost::IPV4Address a1(addr.c_str());
+	for( ReceiverList::iterator it=recvlist.begin(); it!=recvlist.end(); ++it )
+	{
+		if( (*it)->getAddress() == a1.getAddress() && (*it)->getPort() == port )
+			return true;
+	}
+
+	return false;
+}
+// -----------------------------------------------------------------------------
+void UNetExchange::startReceivers()
+{
+	 for( ReceiverList::iterator it=recvlist.begin(); it!=recvlist.end(); ++it )
+		  (*it)->start();
+}
+// -----------------------------------------------------------------------------
+void UNetExchange::initSender(  const std::string s_host, const ost::tpport_t port, UniXML_iterator& it )
+{
+	if( no_sender )
+		return;
+}
+// -----------------------------------------------------------------------------
+void UNetExchange::waitSMReady()
+{
+	// waiting for SM is ready...
+	int ready_timeout = conf->getArgInt("--unet-sm-ready-timeout","15000");
+	if( ready_timeout == 0 )
+		ready_timeout = 15000;
+	else if( ready_timeout < 0 )
+		ready_timeout = UniSetTimer::WaitUpTime;
+
+	if( !shm->waitSMready(ready_timeout,50) )
+	{
+		ostringstream err;
+		err << myname << "(waitSMReady): Не дождались готовности SharedMemory к работе в течение " << ready_timeout << " мсек";
+		dlog[Debug::CRIT] << err.str() << endl;
+		throw SystemError(err.str());
+	}
+}
+// -----------------------------------------------------------------------------
+void UNetExchange::timerInfo( TimerMessage *tm )
+{
+	if( !activated )
+		return;
+
+	if( tm->id == tmStep )
+		step();
+}
+// -----------------------------------------------------------------------------
+void UNetExchange::step()
+{
+	if( !activated )
+		return;
+
+	if( sidHeartBeat!=DefaultObjectId && ptHeartBeat.checkTime() )
+	{
+		try
+		{
+			shm->localSaveValue(aitHeartBeat,sidHeartBeat,maxHeartBeat,getId());
+			ptHeartBeat.reset();
+		}
+		catch(Exception& ex)
+		{
+			dlog[Debug::CRIT] << myname << "(step): (hb) " << ex << std::endl;
+		}
+	}
+}
+
+// -----------------------------------------------------------------------------
+void UNetExchange::processingMessage(UniSetTypes::VoidMessage *msg)
+{
+	try
+	{
+		switch(msg->type)
+		{
+			case UniSetTypes::Message::SysCommand:
+			{
+				UniSetTypes::SystemMessage sm( msg );
+				sysCommand( &sm );
+			}
+			break;
+
+			case Message::SensorInfo:
+			{
+				SensorMessage sm( msg );
+				sensorInfo(&sm);
+			}
+			break;
+
+			case Message::Timer:
+			{
+				TimerMessage tm(msg);
+				timerInfo(&tm);
+			}
+			break;
+
+			default:
+				break;
+		}
+	}
+	catch( SystemError& ex )
+	{
+		dlog[Debug::CRIT] << myname << "(SystemError): " << ex << std::endl;
+//		throw SystemError(ex);
+		raise(SIGTERM);
+	}
+	catch( Exception& ex )
+	{
+		dlog[Debug::CRIT] << myname << "(processingMessage): " << ex << std::endl;
+	}
+	catch(...)
+	{
+		dlog[Debug::CRIT] << myname << "(processingMessage): catch ...\n";
+	}
+}
+// -----------------------------------------------------------------------------
+void UNetExchange::sysCommand( UniSetTypes::SystemMessage *sm )
+{
+	switch( sm->command )
+	{
+		case SystemMessage::StartUp:
+		{
+			waitSMReady();
+
+			// подождать пока пройдёт инициализация датчиков
+			// см. activateObject()
+			msleep(initPause);
+			PassiveTimer ptAct(activateTimeout);
+			while( !activated && !ptAct.checkTime() )
+			{	
+				cout << myname << "(sysCommand): wait activate..." << endl;
+				msleep(300);
+				if( activated )
+					break;
+			}
+			
+			if( !activated )
+				dlog[Debug::CRIT] << myname << "(sysCommand): ************* don`t activate?! ************" << endl;
+			
+			{
+				UniSetTypes::uniset_mutex_lock l(mutex_start, 10000);
+				askSensors(UniversalIO::UIONotify);
+			}
+			askTimer(tmStep,steptime);
+			startReceivers();
+			if( sender )
+				sender->start();
+		}
+
+		case SystemMessage::FoldUp:
+		case SystemMessage::Finish:
+			askSensors(UniversalIO::UIODontNotify);
+			break;
+		
+		case SystemMessage::WatchDog:
+		{
+			// ОПТИМИЗАЦИЯ (защита от двойного перезаказа при старте)
+			// Если идёт локальная работа 
+			// (т.е. UNetExchange  запущен в одном процессе с SharedMemory2)
+			// то обрабатывать WatchDog не надо, т.к. мы и так ждём готовности SM
+			// при заказе датчиков, а если SM вылетит, то вместе с этим процессом(UNetExchange)
+			if( shm->isLocalwork() )
+				break;
+
+			askSensors(UniversalIO::UIONotify);
+		}
+		break;
+
+		case SystemMessage::LogRotate:
+		{
+			// переоткрываем логи
+			unideb << myname << "(sysCommand): logRotate" << std::endl;
+			string fname = unideb.getLogFile();
+			if( !fname.empty() )
+			{
+				unideb.logFile(fname);
+				unideb << myname << "(sysCommand): ***************** UNIDEB LOG ROTATE *****************" << std::endl;
+			}
+
+			dlog << myname << "(sysCommand): logRotate" << std::endl;
+			fname = dlog.getLogFile();
+			if( !fname.empty() )
+			{
+				dlog.logFile(fname);
+				dlog << myname << "(sysCommand): ***************** dlog LOG ROTATE *****************" << std::endl;
+			}
+		}
+		break;
+
+		default:
+			break;
+	}
+}
+// ------------------------------------------------------------------------------------------
+void UNetExchange::askSensors( UniversalIO::UIOCommand cmd )
+{
+	if( !shm->waitSMworking(test_id,activateTimeout,50) )
+	{
+		ostringstream err;
+		err << myname 
+			<< "(askSensors): Не дождались готовности(work) SharedMemory к работе в течение " 
+			<< activateTimeout << " мсек";
+	
+		dlog[Debug::CRIT] << err.str() << endl;
+		kill(SIGTERM,getpid());	// прерываем (перезапускаем) процесс...
+		throw SystemError(err.str());
+	}
+}
+// ------------------------------------------------------------------------------------------
+void UNetExchange::sensorInfo( UniSetTypes::SensorMessage* sm )
+{
+	if( sender )
+		sender->update(sm->id,sm->value);
+}
+// ------------------------------------------------------------------------------------------
+bool UNetExchange::activateObject()
+{
+	// блокирование обработки Starsp 
+	// пока не пройдёт инициализация датчиков
+	// см. sysCommand()
+	{
+		activated = false;
+		UniSetTypes::uniset_mutex_lock l(mutex_start, 5000);
+		UniSetObject_LT::activateObject();
+		initIterators();
+		activated = true;
+	}
+
+	return true;
+}
+// ------------------------------------------------------------------------------------------
+void UNetExchange::sigterm( int signo )
+{
+	cerr << myname << ": ********* SIGTERM(" << signo <<") ********" << endl;
+	activated = false;
+	UniSetObject_LT::sigterm(signo);
+}
+// ------------------------------------------------------------------------------------------
+void UNetExchange::initIterators()
+{
+	shm->initAIterator(aitHeartBeat);
+}
+// -----------------------------------------------------------------------------
+void UNetExchange::help_print( int argc, char* argv[] )
+{
+	cout << "--unet-recvpause msec    - Пауза между получением пакетов. По умолчанию 10 мсек." << endl;
+	cout << "--unet-updatepause msec  - Пауза между обновлением данных в SM. По умолчанию 100 мсек." << endl;
+	cout << "--unet-heartbeat-id      - Данный процесс связан с указанным аналоговым heartbeat-дачиком." << endl;
+	cout << "--unet-heartbeat-max     - Максимальное значение heartbeat-счётчика для данного процесса. По умолчанию 10." << endl;
+	cout << "--unet-ready-timeout     - Время ожидания готовности SM к работе, мсек. (-1 - ждать 'вечно')" << endl;
+	cout << "--unet-initPause		- Задержка перед инициализацией (время на активизация процесса)" << endl;
+	cout << "--unet-notRespondSensor - датчик связи для данного процесса " << endl;
+	cout << "--unet-sm-ready-timeout - время на ожидание старта SM" << endl;
+	cout << " Настройки протокола RS: " << endl;
+}
+// -----------------------------------------------------------------------------
+UNetExchange* UNetExchange::init_unetexchange( int argc, char* argv[], UniSetTypes::ObjectId icID, SharedMemory* ic )
+{
+	string name = conf->getArgParam("--unet-name","UNetExchange1");
+	if( name.empty() )
+	{
+		cerr << "(unetexchange): Не задан name'" << endl;
+		return 0;
+	}
+
+	ObjectId ID = conf->getObjectID(name);
+	if( ID == UniSetTypes::DefaultObjectId )
+	{
+		cerr << "(unetexchange): идентификатор '" << name
+			<< "' не найден в конф. файле!"
+			<< " в секции " << conf->getObjectsSection() << endl;
+		return 0;
+	}
+
+	dlog[Debug::INFO] << "(unetexchange): name = " << name << "(" << ID << ")" << endl;
+	return new UNetExchange(ID,icID,ic);
+}
+// -----------------------------------------------------------------------------

extensions/UNet2/UNetExchange.h

+#ifndef UNetExchange_H_
+#define UNetExchange_H_
+// -----------------------------------------------------------------------------
+#include <ostream>
+#include <string>
+#include <queue>
+#include <cc++/socket.h>
+#include "UniSetObject_LT.h"
+#include "Trigger.h"
+#include "Mutex.h"
+#include "SMInterface.h"
+#include "SharedMemory.h"
+#include "ThreadCreator.h"
+#include "UNetReceiver.h"
+#include "UNetSender.h"
+// -----------------------------------------------------------------------------
+class UNetExchange:
+	public UniSetObject_LT
+{
+	public:
+		UNetExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0 );
+		virtual ~UNetExchange();
+	
+		/*! глобальная функция для инициализации объекта */
+		static UNetExchange* init_unetexchange( int argc, char* argv[],
+											UniSetTypes::ObjectId shmID, SharedMemory* ic=0 );
+
+		/*! глобальная функция для вывода help-а */
+		static void help_print( int argc, char* argv[] );
+
+		bool checkExistUNetHost( const std::string host, ost::tpport_t port );
+
+	protected:
+
+		xmlNode* cnode;
+		std::string s_field;
+		std::string s_fvalue;
+
+		SMInterface* shm;
+		void step();
+
+		virtual void processingMessage( UniSetTypes::VoidMessage *msg );
+		void sysCommand( UniSetTypes::SystemMessage *msg );
+		void sensorInfo( UniSetTypes::SensorMessage*sm );
+		void timerInfo( UniSetTypes::TimerMessage *tm );
+		void askSensors( UniversalIO::UIOCommand cmd );
+		void waitSMReady();
+
+		virtual bool activateObject();
+		
+		// действия при завершении работы
+		virtual void sigterm( int signo );
+
+		void initIterators();
+		void startReceivers();
+		void initSender( const std::string host, const ost::tpport_t port, UniXML_iterator& it );
+
+		enum Timer
+		{
+			tmStep
+		};
+
+	private:
+		UNetExchange();
+		bool initPause;
+		UniSetTypes::uniset_mutex mutex_start;
+
+		PassiveTimer ptHeartBeat;
+		UniSetTypes::ObjectId sidHeartBeat;
+		int maxHeartBeat;
+		IOController::AIOStateList::iterator aitHeartBeat;
+		UniSetTypes::ObjectId test_id;
+
+		int steptime;	/*!< периодичность вызова step, [мсек] */
+
+		bool activated;
+		int activateTimeout;
+
+		typedef std::list<UNetReceiver*> ReceiverList;
+		ReceiverList recvlist;
+
+		bool no_sender;  /*!< флаг отключения посылки сообщений */
+		UNetSender* sender;
+};
+// -----------------------------------------------------------------------------
+#endif // UNetExchange_H_
+// -----------------------------------------------------------------------------

extensions/UNet2/UNetReceiver.cc

+#include <sstream>
+#include "Exceptions.h"
+#include "Extensions.h"
+#include "UNetReceiver.h"
+// -----------------------------------------------------------------------------
+using namespace std;
+using namespace UniSetTypes;
+using namespace UniSetExtensions;
+// -----------------------------------------------------------------------------
+bool UNetReceiver::PacketCompare::operator()(const UniSetUDP::UDPMessage& lhs,
+											const UniSetUDP::UDPMessage& rhs) const
+{
+//	if( lhs.msg.header.num == rhs.msg.header.num )
+//		return (lhs.msg < rhs.msg);
+
+	return lhs.msg.header.num > rhs.msg.header.num;
+}
+// ------------------------------------------------------------------------------------------
+UNetReceiver::UNetReceiver( const std::string s_host, const ost::tpport_t port, SMInterface* smi ):
+shm(smi),
+recvpause(10),
+updatepause(100),
+udp(0),
+recvTimeout(5000),
+lostTimeout(5000),
+lostPackets(0),
+activated(false),
+r_thr(0),
+u_thr(0),
+pnum(0),
+maxDifferens(1000),
+waitClean(false),
+rnum(0),
+maxProcessingCount(100),
+icache(200),
+cache_init_ok(false)
+{
+	{
+		ostringstream s;
+		s << "(" << s_host << ":" << port << ")";
+		myname = s.str();
+	}
+
+	try
+	{
+//		ost::IPV4Cidr ci(s_host.c_str());
+//		addr = ci.getBroadcast();
+//		cerr << "****************** addr: " << addr << endl;
+		addr = s_host.c_str();
+		udp = new ost::UDPDuplex(addr,port);
+	}
+	catch( ost::SockException& e )
+	{
+		ostringstream s;
+		s << e.getString() << ": " << e.getSystemErrorString();
+		dlog[Debug::CRIT] << myname << "(init): " << s.str() << std::endl;
+
+		throw SystemError(s.str());
+	}
+
+	r_thr = new ThreadCreator<UNetReceiver>(this, &UNetReceiver::receive);
+	u_thr = new ThreadCreator<UNetReceiver>(this, &UNetReceiver::update);
+
+
+	ptRecvTimeout.setTiming(recvTimeout);
+}
+// -----------------------------------------------------------------------------
+UNetReceiver::~UNetReceiver()
+{
+	delete r_thr;
+	delete u_thr;
+	delete udp;
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setReceiveTimeout( timeout_t msec )
+{
+	recvTimeout = msec;
+	ptRecvTimeout.setTiming(msec);
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setLostTimeout( timeout_t msec )
+{
+	lostTimeout = msec;
+	ptLostTimeout.setTiming(msec);
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setReceivePause( timeout_t msec )
+{
+	recvpause = msec;
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setUpdatePause( timeout_t msec )
+{
+	updatepause = msec;
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setMaxProcessingCount( int set )
+{
+	maxProcessingCount = set;
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setMaxDifferens( unsigned long set )
+{
+	maxDifferens = set;
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::start()
+{
+	if( !activated )
+	{
+		activated = true;
+		u_thr->start();
+		r_thr->start();
+	}
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::update()
+{
+	cerr << "******************* udpate start" << endl;
+	while(activated)
+	{
+		try
+		{
+			real_update();
+		}
+		catch( UniSetTypes::Exception& ex)
+		{
+			dlog[Debug::CRIT] << myname << "(update): " << ex << std::endl;
+		}
+		catch(...)
+		{
+			dlog[Debug::CRIT] << myname << "(update): catch ..." << std::endl;
+		}
+
+		msleep(updatepause);
+	}
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::real_update()
+{
+	UniSetUDP::UDPMessage p;
+	// обрабатываем пока, очередь либо не опустеет
+	// либо обнаружится "дырка" в последовательности
+	// но при этом обрабатываем не больше maxProcessingCount
+	// за один раз..
+	int k = maxProcessingCount;
+	while( k>0 )
+	{
+		{ // lock qpack
+			uniset_mutex_lock l(packMutex);
+			if( qpack.empty() )
+				return;
+
+			p = qpack.top();
+			unsigned long sub = labs(p.msg.header.num - pnum);
+			if( pnum > 0 )
+			{
+				// если sub > maxDifferens
+				// значит это просто "разрыв"
+				// и нам ждать lostTimeout не надо
+				// сразу начинаем обрабатывать новые пакеты
+				// а если > 1 && < maxDifferens
+				// значит это временная "дырка"
+				// и надо подождать lostTimeout
+				// чтобы констатировать потерю пакета..
+				if( sub > 1 && sub < maxDifferens )
+				{
+					if( !ptLostTimeout.checkTime() )
+						return;
+
+					lostPackets++;
+				}
+				else if( p.msg.header.num == pnum )
+				{
+				   /* а что делать если идут повторные пакеты ?!
+					* для надёжности лучше обрабатывать..
+					* для "оптимизации".. лучше игнорировать
+					*/
+					qpack.pop(); // пока выбрали вариант "оптимизации"
+					continue;
+				}
+			}
+
+			ptLostTimeout.reset();
+
+			// удаляем из очереди, только если
+			// всё в порядке с последовательностью..
+			qpack.pop();
+			pnum = p.msg.header.num;
+		} // unlock qpack
+
+		k--;
+
+//		cerr << myname << "(update): " << p.msg.header << endl;
+
+		initCache(p, !cache_init_ok);
+
+		for( size_t i=0; i<p.msg.header.dcount; i++ )
+		{
+			try
+			{
+				UniSetUDP::UDPData& d = p.msg.dat[i];
+				ItemInfo& ii(icache[i]);
+				if( ii.id != d.id )
+				{
+					dlog[Debug::WARN] << myname << "(update): reinit cache for sid=" << d.id << endl;
+					ii.id = d.id;
+					shm->initAIterator(ii.ait);
+					shm->initDIterator(ii.dit);
+				}
+
+				if( ii.iotype == UniversalIO::DigitalInput )
+					shm->localSaveState(ii.dit,d.id,d.val,shm->ID());
+				else if( ii.iotype == UniversalIO::AnalogInput )
+					shm->localSaveValue(ii.ait,d.id,d.val,shm->ID());
+				else if( ii.iotype == UniversalIO::AnalogOutput )
+					shm->localSetValue(ii.ait,d.id,d.val,shm->ID());
+ 				else if( ii.iotype == UniversalIO::DigitalOutput )
+					shm->localSetState(ii.dit,d.id,d.val,shm->ID());
+				else
+				  dlog[Debug::CRIT] << myname << "(update): Unknown iotype for sid=" << d.id << endl;
+			}
+			catch( UniSetTypes::Exception& ex)
+			{
+				dlog[Debug::CRIT] << myname << "(update): " << ex << std::endl;
+			}
+			catch(...)
+			{
+				dlog[Debug::CRIT] << myname << "(update): catch ..." << std::endl;
+			}
+		}
+	}
+}
+
+// -----------------------------------------------------------------------------
+void UNetReceiver::receive()
+{
+	cerr << "******************* receive start" << endl;
+	ptRecvTimeout.setTiming(recvTimeout);
+	while( activated )
+	{
+		try
+		{
+			if( recv() )
+			  ptRecvTimeout.reset();
+		}
+		catch( ost::SockException& e )
+		{
+			cerr  << e.getString() << ": " << e.getSystemErrorString() << endl;
+		}
+		catch( UniSetTypes::Exception& ex)
+		{
+			cerr << myname << "(poll): " << ex << std::endl;
+		}
+		catch(...)
+		{
+			cerr << myname << "(poll): catch ..." << std::endl;
+		}	
+
+		msleep(recvpause);
+	}
+
+	cerr << "************* execute FINISH **********" << endl;
+}
+// -----------------------------------------------------------------------------
+bool UNetReceiver::recv()
+{
+	if( !udp->isInputReady(recvTimeout) )
+		return false;
+
+	ssize_t ret = udp->UDPReceive::receive(&(pack.msg),sizeof(pack.msg));
+	if( ret < sizeof(UniSetUDP::UDPHeader) )
+	{
+		dlog[Debug::CRIT] << myname << "(receive): FAILED header ret=" << ret << " sizeof=" << sizeof(UniSetUDP::UDPHeader) << endl;
+		return false;
+	}
+		
+	ssize_t sz = pack.msg.header.dcount * sizeof(UniSetUDP::UDPData) + sizeof(UniSetUDP::UDPHeader);
+	if( ret < sz )
+	{
+		dlog[Debug::CRIT] << myname << "(receive): FAILED data ret=" << ret << " sizeof=" << sz
+			  << " packnum=" << pack.msg.header.num << endl;
+		return false;
+	}
+
+
+	if( rnum>0 && labs(pack.msg.header.num - rnum) > maxDifferens )
+	{
+		/* А что делать если мы уже ждём и ещё не "разгребли предыдущее".. а тут уже повторный "разрыв"
+		 * Можно откинуть всё.. что сложили во временную очередь и заново "копить" (но тогда теряем информацию)
+		 * А можно породолжать складывать во временную, но тогда есть риск "никогда" не разгрести временную
+		 * очередь, при "частых обрывах". Потому-что update будет на каждом разрыве ждать ещё lostTimeout..
+		 */
+		// Пока выбираю.. чистить qtmp. Это будет соотвествовать логике работы с картами у которых ограничен буфер приёма.
+		// Обычно "кольцевой". Т.е. если не успели обработать и "вынуть" из буфера информацию.. он будет переписан новыми данными
+		if( waitClean )
+		{
+			dlog[Debug::CRIT] << myname << "(receive): reset qtmp.." << endl;
+			while( !qtmp.empty() )
+				qtmp.pop();
+		}
+		
+		waitClean = true;
+	}
+
+	rnum = pack.msg.header.num;
+
+//	cerr << myname << "(receive): recv DATA OK. ret=" << ret << " sizeof=" << sz
+//		  << " header: " << pack.msg.header
+//		  << " waitClean=" << waitClean
+//		  << endl;
+
+	{	// lock qpack
+		uniset_mutex_lock l(packMutex,500);
+		if( !waitClean )
+		{
+			qpack.push(pack);
+			return true;
+		}
+
+		if( !qpack.empty() )
+		{
+//			cerr << myname << "(receive): copy to qtmp..."
+//							  << " header: " << pack.msg.header
+//							  << endl;
+			qtmp.push(pack);
+		}
+		else
+		{
+//		  	cerr << myname << "(receive): copy from qtmp..." << endl;
+			// очередь освободилась..
+			// то копируем в неё всё что набралось...
+			while( !qtmp.empty() )
+			{
+				qpack.push(qtmp.top());
+				qtmp.pop();
+			}
+
+			// не забываем и текущий поместить в очередь..
+			qpack.push(pack);
+			waitClean = false;
+		}
+	}	// unlock qpack
+
+	return true;
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::initIterators()
+{
+	for( ItemVec::iterator it=icache.begin(); it!=icache.end(); ++it )
+	{
+		shm->initAIterator(it->ait);
+		shm->initDIterator(it->dit);
+	}
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::initCache( UniSetUDP::UDPMessage& pack, bool force )
+{
+	 if( !force && pack.msg.header.dcount == icache.size() )
+		  return;
+
+	 dlog[Debug::INFO] << myname << ": init icache.." << endl;
+	 cache_init_ok = true;
+
+	 icache.resize(pack.msg.header.dcount);
+	 for( size_t i=0; i<icache.size(); i++ )
+	 {
+		  ItemInfo& d(icache[i]);
+		  if( d.id != pack.msg.dat[i].id )
+		  {
+				d.id = pack.msg.dat[i].id;
+				d.iotype = conf->getIOType(d.id);
+				shm->initAIterator(d.ait);
+				shm->initDIterator(d.dit);
+		  }
+	 }
+}
+// -----------------------------------------------------------------------------

extensions/UNet2/UNetReceiver.h

+#ifndef UNetReceiver_H_
+#define UNetReceiver_H_
+// -----------------------------------------------------------------------------
+#include <ostream>
+#include <string>
+#include <queue>
+#include <cc++/socket.h>
+#include "UniSetObject_LT.h"
+#include "Trigger.h"
+#include "Mutex.h"
+#include "SMInterface.h"
+#include "SharedMemory.h"
+#include "ThreadCreator.h"
+#include "UDPPacket.h"
+// -----------------------------------------------------------------------------
+/*  Основная идея: сделать проверку очерёдности пакетов, но при этом использовать UDP.
+ * ===============
+ * Собственно реализация сделана так:
+ * В данных передаётся номер пакета. На случай если несколько пакетов придут не в той последовательности
+ * что были посланы, сделана очередь с приоритетом. В качестве приориета используется номер пакета
+ * (чем меньше тем старше). При этом обработка ведётся только тех пакетов, которые идут "подряд",
+ * как только встречается "дырка" происходит ожидание её "заполения". Если в течение времени (lostTimeout)
+ * "дырка" не исчезает, увеличивается счётчик потерянных пакетов и обработка продолжается дальше..
+ * Всё это реализовано в функции UNetReceiver::real_update()
+ *
+ * КЭШ
+ * ===
+ * Для оптимизации работы с SM, т.к. в пакетах приходят только пары [id,value] сделан кэш итераторов.
+ * Кэш расчитан на то, что принимаемые пакеты всегда имеют одну и ту же длину и последовательность.
+ * Идея проста: сделан вектор размером с количество принимаемых данных. В векторе хранятся итераторы (и всё что необходимо).
+ * Порядковый номер данных в пакете является индексом в кэше.
+ * Для защиты от изменения поседовательности внутри пакета, в кэше хранится ID сохраняемого датчика, и если он не совпадёт с тем,
+ * ID который пришёл в пакете - элемент кэша обновляется.
+ * Если количество пришедших данных не совпадают с размером кэша.. кэш обновляется.
+ *
+ * Обработка сбоя или переполнения счётчика пакетов(перехода через максимум)
+ * =========================================================================
+ * Для защиты от сбоя счётика сделана следующая логика:
+ * Если номер очередного пришедшего пакета отличается от последнего обработанного на maxDifferens, то считается,
+ * что произошёл сбой счётчика и происходит ожидание пока функция update, не обработает основную очередь полностью.
+ * При этом принимаемые пакеты складываются во временную очередь qtmp. Как только основная очередь пустеет,
+ * в неё копируется всё накопленное во временной очереди..и опять идёт штатная обработка.
+ * Если во время "ожидания" опять происходит "разрыв" в номерах пакетов, то временная очередь чиститься
+ * и данные которые в ней были теряются! Аналог ограниченного буфера (у любых карт), когда новые данные
+ * затирают старые, если их не успели вынуть и обработать.
+ * \todo Сделать защиту от бесконечного ожидания "очистки" основной очереди.
+*/
+// -----------------------------------------------------------------------------
+class UNetReceiver
+{
+	public:
+		UNetReceiver( const std::string host, const ost::tpport_t port, SMInterface* smi );
+		~UNetReceiver();
+
+		 void start();
+
+		 void receive();
+		 void update();
+
+		 inline bool isRecvOK(){ return ptRecvTimeout.checkTime(); }
+		 inline unsigned long getLostPacketsNum(){ return lostPackets; }
+
+		 void setReceiveTimeout( timeout_t msec );
+		 void setReceivePause( timeout_t msec );
+		 void setUpdatePause( timeout_t msec );
+		 void setLostTimeout( timeout_t msec );
+		 void setMaxDifferens( unsigned long set );
+
+		 void setMaxProcessingCount( int set );
+
+		 inline ost::IPV4Address getAddress(){ return addr; }
+		 inline ost::tpport_t getPort(){ return port; }
+
+	protected:
+
+		SMInterface* shm;
+
+		bool recv();
+		void step();
+		void real_update();
+
+		void initIterators();
+
+	private:
+		UNetReceiver();
+
+		int recvpause;		/*!< пауза меджду приёмами пакетов, [мсек] */
+		int updatepause;	/*!< переодичность обновления данных в SM, [мсек] */
+
+		ost::UDPReceive* udp;
+		ost::IPV4Address addr;
+		ost::tpport_t port;
+		std::string myname;
+
+		UniSetTypes::uniset_mutex pollMutex;
+		PassiveTimer ptRecvTimeout;
+		timeout_t recvTimeout;
+		timeout_t lostTimeout;
+		PassiveTimer ptLostTimeout;
+		unsigned long lostPackets; /*!< счётчик потерянных пакетов */
+
+		bool activated;
+		
+		ThreadCreator<UNetReceiver>* r_thr;		// receive thread
+		ThreadCreator<UNetReceiver>* u_thr;		// update thread
+
+		// функция определения приоритетного сообщения для обработки
+		struct PacketCompare:
+		public std::binary_function<UniSetUDP::UDPMessage, UniSetUDP::UDPMessage, bool>
+		{
+			bool operator()(const UniSetUDP::UDPMessage& lhs,
+							const UniSetUDP::UDPMessage& rhs) const;
+		};
+		typedef std::priority_queue<UniSetUDP::UDPMessage,std::vector<UniSetUDP::UDPMessage>,PacketCompare> PacketQueue;
+		PacketQueue qpack;	/*!< очередь принятых пакетов (отсортированных по возрастанию номера пакета) */
+		UniSetUDP::UDPMessage pack;		/*!< просто буфер для получения очереlного сообщения */
+		UniSetTypes::uniset_mutex packMutex; /*!< mutex для работы с очередью */
+		unsigned long pnum;	/*!< текущий номер обработанного сообщения, для проверки непрерывности последовательности пакетов */
+
+		/*! максимальная разница межд номерами пакетов, при которой считается, что счётчик пакетов
+		 * прошёл через максимум или сбился...
+		 */
+		unsigned long maxDifferens;
+
+		PacketQueue qtmp;	/*!< очередь на время обработки(очистки) основной очереди */
+		bool waitClean;		/*!< флаг означающий, что ждём очистики очереди до конца */
+		unsigned long rnum;	/*!< текущий номер принятого сообщения, для проверки "переполнения" или "сбоя" счётчика */
+		
+		int maxProcessingCount; /*! максимальное число обрабатываемых за один раз сообщений */
+
+		struct ItemInfo
+		{
+			long id;
+			IOController::AIOStateList::iterator ait;
+			IOController::DIOStateList::iterator dit;
+			UniversalIO::IOTypes iotype;
+		};
+
+		typedef std::vector<ItemInfo> ItemVec;
+		ItemVec icache;	/*!< кэш итераторов */
+		bool cache_init_ok;
+		void initCache( UniSetUDP::UDPMessage& pack, bool force=false );
+
+};
+// -----------------------------------------------------------------------------
+#endif // UNetReceiver_H_
+// -----------------------------------------------------------------------------

extensions/UNet2/UNetSender.cc

+#include <sstream>
+#include "Exceptions.h"
+#include "Extensions.h"
+#include "UNetSender.h"
+// -----------------------------------------------------------------------------
+using namespace std;
+using namespace UniSetTypes;
+using namespace UniSetExtensions;
+// -----------------------------------------------------------------------------
+UNetSender::UNetSender( const std::string s_host, const ost::tpport_t port, SMInterface* smi,
+						const std::string s_f, const std::string s_val, SharedMemory* ic ):
+s_field(s_f),
+s_fvalue(s_val),
+shm(smi),
+s_host(s_host),
+sendpause(150),
+activated(false),
+dlist(100),
+maxItem(0),
+packetnum(1),
+s_thr(0)
+{
+
+	{
+		ostringstream s;
+		s << "(" << s_host << ":" << port << ")";
+		myname = s.str();
+	}
+
+	// определяем фильтр
+//	s_field = conf->getArgParam("--udp-filter-field");
+//	s_fvalue = conf->getArgParam("--udp-filter-value");
+	dlog[Debug::INFO] << myname << "(init): read fileter-field='" << s_field
+						<< "' filter-value='" << s_fvalue << "'" << endl;
+
+	if( dlog.debugging(Debug::INFO) )
+		dlog[Debug::INFO] << "(UNetSender): UDP set to " << s_host << ":" << port << endl;
+
+	
+	try
+	{
+		addr = s_host.c_str();
+		udp = new ost::UDPBroadcast(addr,port);
+	}
+	catch( ost::SockException& e )
+	{
+		ostringstream s;
+		s << e.getString() << ": " << e.getSystemErrorString() << endl;
+		throw SystemError(s.str());
+	}
+
+	s_thr = new ThreadCreator<UNetSender>(this, &UNetSender::send);
+
+	// -------------------------------
+	if( shm->isLocalwork() )
+	{
+		readConfiguration();
+		dlist.resize(maxItem);
+		dlog[Debug::INFO] << myname << "(init): dlist size = " << dlist.size() << endl;
+	}
+	else
+		ic->addReadItem( sigc::mem_fun(this,&UNetSender::readItem) );
+
+
+	// выставляем поля, которые не меняются
+	mypack.msg.header.nodeID = conf->getLocalNode();
+	mypack.msg.header.procID = shm->ID();
+}
+// -----------------------------------------------------------------------------
+UNetSender::~UNetSender()
+{
+  	delete s_thr;
+	delete udp;
+	delete shm;
+}
+// -----------------------------------------------------------------------------
+void UNetSender::update( UniSetTypes::ObjectId id, long value )
+{
+	DMap::iterator it=dlist.begin();
+	for( ; it!=dlist.end(); ++it )
+	{
+		if( it->si.id == id )
+		{
+			uniset_spin_lock lock(it->val_lock);
+			it->val = value;
+		}
+		break;
+	}
+}
+// -----------------------------------------------------------------------------
+void UNetSender::send()
+{
+	dlist.resize(maxItem);
+	dlog[Debug::INFO] << myname << "(init): dlist size = " << dlist.size() << endl;
+/*
+	ost::IPV4Broadcast h = s_host.c_str();
+	try
+	{			
+		udp->setPeer(h,port);
+	}
+	catch( ost::SockException& e )
+	{
+		ostringstream s;
+		s << e.getString() << ": " << e.getSystemErrorString();
+		dlog[Debug::CRIT] << myname << "(poll): " << s.str() << endl;
+		throw SystemError(s.str());
+	}
+*/
+	while( activated )
+	{
+		try
+		{
+			real_send();
+		}
+		catch( ost::SockException& e )
+		{
+			cerr  << e.getString() << ": " << e.getSystemErrorString() << endl;
+		}
+		catch( UniSetTypes::Exception& ex)
+		{
+			cerr << myname << "(send): " << ex << std::endl;
+		}
+		catch(...)
+		{
+			cerr << myname << "(send): catch ..." << std::endl;
+		}	
+
+		msleep(sendpause);
+	}
+
+	cerr << "************* execute FINISH **********" << endl;
+}
+// -----------------------------------------------------------------------------
+void UNetSender::real_send()
+{
+	mypack.msg.header.num = packetnum++;
+
+	if( packetnum > UniSetUDP::MaxPacketNum )
+		packetnum = 1;
+
+//	cout << "************* send header: " << mypack.msg.header << endl;
+	int sz = mypack.byte_size() + sizeof(UniSetUDP::UDPHeader);
+	if( !udp->isPending(ost::Socket::pendingOutput) )
+		return;
+
+	ssize_t ret = udp->send( (char*)&(mypack.msg),sz);
+	if( ret < sz )
+		dlog[Debug::CRIT] << myname << "(send): FAILED ret=" << ret << " < sizeof=" << sz << endl;
+}
+// -----------------------------------------------------------------------------
+void UNetSender::start()
+{
+	if( !activated )
+	{
+		activated = true;
+		s_thr->start();
+	}
+}
+// -----------------------------------------------------------------------------
+void UNetSender::readConfiguration()
+{
+	xmlNode* root = conf->getXMLSensorsSection();
+	if(!root)
+	{
+		ostringstream err;
+		err << myname << "(readConfiguration): not found <sensors>";
+		throw SystemError(err.str());
+	}
+
+	UniXML_iterator it(root);
+	if( !it.goChildren() )
+	{
+		std::cerr << myname << "(readConfiguration): empty <sensors>?!!" << endl;
+		return;
+	}
+
+	for( ;it.getCurrent(); it.goNext() )
+	{
+		if( check_item(it) )
+			initItem(it);
+	}
+}
+// ------------------------------------------------------------------------------------------
+bool UNetSender::check_item( UniXML_iterator& it )
+{
+	if( s_field.empty() )
+		return true;
+
+	// просто проверка на не пустой field
+	if( s_fvalue.empty() && it.getProp(s_field).empty() )
+		return false;
+
+	// просто проверка что field = value
+	if( !s_fvalue.empty() && it.getProp(s_field)!=s_fvalue )
+		return false;
+
+	return true;
+}
+// ------------------------------------------------------------------------------------------
+bool UNetSender::readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec )
+{
+	if( check_item(it) )
+		initItem(it);
+	return true;
+}
+// ------------------------------------------------------------------------------------------
+bool UNetSender::initItem( UniXML_iterator& it )
+{
+	string sname( it.getProp("name") );
+
+	string tid = it.getProp("id");
+	
+	ObjectId sid;
+	if( !tid.empty() )
+	{
+		sid = UniSetTypes::uni_atoi(tid);
+		if( sid <= 0 )
+			sid = DefaultObjectId;
+	}
+	else
+		sid = conf->getSensorID(sname);
+
+	if( sid == DefaultObjectId )
+	{
+		if( dlog )
+			dlog[Debug::CRIT] << myname << "(readItem): ID not found for "
+							<< sname << endl;
+		return false;
+	}
+	
+	UItem p;
+	p.si.id = sid;
+	p.si.node = conf->getLocalNode();
+	mypack.addData(sid,0);
+	p.pack_ind = mypack.size()-1;
+
+	if( maxItem >= mypack.size() )
+		dlist.resize(maxItem+10);
+	
+	dlist[maxItem] = p;
+	maxItem++;
+
+	if( dlog.debugging(Debug::INFO) )
+		dlog[Debug::INFO] << myname << "(initItem): add " << p << endl;
+
+	return true;
+}
+
+// ------------------------------------------------------------------------------------------
+void UNetSender::initIterators()
+{
+	DMap::iterator it=dlist.begin();
+	for( ; it!=dlist.end(); it++ )
+	{
+		shm->initDIterator(it->dit);
+		shm->initAIterator(it->ait);
+	}
+}
+// -----------------------------------------------------------------------------
+std::ostream& operator<<( std::ostream& os, UNetSender::UItem& p )
+{
+	return os 	<< " sid=" << p.si.id;
+}
+// -----------------------------------------------------------------------------

extensions/UNet2/UNetSender.h

+#ifndef UNetSender_H_
+#define UNetSender_H_
+// -----------------------------------------------------------------------------
+#include <ostream>
+#include <string>
+#include <vector>
+#include <cc++/socket.h>
+#include "UniSetObject_LT.h"
+#include "Trigger.h"
+#include "Mutex.h"
+#include "SMInterface.h"
+#include "SharedMemory.h"
+#include "ThreadCreator.h"
+#include "UDPPacket.h"
+// -----------------------------------------------------------------------------
+/*
+ * Для защиты от потери пакета при переполнении "номера пакета".
+ * UNetReceiver при обнаружении "разрыва" в последовательнности, просто игнорирует пакет, обновляет счётчик
+ * и начинает обработку пока буфер опять не заполнится..
+ */
+class UNetSender
+{
+	public:
+		UNetSender( const std::string host, const ost::tpport_t port, SMInterface* smi,
+					const std::string s_field="", const std::string s_fvalue="", SharedMemory* ic=0 );
+
+		~UNetSender();
+	
+		struct UItem
+		{
+			UItem():
+				val(0)
+			{}
+
+			IOController_i::SensorInfo si;
+			IOController::AIOStateList::iterator ait;
+			IOController::DIOStateList::iterator dit;
+			UniSetTypes::uniset_spin_mutex val_lock;
+			int pack_ind;
+			long val;
+
+			friend std::ostream& operator<<( std::ostream& os, UItem& p );
+		};
+
+		void start();
+
+		void send();
+		void real_send();
+		void update( UniSetTypes::ObjectId id, long value );
+
+		inline void setSendPause( int msec ){ sendpause = msec; }
+		
+	protected:
+
+		std::string s_field;
+		std::string s_fvalue;
+
+		SMInterface* shm;
+
+		void initIterators();
+		bool initItem( UniXML_iterator& it );
+		bool readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec );
+
+		void readConfiguration();
+		bool check_item( UniXML_iterator& it );
+
+	private:
+		UNetSender();
+
+		ost::UDPBroadcast* udp;
+		ost::IPV4Address addr;
+		ost::tpport_t port;
+		std::string s_host;
+
+		std::string myname;
+		int sendpause;
+		bool activated;
+		
+		UniSetUDP::UDPMessage mypack;
+		typedef std::vector<UItem> DMap;
+		DMap dlist;
+		int maxItem;
+		unsigned long packetnum;
+
+		ThreadCreator<UNetSender>* s_thr;	// send thread
+};
+// -----------------------------------------------------------------------------
+#endif // UNetSender_H_
+// -----------------------------------------------------------------------------

extensions/UNet2/create_links.sh

+#!/bin/sh
+
+ln -s -f ../../Utilities/scripts/uniset-start.sh 
+ln -s -f ../../Utilities/scripts/uniset-stop.sh stop.sh
+ln -s -f ../../Utilities/scripts/uniset-functions.sh 
+ln -s -f ../../conf/test.xml test.xml
+

extensions/UNet2/libUniSetUNet2.pc.in

+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libUniSetUNet2
+Description: Support library for UniSetUNet2
+Requires: libUniSetExtensions
+Version: @VERSION@
+Libs: -L${libdir} -lUniSetUNet2
+Cflags: -I${includedir}/uniset

extensions/UNet2/start_fg.sh

+#!/bin/sh
+
+uniset-start.sh -f ./uniset-unetexchange --unet-name UNetExchange \
+	--confile test.xml \
+	--unet-filter-field rs --unet-filter-value 2 --unet-maxdifferense 40 \
+	--dlog-add-levels info,crit,warn
+

extensions/UNet2/unetexchange.cc

+#include <sstream>
+#include "ObjectsActivator.h"
+#include "Extensions.h"
+#include "UNetExchange.h"
+// -----------------------------------------------------------------------------
+using namespace std;
+using namespace UniSetTypes;
+using namespace UniSetExtensions;
+// -----------------------------------------------------------------------------
+int main( int argc, char** argv )
+{
+	try
+	{
+		if( argc>1 && (!strcmp(argv[1],"--help") || !strcmp(argv[1],"-h")) )
+		{
+			cout << "--smemory-id objectName  - SharedMemory objectID. Default: read from <SharedMemory>" << endl;
+			cout << "--confile filename       - configuration file. Default: configure.xml" << endl;
+			cout << "--unet-logfile filename    - logfilename. Default: udpexchange.log" << endl;
+			cout << endl;
+			UNetExchange::help_print(argc,argv);
+			return 0;
+		}
+
+		string confile=UniSetTypes::getArgParam("--confile",argc,argv,"configure.xml");
+		conf = new Configuration( argc, argv, confile );
+
+		string logfilename(conf->getArgParam("--unet-logfile"));
+		if( logfilename.empty() )
+			logfilename = "udpexchange.log";
+	
+		conf->initDebug(dlog,"dlog");
+	
+		std::ostringstream logname;
+		string dir(conf->getLogDir());
+		logname << dir << logfilename;
+		unideb.logFile( logname.str() );
+		dlog.logFile( logname.str() );
+
+		ObjectId shmID = DefaultObjectId;
+		string sID = conf->getArgParam("--smemory-id");
+		if( !sID.empty() )
+			shmID = conf->getControllerID(sID);
+		else
+			shmID = getSharedMemoryID();
+
+		if( shmID == DefaultObjectId )
+		{
+			cerr << sID << "? SharedMemoryID not found in " << conf->getControllersSection() << " section" << endl;
+			return 1;
+		}
+
+		UNetExchange* unet = UNetExchange::init_unetexchange(argc,argv,shmID);
+		if( !unet )
+		{
+			dlog[Debug::CRIT] << "(unetexchange): init failed.." << endl;
+			return 1;
+		}
+
+		ObjectsActivator act;
+		act.addObject(static_cast<class UniSetObject*>(unet));
+
+		SystemMessage sm(SystemMessage::StartUp); 
+		act.broadcast( sm.transport_msg() );
+
+		unideb(Debug::ANY) << "\n\n\n";
+		unideb[Debug::ANY] << "(main): -------------- UDPRecevier START -------------------------\n\n";
+		dlog(Debug::ANY) << "\n\n\n";
+		dlog[Debug::ANY] << "(main): -------------- UDPReceiver START -------------------------\n\n";
+
+		act.run(false);
+	}
+	catch( Exception& ex )
+	{
+		dlog[Debug::CRIT] << "(unetexchange): " << ex << std::endl;
+	}
+	catch( ost::SockException& e )
+	{
+		ostringstream s;
+		s << e.getString() << ": " << e.getSystemErrorString();
+		dlog[Debug::CRIT] << s.str() << endl;
+	}
+	catch(...)
+	{
+		dlog[Debug::CRIT] << "(unetexchange): catch ..." << std::endl;
+	}
+
+	return 0;
+}