(unet2): Предварительная реализация "обновления" данных для посылки в сеть

extensions/UNet2/UDPPacket.cc

@@ -43,3 +43,14 @@ bool UDPMessage::addData( long id, long val)
 	return addData(d);
 }
 // -----------------------------------------------------------------------------
+bool UDPMessage::setData( unsigned int index, long val )
+{
+	if( index < MaxDataCount )
+	{
+		msg.dat[index].val = val;
+		return true;
+	}
+
+	return false;
+}
+// -----------------------------------------------------------------------------

extensions/UNet2/UDPPacket.h

@@ -49,6 +49,7 @@ namespace UniSetUDP
 
 		bool addData( const UDPData& dat );
 		bool addData( long id, long val );
+		bool setData( unsigned int index, long val );
 
 		inline bool isFull(){ return count<MaxDataCount; }
 		inline int size(){ return count; }

extensions/UNet2/UNetExchange.cc

@@ -367,12 +367,15 @@ void UNetExchange::askSensors( UniversalIO::UIOCommand cmd )
 		kill(SIGTERM,getpid());	// прерываем (перезапускаем) процесс...
 		throw SystemError(err.str());
 	}
+
+	if( sender )
+		sender->askSensors(cmd);
 }
 // ------------------------------------------------------------------------------------------
 void UNetExchange::sensorInfo( UniSetTypes::SensorMessage* sm )
 {
 	if( sender )
-		sender->update(sm->id,sm->value);
+		sender->updateSensor(sm->id,sm->value);
 }
 // ------------------------------------------------------------------------------------------
 bool UNetExchange::activateObject()
@@ -395,12 +398,30 @@ void UNetExchange::sigterm( int signo )
 {
 	cerr << myname << ": ********* SIGTERM(" << signo <<") ********" << endl;
 	activated = false;
+	for( ReceiverList::iterator it=recvlist.begin(); it!=recvlist.end(); ++it )
+	{
+		try
+		{
+			(*it)->stop();
+		}
+		catch(...){}
+	}
+
+	try
+	{
+		if( sender )
+			sender->stop();
+	}
+	catch(...){}
+
 	UniSetObject_LT::sigterm(signo);
 }
 // ------------------------------------------------------------------------------------------
 void UNetExchange::initIterators()
 {
 	shm->initAIterator(aitHeartBeat);
+	if( sender )
+		sender->initIterators();
 }
 // -----------------------------------------------------------------------------
 void UNetExchange::help_print( int argc, const char* argv[] )

extensions/UNet2/UNetReceiver.cc

@@ -209,6 +209,8 @@ void UNetReceiver::real_update()
 					shm->initDIterator(ii.dit);
 				}
 
+				if( d.id == 121 )
+					cerr << "****** save id=" << d.id << " val=" << d.val << endl;
 				if( ii.iotype == UniversalIO::DigitalInput )
 					shm->localSaveState(ii.dit,d.id,d.val,shm->ID());
 				else if( ii.iotype == UniversalIO::AnalogInput )
@@ -233,6 +235,14 @@ void UNetReceiver::real_update()
 }
 
 // -----------------------------------------------------------------------------
