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.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.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;
+}