testing

Utilities/MBTester/mbtcptester.cc

@@ -146,19 +146,19 @@ int main( int argc, char **argv )
 					}
 				break;
 
-				case 'i':	
+				case 'i':
 					iaddr = string(optarg);
 				break;
 
-				case 'p':	
+				case 'p':
 					port = atoi(optarg);
 				break;
 
-				case 't':	
+				case 't':
 					tout = atoi(optarg);
 				break;
 
-				case 'a':	
+				case 'a':
 					myaddr = ModbusRTU::str2mbAddr(optarg);
 				break;
 
@@ -178,198 +178,201 @@ int main( int argc, char **argv )
 			cout << "(init): ip=" << iaddr << ":" << port
 					<< " myaddr=" << ModbusRTU::addr2str(myaddr)
 					<< " timeout=" << tout << " msec "
-					<< endl;					
-		}		
-		
-		ModbusTCPMaster mb;
+					<< endl;
 
-		if( verb )
 			dlog.addLevel( Debug::type(Debug::CRIT | Debug::WARN | Debug::INFO) );
-
+		}
+		
+		ModbusTCPMaster mb;
 		mb.setLog(dlog);
 
-		ost::Thread::setException(ost::Thread::throwException);
+//		ost::Thread::setException(ost::Thread::throwException);
 		ost::InetAddress ia(iaddr.c_str());
-		mb.connect(ia,port);
 		mb.setTimeout(tout);
+		mb.connect(ia,port);
 