+void UNetReceiver::stop()
+{
+	activated = false;
+//	msleep(10);
+//	u_thr->stop();
+//	r_thr->stop();
+}
+// -----------------------------------------------------------------------------
 void UNetReceiver::receive()
 {
 	cout << myname << ": ******************* receive start" << endl;
@@ -305,10 +315,15 @@ bool UNetReceiver::recv()
 
 	rnum = pack.msg.header.num;
 
-//	cerr << myname << "(receive): recv DATA OK. ret=" << ret << " sizeof=" << sz
-//		  << " header: " << pack.msg.header
-//		  << " waitClean=" << waitClean
-//		  << endl;
+	cerr << myname << "(receive): recv DATA OK. ret=" << ret << " sizeof=" << sz
+		  << " header: " << pack.msg.header
+		  << " waitClean=" << waitClean
+		  << endl;
+	for( size_t i=0; i<pack.msg.header.dcount; i++ )
+	{
+		UniSetUDP::UDPData& d = pack.msg.dat[i];
+		cerr << "****** save id=" << d.id << " val=" << d.val << endl;
+	}
 
 	{	// lock qpack
 		uniset_mutex_lock l(packMutex,500);

extensions/UNet2/UNetReceiver.h

@@ -53,6 +53,7 @@ class UNetReceiver
 		~UNetReceiver();
 
 		 void start();
+		 void stop();
 
 		 void receive();
 		 void update();

extensions/UNet2/UNetSender.cc

@@ -74,20 +74,49 @@ UNetSender::~UNetSender()
 	delete shm;
 }
 // -----------------------------------------------------------------------------
-void UNetSender::update( UniSetTypes::ObjectId id, long value )
+void UNetSender::updateFromSM()
 {
 	DMap::iterator it=dlist.begin();
 	for( ; it!=dlist.end(); ++it )
 	{
-		if( it->si.id == id )
+		long value = 0;
+
+		if( it->iotype == UniversalIO::DigitalInput || it->iotype == UniversalIO::DigitalOutput )
+			value = shm->localGetState(it->dit,it->id) ? 1 : 0;
+		else if( it->iotype == UniversalIO::AnalogInput || it->iotype == UniversalIO::AnalogOutput )
+			value = shm->localGetValue(it->ait,it->id);
+		else
 		{
-			uniset_spin_lock lock(it->val_lock);
-			it->val = value;
+			dlog[Debug::CRIT] << myname << "(update): Unknown iotype for sid=" << it->id << endl;
+			continue;
 		}
-		break;
+
+		updateItem(it,value);
 	}
 }
 // -----------------------------------------------------------------------------
+void UNetSender::updateSensor( UniSetTypes::ObjectId id, long value )
+{
+	DMap::iterator it=dlist.begin();
+	for( ; it!=dlist.end(); ++it )
+	{
+		if( it->id == id )
+		{
+			updateItem( it, value );
+			break;
+		}
+	}
+}
+// -----------------------------------------------------------------------------
+void UNetSender::updateItem( DMap::iterator& it, long value )
+{
+	if( it != dlist.end() )
+		return;
+
+	UniSetTypes::uniset_mutex_lock l(pack_mutex,100);
+	mypack.setData(it->pack_ind,value);
+}
+// -----------------------------------------------------------------------------
 void UNetSender::send()
 {
 	dlist.resize(maxItem);
@@ -133,6 +162,7 @@ void UNetSender::send()
 // -----------------------------------------------------------------------------
 void UNetSender::real_send()
 {
+	UniSetTypes::uniset_mutex_lock l(pack_mutex,300);
 	mypack.msg.header.num = packetnum++;
 
 	if( packetnum > UniSetUDP::MaxPacketNum )
@@ -148,6 +178,12 @@ void UNetSender::real_send()
 		dlog[Debug::CRIT] << myname << "(real_send): FAILED ret=" << ret << " < sizeof=" << sz << endl;
 }
 // -----------------------------------------------------------------------------
+void UNetSender::stop()
+{
+	activated = false;
+//	s_thr->stop();
+}
+// -----------------------------------------------------------------------------
 void UNetSender::start()
 {
 	if( !activated )
@@ -229,10 +265,22 @@ bool UNetSender::initItem( UniXML_iterator& it )
 	}
 
 	UItem p;
-	p.si.id = sid;
-	p.si.node = conf->getLocalNode();
+	p.id = sid;
 	mypack.addData(sid,0);
 	p.pack_ind = mypack.size()-1;
+	p.iotype = UniSetTypes::getIOType(it.getProp("iotype"));
+
+	if( p.iotype == UniversalIO::UnknownIOType )
+	{
+		dlog[Debug::CRIT] << myname << "(update): Unknown iotype for sid=" << sid << endl;
+		return false;
+	}
+
+	if( shm )
+	{
+		shm->initDIterator(p.dit);
+		shm->initAIterator(p.ait);
+	}
 
 	if( maxItem >= dlist.size() )
 		dlist.resize(maxItem+10);
@@ -247,6 +295,11 @@ bool UNetSender::initItem( UniXML_iterator& it )
 }
 
 // ------------------------------------------------------------------------------------------
+std::ostream& operator<<( std::ostream& os, UNetSender::UItem& p )
+{
+	return os << " sid=" << p.id;
+}
+// -----------------------------------------------------------------------------
 void UNetSender::initIterators()
 {
 	DMap::iterator it=dlist.begin();
@@ -257,8 +310,10 @@ void UNetSender::initIterators()
 	}
 }
 // -----------------------------------------------------------------------------
