Сделал предварительную реализацию UNetReceiver-а..

extensions/UDPExchange/Makefile.am

 bin_PROGRAMS 	= @PACKAGE@-udpexchange
-noinst_PROGRAMS = @PACKAGE@-udpreceiver
+noinst_PROGRAMS = @PACKAGE@-udpreceiver @PACKAGE@-unetexchange
 #@PACKAGE@-udpsender
 
 UUDP_VER=@LIBVER@
@@ -11,7 +11,7 @@ libUniSetUDP_la_LIBADD		= $(top_builddir)/lib/libUniSet.la \
 								$(top_builddir)/extensions/lib/libUniSetExtensions.la \
 								$(SIGC_LIBS) $(COMCPP_LIBS)
 libUniSetUDP_la_CXXFLAGS	= -I$(top_builddir)/extensions/include -I$(top_builddir)/extensions/SharedMemory $(SIGC_CFLAGS) $(COMCPP_CFLAGS)
-libUniSetUDP_la_SOURCES 	= UDPPacket.cc UDPExchange.cc UDPNReceiver.cc UDPReceiver.cc
+libUniSetUDP_la_SOURCES 	= UDPPacket.cc UDPExchange.cc UDPNReceiver.cc UDPReceiver.cc UNetReceiver.cc UNetExchange.cc
 
 #UDPSender.cc
 #UDPSender.cc
@@ -37,6 +37,13 @@ libUniSetUDP_la_SOURCES 	= UDPPacket.cc UDPExchange.cc UDPNReceiver.cc UDPReceiv
 									$(SIGC_LIBS) $(COMCPP_LIBS)
 @PACKAGE@_udpreceiver_CXXFLAGS	= -I$(top_builddir)/extensions/include -I$(top_builddir)/extensions/SharedMemory $(SIGC_CFLAGS) $(COMCPP_CFLAGS)
 
+@PACKAGE@_unetexchange_SOURCES 		= unetexchange.cc
+@PACKAGE@_unetexchange_LDADD 		= libUniSetUDP.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

extensions/UDPExchange/UDPReceiver.h

@@ -17,7 +17,7 @@
  * ===============
  * Собственно реализация сделана так:
  * В данных передаётся номер пакета. На случай если несколько пакетов придут не в той последовательности
- * что были посланы, сделана очередь с приориеттом. В качестве приориета используется номер пакета
+ * что были посланы, сделана очередь с приоритетом. В качестве приориета используется номер пакета
  * (чем меньше тем старше). И при этом эта очередь постоянно поддерживается наполненной на minBufSize записей.
  * Это гарантирует, что соседние пакеты пришедшие не в той последовательности, тем не менее обработаны будут в правильной.
  * Т.к. в очереди они "отсортируются" по номеру пакета, ещё до обработки.
@@ -27,11 +27,11 @@
  * ===
  * Для оптимизации работы с SM, т.к. в пакетах приходят только пары [id,value] сделан кэш итераторов.
  * Кэш расчитан на то, что принимаемые пакеты всегда имеют одну и ту же длину и последовательность.
- * Идея проста: сделан вектор размером с количество принимаемы данных. В векторе хранятся итераторы (и всё что необходимо).
+ * Идея проста: сделан вектор размером с количество принимаемых данных. В векторе хранятся итераторы (и всё что необходимо).
  * Порядокый номер данных в пакете является индексом в кэше.
  * Для защиты от изменения поседовательности внутри пакета, в кэше хранится ID сохраняемого датчика, и если он не совпадёт с тем,
  * ID который пришёл в пакете - элемент кэша обновляется.
- * Если количество пришедших данных не совпадают с размеров кэша.. кэш обновляется.
+ * Если количество пришедших данных не совпадают с размером кэша.. кэш обновляется.
  */
 // -----------------------------------------------------------------------------
 class UDPReceiver:
@@ -47,6 +47,7 @@ class UDPReceiver:
 
 		/*! глобальная функция для вывода help-а */
 		static void help_print( int argc, char* argv[] );
+
 	protected:
 
 		xmlNode* cnode;

extensions/UDPExchange/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"
+// -----------------------------------------------------------------------------
+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();
+
+		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;
+};
+// -----------------------------------------------------------------------------
+#endif // UNetExchange_H_
+// -----------------------------------------------------------------------------