-		
-		switch(cmd)
+		while( 1)
 		{
-			case cmdRead01:
+
+			switch(cmd)
 			{
-				if( verb )
+				case cmdRead01:
 				{
-					cout << "read01: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
-						 << " reg=" << ModbusRTU::dat2str(reg) 
-						 << " count=" << ModbusRTU::dat2str(count) 
-						 << endl;
-				}
+					if( verb )
+					{
+						cout << "read01: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+							 << " reg=" << ModbusRTU::dat2str(reg) 
+							 << " count=" << ModbusRTU::dat2str(count) 
+							 << endl;
+					}
 
-				ModbusRTU::ReadCoilRetMessage ret = mb.read01(slaveaddr,reg,count);
-				if( verb )
-					cout << "(reply): " << ret << endl;
-				cout << "(reply): count=" << (int)ret.bcnt << endl;
-				for( int i=0; i<ret.bcnt; i++ )
-				{
-					ModbusRTU::DataBits b(ret.data[i]);
-				
-					cout << i <<": (" << ModbusRTU::dat2str( reg + i ) << ") = (" 
-						<< ModbusRTU::b2str(ret.data[i]) << ") " << b << endl;
+					ModbusRTU::ReadCoilRetMessage ret = mb.read01(slaveaddr,reg,count);
+					if( verb )
+						cout << "(reply): " << ret << endl;
+					cout << "(reply): count=" << (int)ret.bcnt << endl;
+					for( int i=0; i<ret.bcnt; i++ )
+					{
+						ModbusRTU::DataBits b(ret.data[i]);
+					
+						cout << i <<": (" << ModbusRTU::dat2str( reg + i ) << ") = (" 
+							<< ModbusRTU::b2str(ret.data[i]) << ") " << b << endl;
+					}
 				}
-			}
-			break;
+				break;
 
-			case cmdRead02:
-			{
-				if( verb )
+				case cmdRead02:
 				{
-					cout << "read02: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+					if( verb )
+					{
+						cout << "read02: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
 						 << " reg=" << ModbusRTU::dat2str(reg) 
 						 << " count=" << ModbusRTU::dat2str(count) 
 						 << endl;
-				}
+					}
 
-				ModbusRTU::ReadInputStatusRetMessage ret = mb.read02(slaveaddr,reg,count);
-				if( verb )
-					cout << "(reply): " << ret << endl;
-				cout << "(reply): count=" << (int)ret.bcnt << endl;
-				for( int i=0; i<ret.bcnt; i++ )
-				{
-					ModbusRTU::DataBits b(ret.data[i]);
-				
-					cout << i <<": (" << ModbusRTU::dat2str( reg + i ) << ") = (" 
-						<< ModbusRTU::b2str(ret.data[i]) << ") " << b << endl;
+					ModbusRTU::ReadInputStatusRetMessage ret = mb.read02(slaveaddr,reg,count);
+					if( verb )
+						cout << "(reply): " << ret << endl;
+					cout << "(reply): count=" << (int)ret.bcnt << endl;
+					for( int i=0; i<ret.bcnt; i++ )
+					{
+						ModbusRTU::DataBits b(ret.data[i]);
+					
+						cout << i <<": (" << ModbusRTU::dat2str( reg + i ) << ") = (" 
+							<< ModbusRTU::b2str(ret.data[i]) << ") " << b << endl;
+					}
 				}
-			}
-			break;
+				break;
 
-			case cmdRead03:
-			{
-				if( verb )
+				case cmdRead03:
 				{
-					cout << "read03: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
-						 << " reg=" << ModbusRTU::dat2str(reg)
-						 << " count=" << ModbusRTU::dat2str(count) 
-						 << endl;
-				}
+					if( verb )
+					{
+						cout << "read03: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+							 << " reg=" << ModbusRTU::dat2str(reg)
+							 << " count=" << ModbusRTU::dat2str(count) 
+							 << endl;
+					}
 
-				ModbusRTU::ReadOutputRetMessage ret = mb.read03(slaveaddr,reg,count);
-				if( verb )
-					cout << "(reply): " << ret << endl;
-				cout << "(reply): count=" << ModbusRTU::dat2str(ret.count) << endl;
-				for( int i=0; i<ret.count; i++ )
-				{
-					cout << i <<": (" << ModbusRTU::dat2str( reg + i ) << ") = " << (int)(ret.data[i]) 
-						<< " (" 
-						<< ModbusRTU::dat2str(ret.data[i]) 
-						<< ")" 
-						<< endl;
+					ModbusRTU::ReadOutputRetMessage ret = mb.read03(slaveaddr,reg,count);
+					if( verb )
+						cout << "(reply): " << ret << endl;
+					cout << "(reply): count=" << ModbusRTU::dat2str(ret.count) << endl;
+					for( int i=0; i<ret.count; i++ )
+					{
+						cout << i <<": (" << ModbusRTU::dat2str( reg + i ) << ") = " << (int)(ret.data[i]) 
+							<< " (" 
+							<< ModbusRTU::dat2str(ret.data[i]) 
+							<< ")" 
+							<< endl;
+					}
 				}
-			}
-			break;
+				break;
 			
-			case cmdRead04:
-			{
-				if( verb )
+				case cmdRead04:
 				{
-					cout << "read04: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
-						 << " reg=" << ModbusRTU::dat2str(reg) 
-						 << " count=" << ModbusRTU::dat2str(count) 
-						 << endl;
-				}
+					if( verb )
+					{
+						cout << "read04: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+							 << " reg=" << ModbusRTU::dat2str(reg) 
+							 << " count=" << ModbusRTU::dat2str(count) 
+							 << endl;
+					}
 
-				ModbusRTU::ReadInputRetMessage ret = mb.read04(slaveaddr,reg,count);
-				if( verb )
-					cout << "(reply): " << ret << endl;
-				cout << "(reply): count=" << ModbusRTU::dat2str(ret.count) << endl;
-				for( int i=0; i<ret.count; i++ )
-				{
-					cout << i <<": (" << ModbusRTU::dat2str( reg + i ) << ") = " << (int)(ret.data[i]) 
-						<< " (" 
-						<< ModbusRTU::dat2str(ret.data[i]) 
-						<< ")" 
-						<< endl;
+					ModbusRTU::ReadInputRetMessage ret = mb.read04(slaveaddr,reg,count);
+					if( verb )
+						cout << "(reply): " << ret << endl;
+					cout << "(reply): count=" << ModbusRTU::dat2str(ret.count) << endl;
+					for( int i=0; i<ret.count; i++ )
+					{
+						cout << i <<": (" << ModbusRTU::dat2str( reg + i ) << ") = " << (int)(ret.data[i]) 
+							<< " (" 
+							<< ModbusRTU::dat2str(ret.data[i]) 
+							<< ")" 
+							<< endl;
+					}
 				}
-			}
-			break;
+				break;
 
-			case cmdWrite05:
-			{
-				if( verb )
+				case cmdWrite05:
 				{
-					cout << "write05: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
-						 << " reg=" << ModbusRTU::dat2str(reg) 
-						 << " val=" << ModbusRTU::dat2str(val) 
-						 << endl;
+					if( verb )
+					{
+						cout << "write05: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+							 << " reg=" << ModbusRTU::dat2str(reg) 
+							 << " val=" << ModbusRTU::dat2str(val) 
+							 << endl;
+					}
+					
+					ModbusRTU::ForceSingleCoilRetMessage  ret = mb.write05(slaveaddr,reg,(bool)val);
+					if( verb )
+						cout << "(reply): " << ret << endl;
 				}
-				
-				ModbusRTU::ForceSingleCoilRetMessage  ret = mb.write05(slaveaddr,reg,(bool)val);
-				if( verb )
-					cout << "(reply): " << ret << endl;
-			}
-			break;
+				break;
 
-			case cmdWrite06:
-			{
-				if( verb )
+				case cmdWrite06:
 				{
-					cout << "write06: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
-						 << " reg=" << ModbusRTU::dat2str(reg) 
-						 << " val=" << ModbusRTU::dat2str(val) 
-						 << endl;
+					if( verb )
+					{
+						cout << "write06: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+							 << " reg=" << ModbusRTU::dat2str(reg) 
+							 << " val=" << ModbusRTU::dat2str(val) 
+							 << endl;
+					}
+					
+					ModbusRTU::WriteSingleOutputRetMessage  ret = mb.write06(slaveaddr,reg,val);
+					if( verb )
+						cout << "(reply): " << ret << endl;
+					
 				}
-				
-				ModbusRTU::WriteSingleOutputRetMessage  ret = mb.write06(slaveaddr,reg,val);
-				if( verb )
-					cout << "(reply): " << ret << endl;
-				
-			}
-			break;
+				break;
 
-			case cmdWrite0F:
-			{
-				if( verb )
+				case cmdWrite0F:
 				{
-					cout << "write0F: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
-						 << " reg=" << ModbusRTU::dat2str(reg) 
-						 << " val=" << ModbusRTU::dat2str(val) 
-						 << endl;
+					if( verb )
+					{
+						cout << "write0F: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+							 << " reg=" << ModbusRTU::dat2str(reg) 
+							 << " val=" << ModbusRTU::dat2str(val) 
+							 << endl;
+					}
+					
+					ModbusRTU::ForceCoilsMessage msg(slaveaddr,reg);
+					ModbusRTU::DataBits16 b(val);
+					msg.addData(b);
+					ModbusRTU::ForceCoilsRetMessage  ret = mb.write0F(msg);
+					if( verb )
+						cout << "(reply): " << ret << endl;
 				}
-				
-				ModbusRTU::ForceCoilsMessage msg(slaveaddr,reg);
-				ModbusRTU::DataBits16 b(val);
-				msg.addData(b);
-				ModbusRTU::ForceCoilsRetMessage  ret = mb.write0F(msg);
-				if( verb )
-					cout << "(reply): " << ret << endl;
-			}
-			break;
+				break;
 
-			case cmdWrite10:
-			{
-				if( verb )
+				case cmdWrite10:
 				{
-					cout << "write06: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
-						 << " reg=" << ModbusRTU::dat2str(reg) 
-						 << " val=" << ModbusRTU::dat2str(val) 
-						 << endl;
+					if( verb )
+					{
+						cout << "write06: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+							 << " reg=" << ModbusRTU::dat2str(reg) 
+							 << " val=" << ModbusRTU::dat2str(val) 
+							 << endl;
+					}
+					
+					ModbusRTU::WriteOutputMessage msg(slaveaddr,reg);
+					msg.addData(val);
+					ModbusRTU::WriteOutputRetMessage  ret = mb.write10(msg);
+					if( verb )
+						cout << "(reply): " << ret << endl;
 				}
-				
-				ModbusRTU::WriteOutputMessage msg(slaveaddr,reg);
-				msg.addData(val);
-				ModbusRTU::WriteOutputRetMessage  ret = mb.write10(msg);
-				if( verb )
-					cout << "(reply): " << ret << endl;
+				break;
+
+				case cmdNOP:
+				default:
+					cerr << "No command. Use -h for help." << endl;
+					return 1;
 			}
-			break;
 
-			case cmdNOP:
-			default:
-				cerr << "No command. Use -h for help." << endl;
-				return 1;
-		}
-		
+			msleep(200);
+		} // end of while
+
 		mb.disconnect();
 	}
 	catch( ModbusRTU::mbException& ex )

conf/test.xml

@@ -93,7 +93,7 @@
 	<sensors name="Sensors">
 		<item name="Input1_S" textname=" 1" node="" iotype="DI" priority="Medium" default="1" />
 		<item name="Input2_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x31" mbfunc="0x04" mbreg="0x02" rs="1" />
-		<item name="Input3_S" textname=" 3" node="" iotype="DI" priority="Medium" udp="1"/>
+		<item name="Input3_S" textname=" 3" node="" iotype="DI" priority="Medium" mbtcp="1" mbaddr="0x31" mbfunc="0x04" mbreg="0x02"/>
 		<item name="Input4_S" textname=" 4" node="" iotype="DI" priority="Medium" udp="1"/>
 		<item name="Input5_S" textname=" 5" node="" iotype="DI" priority="Medium" udp="2"/>
 		<item name="Input6_S" textname=" 6" node="" iotype="DI" priority="Medium" udp="2">