-std::ostream& operator<<( std::ostream& os, UNetSender::UItem& p )
+void UNetSender::askSensors( UniversalIO::UIOCommand cmd )
 {
-	return os 	<< " sid=" << p.si.id;
+	DMap::iterator it=dlist.begin();
+	for( ; it!=dlist.end(); it++ )
+		shm->askSensor(it->id,cmd);
 }
 // -----------------------------------------------------------------------------

extensions/UNet2/UNetSender.h

@@ -29,27 +29,44 @@ class UNetSender
 		struct UItem
 		{
 			UItem():
-				val(0)
-			{}
+				iotype(UniversalIO::UnknownIOType),
+				id(UniSetTypes::DefaultObjectId),
+				pack_ind(-1){}
 
-			IOController_i::SensorInfo si;
+			UniversalIO::IOTypes iotype;
+			UniSetTypes::ObjectId id;
 			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 );
 		};
 
+		typedef std::vector<UItem> DMap;
+
 		void start();
+		void stop();
 
 		void send();
 		void real_send();
-		void update( UniSetTypes::ObjectId id, long value );
+
+		/*! (принудительно) обновить все данные (из SM) */
+		void updateFromSM();
+
+		/*! Обновить значение по ID датчика */
+		void updateSensor( UniSetTypes::ObjectId id, long value );
+
+		/*! Обновить значение по итератору */
+		void updateItem( DMap::iterator& it, long value );
 
 		inline void setSendPause( int msec ){ sendpause = msec; }
 
+		/*! заказать датчики */
+		void askSensors( UniversalIO::UIOCommand cmd );
+
+		/*! инициализация  итераторов */
+		void initIterators();
+
 	protected:
 
 		std::string s_field;
@@ -57,7 +74,6 @@ class UNetSender
 
 		SMInterface* shm;
 
-		void initIterators();
 		bool initItem( UniXML_iterator& it );
 		bool readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec );
 
@@ -76,8 +92,8 @@ class UNetSender
 		int sendpause;
 		bool activated;
 
+		UniSetTypes::uniset_mutex pack_mutex;
 		UniSetUDP::UDPMessage mypack;
-		typedef std::vector<UItem> DMap;
 		DMap dlist;
 		int maxItem;
 		unsigned long packetnum;

extensions/UNet2/unetexchange.cc

 #include <sstream>
+#include <sys/wait.h>
 #include "ObjectsActivator.h"
 #include "Extensions.h"
 #include "UNetExchange.h"
@@ -68,6 +69,7 @@ int main( int argc, const char** argv )
 		dlog[Debug::ANY] << "(main): -------------- UDPReceiver START -------------------------\n\n";
 
 		act.run(false);
+		while (waitpid(-1, 0, 0));
 	}
 	catch( Exception& ex )
 	{
@@ -84,5 +86,6 @@ int main( int argc, const char** argv )
 		dlog[Debug::CRIT] << "(unetexchange): catch ..." << std::endl;
 	}
 
+	while (waitpid(-1, 0, 0));
 	return 0;
 }