extensions/UDPExchange/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),
+recvTimeout(5000),
+udp(0),
+activated(false),
+r_thr(0),
+u_thr(0),
+minBufSize(30),
+maxProcessingCount(100),
+icache(200),
+cache_init_ok(false)
+{
+	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);
+
+	{
+		ostringstream s;
+		s << "(" << s_host << ":" << port << ")";
+		myname = s.str();
+	}
+
+	ptRecvTimeout.setTiming(recvTimeout);
+}
+// -----------------------------------------------------------------------------
+UNetReceiver::~UNetReceiver()
+{
+	delete r_thr;
+	delete u_thr;
+	delete udp;
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setReceiveTimeout( int msec )
+{
+	recvTimeout = msec;
+	ptRecvTimeout.setTiming(msec);
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setReceivePause( int msec )
+{
+	recvpause = msec;
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setUpdatePause( int msec )
+{
+	updatepause = msec;
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setMinBudSize( int set )
+{
+	minBufSize = set;
+}
+// -----------------------------------------------------------------------------
+void UNetReceiver::setMaxProcessingCount( int set )
+{
+	maxProcessingCount = 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;
+	bool buf_ok = false;
+	{
+		uniset_mutex_lock l(packMutex);
+		if( qpack.size() <= minBufSize )
+			return;
+
+		buf_ok = true;
+	}
+
+	int k = maxProcessingCount;
+	while( buf_ok && k>0 )
+	{
+		{
+			uniset_mutex_lock l(packMutex);
+			p = qpack.top();
+			qpack.pop();
+		}
+
+		if( labs(p.msg.header.num - pnum) > 1 )
+		{
+			dlog[Debug::CRIT] << "************ FAILED! ORDER PACKETS! recv.num=" << pack.msg.header.num
+				  << " num=" << pnum << endl;
+		}
+
+		pnum = p.msg.header.num;
+		k--;
+
+		{
+			uniset_mutex_lock l(packMutex);
+			buf_ok =  ( qpack.size() > minBufSize );
+		}
+
+		initCache(p, !cache_init_ok);
+
+		for( int 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) )
+	{
+		cerr << 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 )
+	{
+		cerr << myname << "(receive): FAILED data ret=" << ret << " sizeof=" << sz << endl;
+		return false;
+	}
+
+
+	cerr << myname << "(receive): recv DATA OK. ret=" << ret << " sizeof=" << sz
+		  << " header: " << pack.msg.header << endl;
+/*
+	if( labs(pack.msg.header.num - pnum) > 1 )
+	{
+		cerr << "************ FAILED! ORDER PACKETS! recv.num=" << pack.msg.header.num
+				<< " num=" << pnum << endl;
+	}
+
+	pnum = pack.msg.header.num;
+*/
+	{
+		uniset_mutex_lock l(packMutex);
+		qpack.push(pack);
+	}
+
+	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( int 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/UDPExchange/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.
+ * ===============
+ * Собственно реализация сделана так:
+ * В данных передаётся номер пакета. На случай если несколько пакетов придут не в той последовательности
+ * что были посланы, сделана очередь с приоритетом. В качестве приориета используется номер пакета
+ * (чем меньше тем старше). И при этом эта очередь постоянно поддерживается наполненной на minBufSize записей.
+ * Это гарантирует, что соседние пакеты пришедшие не в той последовательности, тем не менее обработаны будут в правильной.
+ * Т.к. в очереди они "отсортируются" по номеру пакета, ещё до обработки.
+ *
+ *
+ * КЭШ
+ * ===
+ * Для оптимизации работы с SM, т.к. в пакетах приходят только пары [id,value] сделан кэш итераторов.
+ * Кэш расчитан на то, что принимаемые пакеты всегда имеют одну и ту же длину и последовательность.
+ * Идея проста: сделан вектор размером с количество принимаемых данных. В векторе хранятся итераторы (и всё что необходимо).
+ * Порядокый номер данных в пакете является индексом в кэше.
+ * Для защиты от изменения поседовательности внутри пакета, в кэше хранится ID сохраняемого датчика, и если он не совпадёт с тем,
+ * ID который пришёл в пакете - элемент кэша обновляется.
+ * Если количество пришедших данных не совпадают с размером кэша.. кэш обновляется.
+ */
+// -----------------------------------------------------------------------------
+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(); }
+
+		 void setReceiveTimeout( int msec );
+		 void setReceivePause( int msec );
+		 void setUpdatePause( int msec );
+
+		 void setMinBudSize( int 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::UDPDuplex* udp;
+		ost::IPV4Address addr;
+		ost::tpport_t port;
+		std::string myname;
+
+		UniSetTypes::uniset_mutex pollMutex;
+		PassiveTimer ptRecvTimeout;
+		int recvTimeout;
+
+		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;		/*!< прсто буфер для получения очерещного сообщения */
+		UniSetTypes::uniset_mutex packMutex; /*!< mutex для работы с очередью */
+		long pnum;	/*!< текущий номер обработанного сообщения, для проверки непрерывности последовательности пакетов */
+
+		/*! Минимальный размер очереди.
+		 * Предназначен для создания буфера, чтобы обработка сообщений шла
+		 * в порядке возрастания номеров пакетов. Даже если при приёме последовательность нарушалась
+		 */
+		int minBufSize;
+
+		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/UDPExchange/start_fg_receiver.sh

 #!/bin/sh
 
-uniset-start.sh -f ./uniset-udpreceiver --udp-name UDPExchange \
-	--udp-host 192.168.1.255 --udp-port 3000 \
+uniset-start.sh -f ./uniset-udpexchange --udp-name UDPExchange \
 	--confile test.xml \
 	--udp-filter-field udp --udp-filter-value 1 \
 	--dlog-add-levels info,crit,warn