extentions/MBTCPMaster/MBMaster.cc

@@ -9,6 +9,7 @@
 using namespace std;
 using namespace UniSetTypes;
 using namespace UniSetExtentions;
+using namespace ModbusRTU;
 // -----------------------------------------------------------------------------
 MBMaster::MBMaster( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, SharedMemory* ic,
 						std::string prefix):
@@ -18,6 +19,7 @@ maxItem(0),
 mb(0),
 shm(0),
 initPause(0),
+mbregFromID(false),
 force(false),
 force_out(false),
 activated(false),
@@ -55,13 +57,16 @@ prefix(prefix)
 
 	recv_timeout = atoi(conf->getArgParam("--" + prefix + "-recv-timeout",it.getProp("recv_timeout")).c_str());
 	if( recv_timeout <= 0 )
-		recv_timeout = 100;
+		recv_timeout = 2000;
 
 	string saddr = conf->getArgParam("--" + prefix + "-my-addr",it.getProp("addr"));
 	myaddr = ModbusRTU::str2mbAddr(saddr);
 	if( saddr.empty() )
 		myaddr = 0x00;
 
+	mbregFromID = atoi(conf->getArgParam("--" + prefix + "-reg-from-id",it.getProp("reg_from_id")).c_str());
+	dlog[Debug::INFO] << myname << "(init): mbregFromID=" << mbregFromID << endl;
+
 	polltime = atoi(conf->getArgParam("--" + prefix + "-polltime",it.getProp("polltime")).c_str());
 	if( !polltime )
 		polltime = 100;
@@ -133,6 +138,8 @@ prefix(prefix)
 // -----------------------------------------------------------------------------
 MBMaster::~MBMaster()
 {
+	if( mb )
+		mb->disconnect();
 	delete mb;
 }
 // -----------------------------------------------------------------------------
@@ -205,6 +212,7 @@ void MBMaster::init_mb()
 		mb = new ModbusTCPMaster();
 		mb->connect(ia,port);
 		mb->setTimeout(recv_timeout);
+		mb->setLog(dlog);
 	}
 	catch( Exception& ex )
 	{
@@ -241,24 +249,23 @@ void MBMaster::poll()
 		{
 			if( it->stype == UniversalIO::AnalogInput )
 			{
-				long val = callItem(it);
+				long val = readReg(it);
 				IOBase::processingAsAI( ib, val, shm, force );
 			}
 			else if( it->stype == UniversalIO::DigitalInput )
 			{
-				bool set = callItem(it) ? true : false;
+				bool set = readReg(it) ? true : false;
 				IOBase::processingAsDI( ib, set, shm, force );
 			}
 			else if( it->stype == UniversalIO::AnalogOutput )
 			{
-				cerr << myname << "(poll): AnalogOutput   !!! (sid=" << it->si.id << ")" << endl;
-//				IOBase::processingAO( &ib, val );
+				long val = IOBase::processingAsAO(ib,shm,force_out);
+				writeReg(it,val);
 			}
 			else if( it->stype == UniversalIO::DigitalOutput )
 			{
-//				if( force_out )
-//					it->value = shm->localGetState(it->dit,it->si.id);
-//				bool set IOBase::processingAO( &ib, val );
+				long val = IOBase::processingAsDO(ib,shm,force_out) ? 1 : 0;
+				writeReg(it,val);
 			}
 		}
 		catch(ModbusRTU::mbException& ex )
@@ -293,25 +300,82 @@ void MBMaster::poll()
 	}
 }
 // -----------------------------------------------------------------------------
-long MBMaster::callItem( MBMap::iterator& p )
+long MBMaster::readReg( MBMap::iterator& p )
 {
-	unsigned short v1=0, v2=0;
-	if( p->mbfunc == ModbusRTU::fnReadInputRegisters )
+	try
 	{
-		ModbusRTU::ReadInputRetMessage ret = mb->read04(p->mbaddr, p->mbreg,1);
-		return ret.data[0];
+		if( p->mbfunc == ModbusRTU::fnReadInputRegisters )
+		{	
+//			if( dlog.debugging(Debug::LEVEL3) )
+//				dlog[Debug::LEVEL3] << " read from " << ModbusRTU::addr2str(p->mbaddr) << " reg=" << ModbusRTU::dat2str(p->mbreg) << endl;
+			cerr << " read from " << ModbusRTU::addr2str(p->mbaddr) << " reg=" << ModbusRTU::dat2str(p->mbreg) << endl;
+			ModbusRTU::ReadInputRetMessage ret = mb->read04(p->mbaddr,p->mbreg,1);
+			return ret.data[0];
+		}
+	
+		if( p->mbfunc == ModbusRTU::fnReadOutputRegisters )
+		{
+			ModbusRTU::ReadOutputRetMessage ret = mb->read03(p->mbaddr,p->mbreg,1);
+			return ret.data[0];
+		}
+
+		cerr << myname << "(readReg):    " << (int)p->mbfunc << endl;
 	}
-	else if( p->mbfunc == ModbusRTU::fnReadOutputRegisters )
+	catch( ModbusRTU::mbException& ex )
 	{
-		ModbusRTU::ReadOutputRetMessage ret = mb->read03(p->mbaddr, p->mbreg,1);
-		return ret.data[0];
+		dlog[Debug::CRIT] << "(readReg): " << ex << endl;
 	}
-	else
-		cerr << myname << "(callItem):    " << (int)p->mbfunc << endl;
-//		return 0;
+	catch(SystemError& err)
+	{
+		dlog[Debug::CRIT] << "(readReg): " << err << endl;
+	}
+	catch(Exception& ex)
+	{
+		dlog[Debug::CRIT] << "(readReg): " << ex << endl;
+	}
+	catch( ost::SockException& e ) 
+	{
+		dlog[Debug::CRIT] << "(readReg): " << e.getString() << ": " << e.getSystemErrorString() << endl;
+	}
+
 	return 0;
 }
 // -----------------------------------------------------------------------------
+bool MBMaster::writeReg( MBMap::iterator& p, long val )
+{
+	if( p->mbfunc == fnWriteOutputRegisters )
+	{
+		ModbusRTU::WriteOutputMessage msg(p->mbaddr,p->mbreg);
+		msg.addData(val);
+		ModbusRTU::WriteOutputRetMessage ret = mb->write10(msg);
+		return true;
+	}
+
+	if( p->mbfunc == ModbusRTU::fnForceSingleCoil )
+	{
+		ModbusRTU::ForceSingleCoilRetMessage ret = mb->write05(p->mbaddr,p->mbreg,(bool)val);
+		return false;
+	}
+	
+	if( p->mbfunc == fnWriteOutputSingleRegister )
+	{
+		ModbusRTU::WriteSingleOutputRetMessage  ret = mb->write06(p->mbaddr,p->mbreg,val);
+		return true;
+	}
+	
+	if( p->mbfunc == fnForceMultipleCoils )
+	{
+		ModbusRTU::ForceCoilsMessage msg(p->mbaddr,p->mbreg);
+		ModbusRTU::DataBits16 b(val);
+		msg.addData(b);
+		ModbusRTU::ForceCoilsRetMessage  ret = mb->write0F(msg);
+		return true;
+	}
+
+	cerr << myname << "(writeReg):    " << (int)p->mbfunc << endl;
+	return false;
+}
+// -----------------------------------------------------------------------------
 void MBMaster::processingMessage(UniSetTypes::VoidMessage *msg)
 {
 	try
@@ -365,6 +429,13 @@ void MBMaster::sysCommand(UniSetTypes::SystemMessage *sm)
 	{
 		case SystemMessage::StartUp:
 		{
+			if( mbmap.empty() )
+			{
+				dlog[Debug::CRIT] << myname << "(sysCommand): mbmap EMPTY! terminated..." << endl;
+				raise(SIGTERM);
+				return; 
+			}
+		
 			waitSMReady();
 
 			//   ģ  
@@ -393,7 +464,7 @@ void MBMaster::sysCommand(UniSetTypes::SystemMessage *sm)
 			//  
 			if( !force )
 			{
-				uniset_mutex_lock l(pollMutex,2000);	
+				uniset_mutex_lock l(pollMutex,2000);
 				force = true;
 				poll();
 				force = false;
@@ -461,9 +532,7 @@ void MBMaster::initOutput()
 // ------------------------------------------------------------------------------------------
 void MBMaster::askSensors( UniversalIO::UIOCommand cmd )
 {
-#warning   testid
-	UniSetTypes::ObjectId testid = 4100; // (notRespondSensor!=DefaultObjectId) ? notRespondSensor : 4100; //TestMode_S
-	if( !shm->waitSMworking(testid,activateTimeout,50) )
+	if( !shm->waitSMworking(test_id,activateTimeout,50) )
 	{
 		ostringstream err;
 		err << myname 
@@ -498,7 +567,27 @@ void MBMaster::askSensors( UniversalIO::UIOCommand cmd )
 // ------------------------------------------------------------------------------------------
 void MBMaster::sensorInfo( UniSetTypes::SensorMessage* sm )
 {
-	
+	MBMap::iterator it=mbmap.begin();
+	for( ; it!=mbmap.end(); ++it )
+	{
+		if( it->stype != UniversalIO::DigitalOutput && it->stype!=UniversalIO::AnalogOutput )
+			continue;
+
+		if( it->si.id == sm->id )
+		{
+			if( it->stype == UniversalIO::DigitalOutput )
+			{
+				uniset_spin_lock lock(it->val_lock);
+				it->value = sm->state ? 1 : 0;
+			}
+			else if( it->stype == UniversalIO::AnalogOutput )
+			{
+				uniset_spin_lock lock(it->val_lock);
+				it->value = sm->value;
+			}
+			break;
+		}
+	}
 }
 // ------------------------------------------------------------------------------------------
 bool MBMaster::activateObject()
@@ -600,28 +689,54 @@ bool MBMaster::readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec )
 // ------------------------------------------------------------------------------------------
 bool MBMaster::initItem( UniXML_iterator& it )
 {
-	cerr << "********** init item *************" << endl;
-
 	MBProperty p;
+
 	if( !IOBase::initItem( static_cast<IOBase*>(&p),it,shm,&dlog,myname) )
 		return false;
 
-	cerr << "********** init item(2) *************" << endl;
-
 	string addr = it.getProp("mbaddr");
 	if( addr.empty() )
 		return true;
 
+	if( mbregFromID )
+		p.mbreg = p.si.id;
+	else
+	{
+		string r = it.getProp("mbreg");
+		if( r.empty() )
+		{
+			dlog[Debug::CRIT] << myname << "(initItem): Unknown 'mbreg' for " << it.getProp("name") << endl;
+			return false;
+		}
+		p.mbreg = ModbusRTU::str2mbData(r);
+	}
+
 	p.mbaddr 	= ModbusRTU::str2mbAddr(addr);
-	
-	if( p.stype == UniversalIO::AnalogInput )
+
+	string stype( it.getProp("mb_iotype") );
+	if( stype.empty() )
+		stype = it.getProp("iotype");
+
+	if( stype == "AI" )
+	{
+		p.stype 	= UniversalIO::AnalogInput;
 		p.mbfunc  	= ModbusRTU::fnReadInputRegisters;
-	else if ( p.stype == UniversalIO::DigitalInput )
+	}
+	else if ( stype == "DI" )
+	{
+		p.stype 	= UniversalIO::DigitalInput;
 		p.mbfunc  	= ModbusRTU::fnReadInputRegisters;
-	else if ( p.stype == UniversalIO::AnalogOutput )
+	}
+	else if ( stype == "AO" )
+	{
+		p.stype 	= UniversalIO::AnalogOutput;
 		p.mbfunc  	= ModbusRTU::fnWriteOutputRegisters;
-	else if ( p.stype == UniversalIO::DigitalOutput )
+	}
+	else if ( stype == "DO" )
+	{
+		p.stype 	= UniversalIO::DigitalOutput;
 		p.mbfunc  	= ModbusRTU::fnWriteOutputRegisters;
+	}
 
 	string f = it.getProp("mbfunc");
 	if( !f.empty() )
@@ -629,13 +744,33 @@ bool MBMaster::initItem( UniXML_iterator& it )
 		p.mbfunc = (ModbusRTU::SlaveFunctionCode)UniSetTypes::uni_atoi(f.c_str());
 		if( p.mbfunc == ModbusRTU::fnUnknown )
 		{
-			dlog[Debug::CRIT] << myname << "(initCommParam):  mbfunc ='" << f
+			dlog[Debug::CRIT] << myname << "(initItem):  mbfunc ='" << f
 					<< "'    " << it.getProp("name") << endl;
 
 			return false;
 		}
 	}
 
+	if( p.mbfunc == ModbusRTU::fnReadCoilStatus ||
+		p.mbfunc == ModbusRTU::fnReadInputStatus )
+	{
+		string nb = it.getProp("nbit");
+		if( nb.empty() )
+		{
+			dlog[Debug::CRIT] << myname << "(initItem): Unknown nbit. for " 
+					<< it.getProp("name") 
+					<< " mbfunc=" << p.mbfunc
+					<< endl;
+
+			return false;
+		}
+		
+		p.nbit = UniSetTypes::uni_atoi(nb.c_str());
+	}
+
+	if( dlog.debugging(Debug::INFO) )
+		dlog[Debug::INFO] << myname << "(initItem): add " << p << endl;
+
 	//    
 	//     10  ( )
 	//    resize

extentions/MBTCPMaster/MBMaster.h

@@ -43,10 +43,11 @@ class MBMaster:
 			ModbusRTU::ModbusAddr mbaddr;			/*!<   */
 			ModbusRTU::ModbusData mbreg;			/*!<  */
 			ModbusRTU::SlaveFunctionCode mbfunc;	/*!<   / */
+			short nbit;		/*!< bit number (for func=[0x01,0x02]) */
 
 			MBProperty():	
 				mbaddr(0),mbreg(0),
-				mbfunc(ModbusRTU::fnUnknown)
+				mbfunc(ModbusRTU::fnUnknown),nbit(0)
 			{}
 
 			friend std::ostream& operator<<( std::ostream& os, MBProperty& p );
@@ -80,7 +81,8 @@ class MBMaster:
 		void askSensors( UniversalIO::UIOCommand cmd );	
 		void initOutput();
 		void waitSMReady();
-		long callItem( MBMap::iterator& p );
+		long readReg( MBMap::iterator& p );
+		bool writeReg( MBMap::iterator& p, long val );
 
 		virtual bool activateObject();
 		
@@ -100,6 +102,7 @@ class MBMaster:
 		bool initPause;
 		UniSetTypes::uniset_mutex mutex_start;
 
+		bool mbregFromID;
 		bool force;		/*!<  ,     SM,      */
 		bool force_out;	/*!<  ,    */
 		int polltime;	/*!<   , [] */
@@ -113,6 +116,7 @@ class MBMaster:
 		Trigger trTimeout;
 		PassiveTimer ptTimeout;
 		
+		
 		bool activated;
 		int activateTimeout;
 		std::string prefix;

extentions/MBTCPMaster/start_fg.sh

 #!/bin/sh
 
 uniset-start.sh -f ./uniset-mbtcpmaster --mbtcp-name MBMaster1 --confile test.xml \
---dlog-add-levels info,crit,warn --mbtcp-reg-from-id 1 \
---mbtcp-iaddr 127.0.0.1 --mbtcp-port 30000
+--dlog-add-levels info,crit,warn \
+--mbtcp-iaddr 127.0.0.1 --mbtcp-port 2048 \
+--mbtcp-filter-field mbtcp --mbtcp-filter-value 1
+
+#--mbtcp-reg-from-id 1
\ No newline at end of file

extentions/ModbusSlave/MBSlave.cc

@@ -13,7 +13,8 @@ using namespace UniSetTypes;
 using namespace UniSetExtentions;
 using namespace ModbusRTU;
 // -----------------------------------------------------------------------------
-MBSlave::MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, SharedMemory* ic ):
+MBSlave::MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, 
+					SharedMemory* ic, string prefix ):
 UniSetObject_LT(objId),
 mbslot(0),
 shm(0),
@@ -21,8 +22,8 @@ initPause(0),
 activated(false),
 pingOK(true),
 force(false),
-force_out(false),
-mbregFromID(false)
+mbregFromID(false),
+prefix(prefix)
 {
 	cout << "$Id: MBSlave.cc,v 1.1 2009/01/11 19:08:45 vpashka Exp $" << endl;
 
@@ -39,36 +40,35 @@ mbregFromID(false)
 	UniXML_iterator it(cnode);
 
 	//  
-	s_field = conf->getArgParam("--mbs-s-filter-field");
-	s_fvalue = conf->getArgParam("--mbs-s-filter-value");
+	s_field = conf->getArgParam("--" + prefix + "-filter-field");
+	s_fvalue = conf->getArgParam("--" + prefix + "-filter-value");
 	dlog[Debug::INFO] << myname << "(init): read s_field='" << s_field
 						<< "' s_fvalue='" << s_fvalue << "'" << endl;
 
-	force 		= atoi(conf->getArgParam("--mbs-force",it.getProp("force")).c_str());
-	force_out 	= atoi(conf->getArgParam("--mbs-force-out",it.getProp("force_out")).c_str());
+	force 		= atoi(conf->getArgParam("--" + prefix + "-force",it.getProp("force")).c_str());
 
-	int recv_timeout = atoi(conf->getArgParam("--mbs-recv-timeout",it.getProp("recv_timeout")).c_str());
+	int recv_timeout = atoi(conf->getArgParam("--" + prefix + "-recv-timeout",it.getProp("recv_timeout")).c_str());
 
-	string saddr = conf->getArgParam("--mbs-my-addr",it.getProp("addr"));
+	string saddr = conf->getArgParam("--" + prefix + "-my-addr",it.getProp("addr"));
 
 	if( saddr.empty() )
 		addr = 0x01;
 	else
 		addr = ModbusRTU::str2mbAddr(saddr);
 
-	mbregFromID = atoi(conf->getArgParam("--mbs-reg-from-id",it.getProp("reg_from_id")).c_str());
+	mbregFromID = atoi(conf->getArgParam("--" + prefix + "-reg-from-id",it.getProp("reg_from_id")).c_str());
 	dlog[Debug::INFO] << myname << "(init): mbregFromID=" << mbregFromID << endl;
 
-	string stype = conf->getArgParam("--mbs-type",it.getProp("type"));
+	string stype = conf->getArgParam("--" + prefix + "-type",it.getProp("type"));
 	
 	if( stype == "RTU" )
 	{
 		// ---------- init RS ----------
-		string dev	= conf->getArgParam("--mbs-dev",it.getProp("device"));
+		string dev	= conf->getArgParam("--" + prefix + "-dev",it.getProp("device"));
 		if( dev.empty() )
 			throw UniSetTypes::SystemError(myname+"(MBSlave): Unknown device...");
 
-		string speed 	= conf->getArgParam("--mbs-speed",it.getProp("speed"));
+		string speed 	= conf->getArgParam("--" + prefix + "-speed",it.getProp("speed"));
 		if( speed.empty() )
 			speed = "38400";
 
@@ -87,11 +87,11 @@ mbregFromID(false)
 	}
 	else if( stype == "TCP" )
 	{
-		string iaddr = conf->getArgParam("--mbs-inet-addr",it.getProp("iaddr"));
+		string iaddr = conf->getArgParam("--" + prefix + "-inet-addr",it.getProp("iaddr"));
 		if( iaddr.empty() )
 			throw UniSetTypes::SystemError(myname+"(MBSlave): Unknown TCP server address. Use: --mbs-inet-addr [ XXX.XXX.XXX.XXX| hostname ]");
 		
-		int port = atoi(conf->getArgParam("--mbs-inet-port",it.getProp("iport")).c_str());
+		int port = atoi(conf->getArgParam("--" + prefix + "-inet-port",it.getProp("iport")).c_str());
 		if( port <=0 )
 			port = 502;
 	
@@ -122,7 +122,7 @@ mbregFromID(false)
 //	mbslot->connectRemoteService( sigc::mem_fun(this, &MBSlave::remoteService) );
 	// -------------------------------
 
-	initPause = atoi(conf->getArgParam("--mbs-initPause",it.getProp("initPause")).c_str());
+	initPause = atoi(conf->getArgParam("--" + prefix + "-initPause",it.getProp("initPause")).c_str());
 	if( !initPause )
 		initPause = 3000;
 
@@ -135,7 +135,7 @@ mbregFromID(false)
 		ic->addReadItem( sigc::mem_fun(this,&MBSlave::readItem) );
 
 	// ********** HEARTBEAT *************
-	string heart = conf->getArgParam("--mbs-heartbeat-id",it.getProp("heartbeat_id"));
+	string heart = conf->getArgParam("--" + prefix + "-heartbeat-id",it.getProp("heartbeat_id"));
 	if( !heart.empty() )
 	{
 		sidHeartBeat = conf->getSensorID(heart);
@@ -153,7 +153,7 @@ mbregFromID(false)
 		else
 			ptHeartBeat.setTiming(UniSetTimer::WaitUpTime);
 
-		maxHeartBeat = atoi(conf->getArgParam("--mbs-heartbeat-max",it.getProp("heartbeat_max")).c_str());
+		maxHeartBeat = atoi(conf->getArgParam("--" + prefix + "-heartbeat-max",it.getProp("heartbeat_max")).c_str());
 		if( maxHeartBeat <=0 )
 			maxHeartBeat = 10;
 
@@ -177,11 +177,11 @@ mbregFromID(false)
 	if( wait_msec < 500 )
 		wait_msec = 500;
 
-	activateTimeout	= atoi(conf->getArgParam("--activate-timeout").c_str());
+	activateTimeout	= atoi(conf->getArgParam("--" + prefix + "-activate-timeout").c_str());
 	if( activateTimeout<=0 )
 		activateTimeout = 20000;
 
-	int msec = atoi(conf->getArgParam("--mbs-timeout",it.getProp("timeout")).c_str());
+	int msec = atoi(conf->getArgParam("--" + prefix + "-timeout",it.getProp("timeout")).c_str());
 	if( msec <=0 )
 		msec = 3000;
 
@@ -249,7 +249,7 @@ MBSlave::~MBSlave()
 void MBSlave::waitSMReady()
 {
 	// waiting for SM is ready...
-	int ready_timeout = atoi(conf->getArgParam("--mbs-sm-ready-timeout","15000").c_str());
+	int ready_timeout = atoi(conf->getArgParam("--" + prefix + "-sm-ready-timeout","15000").c_str());
 	if( ready_timeout == 0 )
 		ready_timeout = 15000;
 	else if( ready_timeout < 0 )
@@ -374,6 +374,13 @@ void MBSlave::processingMessage(UniSetTypes::VoidMessage *msg)
 			}
 			break;
 
+			case Message::SensorInfo:
+			{
+				SensorMessage sm( msg );
+				sensorInfo(&sm);
+			}
+			break;
+
 			default:
 				break;
 		}
@@ -478,7 +485,6 @@ void MBSlave::sysCommand(UniSetTypes::SystemMessage *sm)
 // ------------------------------------------------------------------------------------------
 void MBSlave::askSensors( UniversalIO::UIOCommand cmd )
 {
-#warning   testid
 	if( !shm->waitSMworking(test_id,activateTimeout,50) )
 	{
 		ostringstream err;
@@ -491,17 +497,19 @@ void MBSlave::askSensors( UniversalIO::UIOCommand cmd )
 		throw SystemError(err.str());
 	}
 
+	if( force )
+		return;
+
 	IOMap::iterator it=iomap.begin();
 	for( ; it!=iomap.end(); ++it )
 	{
 		IOProperty* p(&it->second);
 		
-		if( p->stype != UniversalIO::DigitalOutput && p->stype != UniversalIO::AnalogOutput )
-			continue;
-
-		if( p->safety == NoSafetyState )
-			continue;
+//		if( p->stype != UniversalIO::DigitalOutput && p->stype != UniversalIO::AnalogOutput )
+//			continue;
 
+//		if( p->safety == NoSafetyState )
+//			continue;
 		try
 		{
 			shm->askSensor(p->si.id,cmd);
@@ -519,18 +527,17 @@ void MBSlave::sensorInfo( UniSetTypes::SensorMessage* sm )
 	IOMap::iterator it=iomap.begin();
 	for( ; it!=iomap.end(); ++it )
 	{
-		if( it->second.stype != UniversalIO::DigitalOutput && it->second.stype!=UniversalIO::AnalogOutput )
-			continue;
-
 		if( it->second.si.id == sm->id )
 		{
 			IOProperty* p(&it->second);
-			if( p->stype == UniversalIO::DigitalOutput )
+			if( p->stype == UniversalIO::DigitalOutput ||
+				p->stype == UniversalIO::DigitalInput )
 			{
 				uniset_spin_lock lock(p->val_lock);
 				p->value = sm->state ? 1 : 0;
 			}
-			else if( p->stype == UniversalIO::AnalogOutput )
+			else if( p->stype == UniversalIO::AnalogOutput ||
+					p->stype == UniversalIO::AnalogInput )
 			{
 				uniset_spin_lock lock(p->val_lock);
 				p->value = sm->value;
@@ -621,45 +628,23 @@ bool MBSlave::initItem( UniXML_iterator& it )
 {
 	IOProperty p;
 
-	string sname(it.getProp("name"));
-	ObjectId sid = DefaultObjectId;
-	
-	if( it.getProp("id").empty() )
-		sid = conf->getSensorID(sname);
-	else
-	{
-		sid = UniSetTypes::uni_atoi(it.getProp("id").c_str());
-		if( sid <=0 )
-			sid = DefaultObjectId;
-	}
-	
-	if( sid == DefaultObjectId )
-	{
-		dlog[Debug::CRIT] << myname << "(readItem): (-1)    ID  : "
-						<< sname << endl;
+	if( !IOBase::initItem( static_cast<IOBase*>(&p),it,shm,&dlog,myname) )
 		return false;
-	}
 
 	if( mbregFromID )
-		p.mbreg = sid;
+		p.mbreg = p.si.id;
 	else
 	{
 		string r = it.getProp("mbreg");
 		if( r.empty() )
 		{
-			dlog[Debug::CRIT] << myname << "(initItem): Unknown 'mbreg' for " << sname << endl;
+			dlog[Debug::CRIT] << myname << "(initItem): Unknown 'mbreg' for " << it.getProp("name") << endl;
 			return false;
 		}
+		
+		p.mbreg = ModbusRTU::str2mbData(r);
 	}
 	
-	p.si.id		= sid;
-	p.si.node 	= conf->getLocalNode();
-	p.value		= atoi(it.getProp("default").c_str());
-
-	p.ignore 	= atoi(it.getProp("ignore").c_str());
-	p.safety 	= atoi(it.getProp("safety").c_str());
-	p.invert 	= atoi(it.getProp("invert").c_str());
-
 	string stype( it.getProp("mb_iotype") );
 	if( stype.empty() )
 		stype = it.getProp("iotype");
@@ -705,30 +690,6 @@ bool MBSlave::initItem( UniXML_iterator& it )
 		}
 	}
 
-	p.cal.minRaw = 0;
-	p.cal.maxRaw = 0;
-	p.cal.minCal = 0;
-	p.cal.maxCal = 0;
-	p.cal.sensibility = 0;
-	p.cal.precision = 0;
-	p.cdiagram = 0;
-
-	if( p.stype == 	UniversalIO::AnalogInput || p.stype == 	UniversalIO::AnalogOutput )
-	{
-		p.cal.minRaw = atoi( it.getProp("rmin").c_str() );
-		p.cal.maxRaw = atoi( it.getProp("rmax").c_str() );
-		p.cal.minCal = atoi( it.getProp("cmin").c_str() );
-		p.cal.maxCal = atoi( it.getProp("cmax").c_str() );
-		p.cal.sensibility = atoi( it.getProp("sensibility").c_str() );
-		p.cal.precision = atoi( it.getProp("precision").c_str() );
-
-		std::string caldiagram( it.getProp("caldiagram") );
-		if( !caldiagram.empty() )
-			p.cdiagram = buildCalibrationDiagram( caldiagram );
-	}
-
-	shm->initAIterator(p.ait);
-	shm->initDIterator(p.dit);
 	iomap[p.mbreg] = p;
 	
 	if( dlog.debugging(Debug::INFO) )
@@ -751,29 +712,31 @@ void MBSlave::initIterators()
 // -----------------------------------------------------------------------------
 void MBSlave::help_print( int argc, char* argv[] )
 {
-	cout << "--mbs-heartbeat-id		-       heartbeat-." << endl;
-	cout << "--mbs-heartbeat-max  	-   heartbeat-ޣ   .   10." << endl;
-	cout << "--mbs-ready-timeout	-    SM  , . (-1 -  '')" << endl;    
-	cout << "--mbs-initPause		-    (   )" << endl;
-	cout << "--mbs-notRespondSensor -      " << endl;
-	cout << "--mbs-sm-ready-timeout -     SM" << endl;
-	cout << "--mbs-recv-timeout -    ." << endl;
-	cout << "--mbs-allow-setdatetime - On set date and time (0x50) modbus function" << endl;
-	cout << "--mbs-my-addr      -   " << endl;
-	cout << "--mbs-type [RTU|TCP] - modbus server type." << endl;
+	cout << "Default: prefix='mbtcp'" << endl;
+	cout << "--prefix-heartbeat-id		-       heartbeat-." << endl;
+	cout << "--prefix-heartbeat-max  	-   heartbeat-ޣ   .   10." << endl;
+	cout << "--prefix-ready-timeout	-    SM  , . (-1 -  '')" << endl;    
+	cout << "--prefix-initPause		-    (   )" << endl;
+	cout << "--prefix-notRespondSensor -      " << endl;
+	cout << "--prefix-sm-ready-timeout -     SM" << endl;
+	cout << "--prefix-recv-timeout -    ." << endl;
+	cout << "--prefix-allow-setdatetime - On set date and time (0x50) modbus function" << endl;
+	cout << "--prefix-my-addr      -   " << endl;
+	cout << "--prefix-type [RTU|TCP] - modbus server type." << endl;
 
 	cout << "   RTU: " << endl;
-	cout << "--mbs-dev devname  -  " << endl;
-	cout << "--mbs-speed        -   (9600,19920,38400,57600,115200)." << endl;
+	cout << "--prefix-dev devname  -  " << endl;
+	cout << "--prefix-speed        -   (9600,19920,38400,57600,115200)." << endl;
 
 	cout << "   TCP: " << endl;
-	cout << "--mbs-inet-addr [xxx.xxx.xxx.xxx | hostname ]  - this modbus server address" << endl;
-	cout << "--mbs-inet-port num - this modbus server port. Default: 502" << endl;
+	cout << "--prefix-inet-addr [xxx.xxx.xxx.xxx | hostname ]  - this modbus server address" << endl;
+	cout << "--prefix-inet-port num - this modbus server port. Default: 502" << endl;
 }
 // -----------------------------------------------------------------------------
-MBSlave* MBSlave::init_mbslave( int argc, char* argv[], UniSetTypes::ObjectId icID, SharedMemory* ic )
+MBSlave* MBSlave::init_mbslave( int argc, char* argv[], UniSetTypes::ObjectId icID, SharedMemory* ic,
+								string prefix )
 {
-	string name = conf->getArgParam("--mbs-name","MBSlave1");
+	string name = conf->getArgParam("--" + prefix + "-name","MBSlave1");
 	if( name.empty() )
 	{
 		cerr << "(mbslave):   name'" << endl;
@@ -1001,7 +964,7 @@ ModbusRTU::mbErrCode MBSlave::real_read( ModbusRTU::ModbusData reg,
 	{
 		if( dlog.debugging(Debug::INFO) )
 		{
-			dlog[Debug::INFO] << myname << "(read): read mbID=" 
+			dlog[Debug::INFO] << myname << "(real_read): read mbID=" 
 				<< ModbusRTU::dat2str(reg) << endl;
 		}
 
@@ -1033,29 +996,29 @@ ModbusRTU::mbErrCode MBSlave::real_read( ModbusRTU::ModbusData reg,
 	}
 	catch( UniSetTypes::NameNotFound& ex )
 	{
-		dlog[Debug::WARN] << myname << "(read): " << ex << endl;
+		dlog[Debug::WARN] << myname << "(real_read): " << ex << endl;
 		return ModbusRTU::erBadDataAddress;
 	}
 	catch( UniSetTypes::OutOfRange& ex )
 	{
-		dlog[Debug::WARN] << myname << "(read): " << ex << endl;
+		dlog[Debug::WARN] << myname << "(real_read): " << ex << endl;
 		return ModbusRTU::erBadDataValue;
 	}
 	catch( Exception& ex )
 	{
 		if( pingOK )
-			dlog[Debug::CRIT] << myname << "(read): " << ex << endl;
+			dlog[Debug::CRIT] << myname << "(real_read): " << ex << endl;
 	}
 	catch( CORBA::SystemException& ex )
 	{
 		if( pingOK )
-			dlog[Debug::CRIT] << myname << "(read): ORBA::SystemException: "
+			dlog[Debug::CRIT] << myname << "(real_read): CORBA::SystemException: "
 				<< ex.NP_minorString() << endl;
 	}
 	catch(...)
 	{
 		if( pingOK )
-			dlog[Debug::CRIT] << myname << "(read) catch ..." << endl;
+			dlog[Debug::CRIT] << myname << "(real_read) catch ..." << endl;
 	}
 	
 	pingOK = false;

extentions/ModbusSlave/MBSlave.h

@@ -13,7 +13,6 @@
 #include "PassiveTimer.h"
 #include "Trigger.h"
 #include "Mutex.h"
-#include "Calibration.h"
 #include "SMInterface.h"
 #include "SharedMemory.h"
 #include "IOBase.h"
@@ -23,12 +22,13 @@ class MBSlave:
 	public UniSetObject_LT
 {
 	public:
-		MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0 );
+		MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0, std::string prefix="mbs" );
 		virtual ~MBSlave();
 	
 		/*!      */
 		static MBSlave* init_mbslave( int argc, char* argv[], 
-											UniSetTypes::ObjectId shmID, SharedMemory* ic=0 );
+											UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+											std::string prefix="mbs" );
 
 		/*!     help- */
 		static void help_print( int argc, char* argv[] );
@@ -172,12 +172,12 @@ class MBSlave:
 		bool pingOK;
 		int wait_msec;
 		bool force;		/*!<  ,     SM,      */
-		bool force_out;	/*!<  ,    */
 
 		bool mbregFromID;
 
 		typedef std::map<int,std::string> FileList;
 		FileList flist;
+		std::string prefix;
 };
 // -----------------------------------------------------------------------------
 #endif // _MBSlave_H_

extentions/ModbusSlave/start_tcp_fg.sh

 #!/bin/sh
 
 uniset-start.sh -f ./uniset-mbslave --mbs-name MBSlave1 --confile test.xml --dlog-add-levels info,crit,warn \
-	--mbs-type TCP --mbs-inet-addr 127.0.0.2 --mbs-inet-port 2048  --mbs-reg-from-id 1
+	--mbs-type TCP --mbs-inet-addr 127.0.0.1 --mbs-inet-port 2048 \
\ No newline at end of file
+	--mbs-filter-field rs --mbs-filter-value 1
+	# --mbs-force 1
+	#--mbs-reg-from-id 1 \
\ No newline at end of file

extentions/lib/IOBase.cc

@@ -252,18 +252,20 @@ bool IOBase::initItem( IOBase* b, UniXML_iterator& it, SMInterface* shm,
 {
 	string sname( it.getProp("name") );
 
-	ObjectId sid = UniSetTypes::uni_atoi(it.getProp("id").c_str());
-	if( sid <=0 )
+	ObjectId sid = DefaultObjectId;
+	if( it.getProp("id").empty() )
+		sid = conf->getSensorID(sname);
+	else
 	{
-		if( dlog )
-			dlog[Debug::CRIT] << myname << "(readItem):    ID  : "
-							<< sname << endl;
-		return false;
+		sid = UniSetTypes::uni_atoi(it.getProp("id").c_str());
+		if( sid <=0 )
+			sid = DefaultObjectId;
 	}
 	
 	if( sid == DefaultObjectId )
 	{
-		dlog[Debug::CRIT] << myname << "(readItem): (-1)    ID  : "
+		if( dlog )
+			dlog[Debug::CRIT] << myname << "(readItem): (-1)    ID  : "
 						<< sname << endl;
 		return false;
 	}

extentions/lib/SMInterface.cc

@@ -439,16 +439,16 @@ void SMInterface::initAIterator( IOController::AIOStateList::iterator& it )
 {
 	if( ic )
 		it = ic->aioEnd();
-	else	
-		cerr << "(SMInterface::initAIterator): ic=NULL" << endl;
+//	else	
+//		cerr << "(SMInterface::initAIterator): ic=NULL" << endl;
 }
 // --------------------------------------------------------------------------
 void SMInterface::initDIterator( IOController::DIOStateList::iterator& it )
 {
 	if( ic )
 		it = ic->dioEnd();
-	else	
-		cerr << "(SMInterface::initDIterator): ic=NULL" << endl;
+//	else
+//		cerr << "(SMInterface::initDIterator): ic=NULL" << endl;
 }
 // --------------------------------------------------------------------------
 bool SMInterface::waitSMready( int ready_timeout, int pmsec )

include/modbus/ModbusTCPMaster.h

@@ -24,6 +24,8 @@ class ModbusTCPMaster:
 		bool isConnection();
 
 	protected:
+		
+		void reconnect();
 
 		virtual int getNextData( unsigned char* buf, int len );
 		virtual void setChannelTimeout( int msec );
@@ -35,6 +37,8 @@ class ModbusTCPMaster:
 		ost::TCPStream* tcp;
 		static int nTransaction;
 		std::queue<unsigned char> qrecv;
+		PassiveTimer ptTimeout;
+		std::string iaddr;
 };
 // -------------------------------------------------------------------------
 #endif // ModbusTCPMaster_H_

src/Communications/Modbus/ModbusTCPMaster.cc

@@ -13,7 +13,8 @@ using namespace ModbusRTU;
 using namespace UniSetTypes;
 // -------------------------------------------------------------------------
 ModbusTCPMaster::ModbusTCPMaster():
-tcp(0)
+tcp(0),
+iaddr("")
 {
 	setCRCNoCheckit(true);
 }
@@ -46,13 +47,16 @@ int ModbusTCPMaster::nTransaction = 0;
 mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg, 
 				 			ModbusMessage& reply, int timeout )
 {
-	if( !isConnection() )
+
+//	if( !isConnection() )
+	if( iaddr.empty() )
 	{
 		dlog[Debug::WARN] << "(query): not connection to server..." << endl;
 		return erHardwareError;
+
 	}
 
-	PassiveTimer ptTimeout;
+	reconnect();
 
 	if( timeout<=0 || timeout == UniSetTimer::WaitUpTime )
 	{
@@ -66,6 +70,9 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 	
 	try
 	{
+		if( nTransaction >= numeric_limits<int>::max() )
+			nTransaction = 0;
+		
 		ModbusTCP::MBAPHeader mh;
 		mh.tID = ++nTransaction;
 		mh.pID = 0;
@@ -89,7 +96,7 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 		mbErrCode res = send(msg);
 		if( res!=erNoError )
 			return res;
-
+		
   		if( !tcp->isPending(ost::Socket::pendingOutput,timeout) )
   			return erTimeOut;
 
@@ -159,6 +166,17 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 	return erHardwareError;
 }
 // -------------------------------------------------------------------------
+void ModbusTCPMaster::reconnect()
+{
+	if( tcp )
+	{
+		tcp->disconnect();
+		delete tcp;
+	}
+	
+	tcp = new ost::TCPStream(iaddr.c_str());
+}
+// -------------------------------------------------------------------------
 void ModbusTCPMaster::connect( ost::InetAddress addr, int port )
 {
 	if( !tcp )
@@ -169,7 +187,8 @@ void ModbusTCPMaster::connect( ost::InetAddress addr, int port )
 		if( dlog.debugging(Debug::INFO) )
 			dlog[Debug::INFO] << "(ModbusTCPMaster): connect to " << s.str() << endl;
 		
-		tcp = new ost::TCPStream(s.str().c_str());
+		iaddr = s.str();
+		tcp = new ost::TCPStream(iaddr.c_str());
 	}
 }
 // -------------------------------------------------------------------------