Merge branch 'master' into utf8

IDL/Processes/IOController_i.idl

@@ -291,6 +291,7 @@ interface IONotifyController_i : IOController_i
 		ThresholdState state;	
 		long tv_sec;			/*!< время последнего изменения датчика, секунды (gettimeofday) */
 		long tv_usec;			/*!< время последнего изменения датчика, мксек (gettimeofday) */
+		boolean inverse;		/*!< инверсная логика */
 	};
 
 	typedef sequence<ThresholdInfo> ThresholdInfoSeq;

conf/libuniset.spec

@@ -2,8 +2,8 @@
 %define oname uniset
 
 Name: libuniset
-Version: 0.98
-Release: eter1
+Version: 0.97
+Release: eter59
 Summary: UniSet - library for building distributed industrial control systems
 License: GPL
 Group: Development/C++
@@ -143,7 +143,8 @@ rm -f %buildroot%_libdir/*.la
 %_bindir/%oname-iocalibr
 %_bindir/%oname-logicproc
 %_bindir/%oname-plogicproc
-%_bindir/mtrconv
+%_bindir/mtr-conv
+%_bindir/mtr-setup
 %_bindir/vtconv
 %_bindir/rtustate
 %_bindir/%oname-rtuexchange
@@ -183,6 +184,19 @@ rm -f %buildroot%_libdir/*.la
 %exclude %_pkgconfigdir/libUniSet.pc
 
 %changelog
+
+* Sun Mar 14 2010 Pavel Vainerman <pv@altlinux.ru> 0.97-eter58
+- minor fixes in MTR setup API
+
+* Sun Mar 14 2010 Pavel Vainerman <pv@altlinux.ru> 0.97-eter57
+- add MTR setup (API and utility)
+
+* Sat Mar 13 2010 Pavel Vainerman <pv@altlinux.ru> 0.97-eter56
+- new build
+
+* Fri Mar 12 2010 Pavel Vainerman <pv@altlinux.ru> 0.97-eter55
+- new build
+
 * Wed Mar 03 2010 Ilya Shpigor <elly@altlinux.org> 0.98-eter1
 - new build for Sisyphus with utf8 support
 

extensions/ModbusSlave/MBSlave.cc

@@ -21,6 +21,8 @@ shm(0),
 initPause(0),
 test_id(DefaultObjectId),
 askcount_id(DefaultObjectId),
+respond_id(DefaultObjectId),
+respond_invert(false),
 askCount(0),
 activated(false),
 activateTimeout(500),
@@ -63,6 +65,9 @@ prefix(prefix)
 	mbregFromID = conf->getArgInt("--" + prefix + "-reg-from-id",it.getProp("reg_from_id"));
 	dlog[Debug::INFO] << myname << "(init): mbregFromID=" << mbregFromID << endl;
 
+	respond_id = conf->getSensorID(conf->getArgParam("--" + prefix + "-respond-id",it.getProp("respond_id")));
+	respond_invert = conf->getArgInt("--" + prefix + "-respond-invert",it.getProp("respond_invert"));
+
 	string stype = conf->getArgParam("--" + prefix + "-type",it.getProp("type"));
 	
 	if( stype == "RTU" )
@@ -96,16 +101,18 @@ prefix(prefix)
 	{
 		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 ]");
+			throw UniSetTypes::SystemError(myname+"(MBSlave): Unknown TCP server address. Use: --prefix-inet-addr [ XXX.XXX.XXX.XXX| hostname ]");
 		
 		int port = conf->getArgPInt("--" + prefix + "-inet-port",it.getProp("iport"), 502);
+
+		dlog[Debug::INFO] << myname << "(init): type=TCP myaddr=" << ModbusRTU::addr2str(addr) 
+			<< " inet=" << iaddr << " port=" << port << endl;
 	
 		ost::InetAddress ia(iaddr.c_str());
 		mbslot	= new ModbusTCPServerSlot(ia,port);
 		thr = new ThreadCreator<MBSlave>(this,&MBSlave::execute_tcp);
 
-		dlog[Debug::INFO] << myname << "(init): type=TCP myaddr=" << ModbusRTU::addr2str(addr) 
-			<< " inet=" << iaddr << " port=" << port << endl;
+		dlog[Debug::INFO] << myname << "(init): init TCP connection ok. " << " inet=" << iaddr << " port=" << port << endl;
 	}
 	else
 		throw UniSetTypes::SystemError(myname+"(MBSlave): Unknown slave type. Use: --mbs-type [RTU|TCP]");
@@ -119,7 +126,7 @@ prefix(prefix)
 	mbslot->connectWriteOutput( sigc::mem_fun(this, &MBSlave::writeOutputRegisters) );
 	mbslot->connectWriteSingleOutput( sigc::mem_fun(this, &MBSlave::writeOutputSingleRegister) );
 
-	if( findArgParam("--mbs-allow-setdatetime",conf->getArgc(),conf->getArgv())!=-1 )
+	if( findArgParam("--" + prefix + "-allow-setdatetime",conf->getArgc(),conf->getArgv())!=-1 )
 		mbslot->connectSetDateTime( sigc::mem_fun(this, &MBSlave::setDateTime) );
 	
 	mbslot->connectFileTransfer( sigc::mem_fun(this, &MBSlave::fileTransfer) );	
@@ -306,6 +313,23 @@ void MBSlave::execute_rtu()
 				}
 			}
 
+			if( respond_id != DefaultObjectId )
+			{
+				bool state = ptTimeout.checkTime() ? false : true;
+				if( respond_invert )
+					state ^= true;
+
+				try
+				{
+					shm->localSaveState(ditRespond,respond_id,state,getId());
+				}
+				catch(Exception& ex)
+				{
+					dlog[Debug::CRIT] << myname
+						<< "(execute_rtu): (respond) " << ex << std::endl;
+				}
+			}
+
 			if( askcount_id!=DefaultObjectId )
 			{
 				try
@@ -370,6 +394,22 @@ void MBSlave::execute_tcp()
 				}
 			}
 
+			if( respond_id != DefaultObjectId )
+			{
+				bool state = ptTimeout.checkTime() ? false : true;
+				if( respond_invert )
+					state ^= true;
+				try
+				{
+					shm->localSaveState(ditRespond,respond_id,state,getId());
+				}
+				catch(Exception& ex)
+				{
+					dlog[Debug::CRIT] << myname
+						<< "(execute_rtu): (respond) " << ex << std::endl;
+				}
+			}
+
 			if( askcount_id!=DefaultObjectId )
 			{
 				try
@@ -729,6 +769,7 @@ void MBSlave::initIterators()
 
 	shm->initAIterator(aitHeartBeat);
 	shm->initAIterator(aitAskCount);
+	shm->initDIterator(ditRespond);
 }
 // -----------------------------------------------------------------------------
 void MBSlave::help_print( int argc, const char* const* argv )
@@ -741,6 +782,9 @@ void MBSlave::help_print( int argc, const char* const* argv )
 	cout << "--prefix-notRespondSensor - датчик связи для данного процесса " << endl;
 	cout << "--prefix-sm-ready-timeout - время на ожидание старта SM" << endl;
 	cout << "--prefix-recv-timeout - Таймаут на ожидание ответа." << endl;
+	cout << "--prefix-respond-id - respond sensor id" << endl;
+	cout << "--prefix-respond-invert [0|1] - invert respond logic" << endl;
+	cout << "--prefix-timeout msec - timeout for check link" << 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;
@@ -774,7 +818,7 @@ MBSlave* MBSlave::init_mbslave( int argc, const char* const* argv, UniSetTypes::
 	}
 
 	dlog[Debug::INFO] << "(mbslave): name = " << name << "(" << ID << ")" << endl;
-	return new MBSlave(ID,icID,ic);
+	return new MBSlave(ID,icID,ic,prefix);
 }
 // -----------------------------------------------------------------------------
 std::ostream& operator<<( std::ostream& os, MBSlave::IOProperty& p )

extensions/ModbusSlave/MBSlave.h

@@ -168,6 +168,10 @@ class MBSlave:
 		IOController::AIOStateList::iterator aitAskCount;
 		UniSetTypes::ObjectId askcount_id;
 
+		IOController::DIOStateList::iterator ditRespond;
+		UniSetTypes::ObjectId respond_id;
+		bool respond_invert;
+
 		PassiveTimer ptTimeout;
 		ModbusRTU::mbErrCode prev;
 		long askCount;

extensions/RTUExchange/Makefile.am

-bin_PROGRAMS 			= @PACKAGE@-rtuexchange mtrconv rtustate vtconv
+bin_PROGRAMS 			= @PACKAGE@-rtuexchange mtr-conv rtustate vtconv mtr-setup
 
 lib_LTLIBRARIES 			= libUniSetRTU.la
 libUniSetRTU_la_LIBADD		= $(top_builddir)/lib/libUniSet.la \
@@ -15,9 +15,13 @@ libUniSetRTU_la_SOURCES 	= RTUStorage.cc RTUExchange.cc
 									$(SIGC_LIBS)
 @PACKAGE@_rtuexchange_CXXFLAGS	= -I$(top_builddir)/extensions/include -I$(top_builddir)/extensions/SharedMemory $(SIGC_CFLAGS)
 
-mtrconv_SOURCES	= mtrconv.cc
-mtrconv_LDADD	= $(top_builddir)/extensions/lib/libUniSetExtensions.la $(top_builddir)/lib/libUniSet.la
-mtrconv_CXXFLAGS = -I$(top_builddir)/extensions/include
+mtr_conv_SOURCES	= mtrconv.cc
+mtr_conv_LDADD	= $(top_builddir)/extensions/lib/libUniSetExtensions.la $(top_builddir)/lib/libUniSet.la
+mtr_conv_CXXFLAGS = -I$(top_builddir)/extensions/include
+
+mtr_setup_SOURCES	= mtr-setup.cc
+mtr_setup_LDADD	= $(top_builddir)/extensions/lib/libUniSetExtensions.la $(top_builddir)/lib/libUniSet.la
+mtr_setup_CXXFLAGS = -I$(top_builddir)/extensions/include
 
 vtconv_SOURCES	= vtconv.cc
 vtconv_LDADD	= $(top_builddir)/extensions/lib/libUniSetExtensions.la $(top_builddir)/lib/libUniSet.la

extensions/RTUExchange/mtr-setup.cc

+// --------------------------------------------------------------------------
+//!  \version $Id: mbrtutester.cc,v 1.3 2009/02/24 20:27:24 vpashka Exp $
+// --------------------------------------------------------------------------
+#include <string>
+#include <map>
+#include <list>
+#include <fstream>
+#include <iomanip>
+#include <getopt.h>
+#include <math.h>
+#include "Debug.h"
+#include "modbus/ModbusRTUMaster.h"
+#include "modbus/ModbusHelpers.h"
+#include "extensions/MTR.h"
+// --------------------------------------------------------------------------
+using namespace UniSetTypes;
+using namespace std;
+// --------------------------------------------------------------------------
+static struct option longopts[] = {
+	{ "help", no_argument, 0, 'h' },
+	{ "read", required_argument, 0, 'r' },
+	{ "save", required_argument, 0, 'w' },
+	{ "timeout", required_argument, 0, 't' },
+	{ "autodetect-slave", required_argument, 0, 'l' },
+	{ "autodetect-speed", required_argument, 0, 'n' },
+	{ "device", required_argument, 0, 'd' },
+	{ "verbose", no_argument, 0, 'v' },
+	{ "speed", required_argument, 0, 's' },
+	{ "stop-bits", required_argument, 0, 'i' },
+	{ "parity", required_argument, 0, 'p' },
+	{ "use485F", no_argument, 0, 'y' },
+	{ "min-addr", required_argument, 0, 'b' },
+	{ "max-addr", required_argument, 0, 'e' },
+	{ "model", required_argument, 0, 'x' },
+	{ "serial", required_argument, 0, 'z' },
+	{ NULL, 0, 0, 0 }
+};
+// --------------------------------------------------------------------------
+static void print_help()
+{
+	printf("-h|--help                 - this message\n");
+	printf("[--read] mtraddr          - read configuration from MTR\n");
+	printf("[--save] mtraddr confile  - save configureation to MTR\n");
+	printf("             mtraddr=0x00 - autodetect addr\n");
+	printf("[-d|--device] dev         - use device dev. Default: /dev/ttyS0\n");
+	printf("[-s|--speed] speed        - 9600,14400,19200,38400,57600,115200. Default: 38400.\n");
+	printf("[--stop-bits] n           - stop bits [1,2]. Default: 1\n");
+	printf("[--parity] par            - parity [odd,even,no]. Default: no\n");
+	printf("[-t|--timeout] msec       - Timeout. Default: 2000.\n");
+	printf("[-v|--verbose]            - Print all messages to stdout\n");
+	printf("[-y|--use485F]            - use RS485 Fastwel.\n");
+	printf("[--autodetect-speed] slaveaddr [reg fn]  - detect speed\n");
+	printf("          reg - register of test. Default: 0\n");
+	printf("          fn - function of test [0x01,0x02,0x03,0x04]. Default: 0x04\n");
+	printf("[--autodetect-slave] [reg fn]  - find slave\n");
+	printf("          reg - register of test. Default: 0\n");
+	printf("          fn - function of test [0x01,0x02,0x03,0x04]. Default: 0x04\n");
+	printf("[--min-addr] - start addres for autodetect. Default: 0\n");
+	printf("[--max-addr] - end addres for autodetect. Default: 255\n");
+	printf("\n");
+}
+// --------------------------------------------------------------------------
+enum Command
+{
+	cmdNOP,
+	cmdRead,
+	cmdSave,
+	cmdDetectSpeed,
+	cmdDetectSlave,
+	cmdGetModel,
+	cmdGetSerial
+};
+// --------------------------------------------------------------------------
+static char* checkArg( int ind, int argc, char* argv[] );
+// --------------------------------------------------------------------------
+int main( int argc, char **argv )
+{   
+	Command cmd = cmdNOP;
+	int optindex = 0;
+	int opt = 0;
+	int verb = 0;
+	string dev("/dev/ttyS0");
+	string speed("38400");
+	string mtrconfile("");
+	string par("");
+	ModbusRTU::ModbusData reg = 0;
+	ModbusRTU::ModbusAddr slaveaddr = 0x00;
+	ModbusRTU::SlaveFunctionCode fn = ModbusRTU::fnReadInputRegisters;
+	ModbusRTU::ModbusAddr beg = 0;
+	ModbusRTU::ModbusAddr end = 255;
+	int tout = 20;
+	DebugStream dlog;
+	string tofile("");
+	int use485 = 0;
+	ComPort::StopBits sbits = ComPort::OneBit;
+	ComPort::Parity parity = ComPort::NoParity;
+
+	try
+	{
+		while( (opt = getopt_long(argc, argv, "hvw:r:x:d:s:t:l:n:yb:e:x:z:",longopts,&optindex)) != -1 ) 
+		{
+			switch (opt) 
+			{
+				case 'h':
+					print_help();
+				return 0;
+
+				case 'r':
+						cmd = cmdRead;
+						slaveaddr = ModbusRTU::str2mbAddr(optarg);
+				break;
+				
+				case 'w':
+					cmd = cmdSave;
+					slaveaddr = ModbusRTU::str2mbAddr( optarg );
+					if( !checkArg(optind,argc,argv) )
+					{
+						cerr << "read command error: bad or no arguments..." << endl;
+						return 1;
+					}
+					else
+						mtrconfile = string(argv[optind]);
+				break;
+
+				case 'x':
+						cmd = cmdGetModel;
+						slaveaddr = ModbusRTU::str2mbAddr(optarg);
+				break;
+
+				case 'z':
+						cmd = cmdGetSerial;
+						slaveaddr = ModbusRTU::str2mbAddr(optarg);
+				break;
+		
+				case 'y':
+					use485 = 1;
+				break;
+
+				case 'd':
+					dev = string(optarg);
+				break;
+
+				case 's':
+					speed = string(optarg);
+				break;
+
+				case 'p':
+					par = string(optarg);
+					if( !par.compare("odd") )
+						parity = ComPort::Odd;
+					else if( !par.compare("even") )
+						parity = ComPort::Even;
+				break;
+
+#undef atoi
+				case 't':
+					tout = atoi(optarg);
+				break;
+
+				case 'i':
+					if( atoi(optarg) == 2 )
+						sbits = ComPort::TwoBits;
+				break;
+
+				case 'b':
+					beg = atoi(optarg);
+				break;
+	
+				case 'e':
+					end = atoi(optarg);
+				break;
+
+//				case 'a':
+//					myaddr = ModbusRTU::str2mbAddr(optarg);
+//				break;
+
+				case 'v':
+					verb = 1;
+				break;
+				
+				case 'l':
+				{
+					if( cmd == cmdNOP )
+						cmd = cmdDetectSlave;
+		
+					if( !checkArg(optind,argc,argv) )
+						break;
+					reg = ModbusRTU::str2mbData(argv[optind+2]);
+
+					if( !checkArg(optind+1,argc,argv) )
+						break;
+					fn = (ModbusRTU::SlaveFunctionCode)UniSetTypes::uni_atoi(argv[optind+3]);
+				}
+				break;
+
+				case 'n':
+				{
+					if( cmd == cmdNOP )
+						cmd = cmdDetectSpeed;
+		
+					slaveaddr = ModbusRTU::str2mbAddr(optarg);
+		
+					if( !checkArg(optind,argc,argv) )
+						break;
+
+					reg = ModbusRTU::str2mbData(argv[optind]);
+
+					if( !checkArg(optind+1,argc,argv) )
+						break;
+
+					fn = (ModbusRTU::SlaveFunctionCode)UniSetTypes::uni_atoi(argv[optind+1]);
+				}
+				break;
+
+				case '?':
+				default:
+					printf("? argumnet\n");
+					return 0;
+			}
+		}
+
+		if( verb )
+		{
+			cout << "(init): dev=" << dev << " speed=" << speed
+					<< " timeout=" << tout << " msec "
+					<< endl;					
+		}		
+		
+		ModbusRTUMaster mb(dev,use485);
+
+		if( verb )
+			dlog.addLevel( Debug::type(Debug::CRIT | Debug::WARN | Debug::INFO) );
+		
+		mb.setTimeout(tout);
+		mb.setSpeed(speed);
+		mb.setParity(parity);
+		mb.setStopBits(sbits);
+		mb.setLog(dlog);
+		
+		switch(cmd)
+		{
+			case cmdRead:
+			{
+				if( verb )
+					cout << "(mtr-setup): read: slaveaddr=" << ModbusRTU::addr2str(slaveaddr) << endl;
+			}
+			break;
+
+			case cmdSave:
+			{
+				if( slaveaddr == 0x00 )
+				{
+					if( verb )
+						cout << "(mtr-setup): save: autodetect slave addr... (speed=" << speed <<  ")" << endl;
+
+					mb.setTimeout(50);
+					slaveaddr = ModbusHelpers::autodetectSlave(&mb,beg,end,MTR::regModelNumber,ModbusRTU::fnReadInputRegisters);
+					mb.setTimeout(tout);
+				}
+
+				if( speed.empty() )
+				{
+					if( verb )
+						cout << "(mtr-setup): save: autodetect speed... (addr=" << ModbusRTU::addr2str(slaveaddr) << ")" << endl;
+
+					mb.setTimeout(50);
+					ComPort::Speed s = ModbusHelpers::autodetectSpeed(&mb,slaveaddr,MTR::regModelNumber,ModbusRTU::fnReadInputRegisters);
+					mb.setSpeed(s);
+					mb.setTimeout(tout);
+				}
+
+				if( verb )
+					cout << "(mtr-setup): save: "
+						 << " slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+						 << " confile=" << mtrconfile
+						 << " speed=" << speed
+						 << endl;
+
+				return  MTR::update_configuration(&mb,slaveaddr,mtrconfile,verb) ? 0 : 1;
+			}
+			break;
+
+			case cmdDetectSlave:
+			{
+				if( verb )
+				{
+					cout << "(mtr-setup): autodetect slave: "
+						 << " beg=" << ModbusRTU::addr2str(beg)
+						 << " end=" << ModbusRTU::addr2str(end)
+						 << " reg=" << ModbusRTU::dat2str(reg) 
+						 << " fn=" << ModbusRTU::b2str(fn) 
+						 << endl;
+				}
+				
+				try
+				{
+					ModbusRTU::ModbusAddr a = ModbusHelpers::autodetectSlave(&mb,beg,end,reg,fn);
+					cout << "(mtr-setup): autodetect modbus slave: " << ModbusRTU::addr2str(a) << endl;
+				}
+				catch( UniSetTypes::TimeOut )
+				{
+					cout << "(mtr-setup): slave not autodetect..." << endl;
+				}
+			break;
+			}
+
+			case cmdDetectSpeed:
+			{
+				if( verb )
+				{
+					cout << "(mtr-setup): autodetect speed: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+						 << " reg=" << ModbusRTU::dat2str(reg) 
+						 << " fn=" << ModbusRTU::b2str(fn) 
+						 << endl;
+				}
+				
+				try
+				{
+					ComPort::Speed s = ModbusHelpers::autodetectSpeed(&mb,slaveaddr,reg,fn);
+					cout << "(mtr-setup): autodetect: slaveaddr=" << ModbusRTU::addr2str(slaveaddr) 
+						<< " speed=" << ComPort::getSpeed(s) << endl;
+				}
+				catch( UniSetTypes::TimeOut )
+				{
+					cout << "(mtr-setup): speed not autodetect for slaveaddr=" 
+						<< ModbusRTU::addr2str(slaveaddr) << endl;
+				}
+			}
+			break;
+
+			case cmdGetModel:
+			{
+				if( verb )
+				{
+					cout << "(mtr-setup): model: "
+						 << " slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+						 << endl;
+				}
+				
+				cout << "model: " << MTR::getModelNumber(&mb,slaveaddr) << endl;
+			}
+			break;
+		
+			case cmdGetSerial:
+			{
+				if( verb )
+				{
+					cout << "(mtr-setup): serial: "
+						 << " slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
+						 << endl;
+				}
+				
+				cout << "serial: " << MTR::getSerialNumber(&mb,slaveaddr) << endl;
+			}
+			break;
+		
+			case cmdNOP:
+			default:
+				cerr << "No command. Use -h for help." << endl;
+				return 1;
+		}
+		
+	}
+	catch( ModbusRTU::mbException& ex )
+	{
+		cerr << "(mtr-setup): " << ex << endl;
+	}
+	catch(SystemError& err)
+	{
+		cerr << "(mtr-setup): " << err << endl;
+	}
+	catch(Exception& ex)
+	{
+		cerr << "(mtr-setup): " << ex << endl;
+	}
+	catch(...)
+	{
+		cerr << "(mtr-setup): catch(...)" << endl;
+	}
+
+	return 0;
+}
+// --------------------------------------------------------------------------
+char* checkArg( int i, int argc, char* argv[] )
+{
+	if( i<argc && (argv[i])[0]!='-' )
+		return argv[i];
+		
+	return 0;
+}
+// --------------------------------------------------------------------------

extensions/include/MTR.h

@@ -5,9 +5,12 @@
 #define _MTR_H_
 // -----------------------------------------------------------------------------
 #include <string>
+#include <map>
+#include <list>
 #include <cstring>
 #include <cmath>
 #include "modbus/ModbusTypes.h"
+#include "ComPort.h"
 // -----------------------------------------------------------------------------
 class ModbusRTUMaster;
 // -----------------------------------------------------------------------------
@@ -79,7 +82,25 @@ namespace MTR
 	bool setStopBit( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, bool state );
 	bool setParity( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, mtrParity p );
 	bool setDataBits( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, mtrDataBits d );
+	ComPort::Parity get_parity( ModbusRTU::ModbusData data );
+	ComPort::Speed get_speed( ModbusRTU::ModbusData data );
+	// -------------------------------------------------------------------------
+	//    .
+	bool update_configuration( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, 
+				    const std::string mtrconfile, int verbose=0 );
+	// ---------------------------
+	//     
+	typedef std::list<ModbusRTU::ModbusData> DataList;
+	typedef std::map<ModbusRTU::ModbusData,DataList> DataMap;
+	static int attempts = 3; //
+	static const ModbusRTU::ModbusData skip[] = {48, 49, 59};  // registers which should not write
+
 	
+	bool send_param( ModbusRTUMaster* mb, DataMap& dmap, ModbusRTU::ModbusAddr addr, int verb );
+	bool read_param( const std::string str, std::string& str1, std::string& str2 );
+	DataMap read_confile( const std::string f );
+	void update_communication_params( ModbusRTU::ModbusAddr reg, ModbusRTU::ModbusData data,
+				  ModbusRTUMaster* mb, ModbusRTU::ModbusAddr& addr, int verb );
 	// -------------------------------------------------------------------------
 	static const int u2size = 2;
 	// -------------------------------------------------------------------------

extensions/lib/IOBase.cc

@@ -369,10 +369,20 @@ void IOBase::processingThreshold( IOBase* it, SMInterface* shm, bool force )
 //	cout  << "val=" << val << " set=" << set << endl;
 	// Проверка нижнего предела
 	// значение должно быть меньше lowLimit-чуствительность
-	if( val <= (it->ti.lowlimit-it->ti.sensibility) )
-		set = false;
-	else if( val >= (it->ti.hilimit+it->ti.sensibility) )
-		set = true;
+	if (it->ti.inverse)
+	{
+		if( val <= (it->ti.lowlimit-it->ti.sensibility) )
+			set = true;
+		else if( val >= (it->ti.hilimit+it->ti.sensibility) )
+			set = false;
+	}
+	else
+	{
+		if( val <= (it->ti.lowlimit-it->ti.sensibility) )
+			set = false;
+		else if( val >= (it->ti.hilimit+it->ti.sensibility) )
+			set = true;
+	}
 
 //	cout  << "thresh: set=" << set << endl;
 	processingAsDI(it,set,shm,force);
@@ -527,6 +537,7 @@ bool IOBase::initItem( IOBase* b, UniXML_iterator& it, SMInterface* shm,
 			b->ti.lowlimit 	= it.getIntProp("lowlimit");
 			b->ti.hilimit 		= it.getIntProp("hilimit");
 			b->ti.sensibility 	= it.getIntProp("sensibility");
+			b->ti.inverse 		= it.getIntProp("inverse");
 		}
 	}
 //	else

extensions/lib/MTR.cc

@@ -2,7 +2,10 @@
 //!  \version $Id: MTR.cc,v 1.1 2008/12/14 21:57:50 vpashka Exp $
 // --------------------------------------------------------------------------
 #include <cmath>
+#include <vector>
+#include <algorithm>
 #include "modbus/ModbusRTUMaster.h"
+#include "modbus/ModbusHelpers.h"
 #include "MTR.h"
 // --------------------------------------------------------------------------
 using namespace std;
@@ -207,5 +210,236 @@ std::string getSerialNumber( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr )
 	return "";
 }
 // -----------------------------------------------------------------------------
+DataMap read_confile( const std::string f )
+{
+	bool start = false;
+	DataMap dmap;
+	std::ifstream ifs(f.c_str(),std::ios::in);
+	if( ifs )
+	{
+		while( !ifs.eof() )
+		{
+			std::string str;
+			if( getline(ifs,str) )
+			{
+				if( str.empty() )
+					continue;
+
+				if( !start )
+				{
+					str = str.substr(0,str.size()-1); // remove \n\r
+//					cout <<  "check str: " << str << endl;
+					if( str == "[Settings]" )
+					{
+						start = true;
+						continue;
+					}
+					else
+						continue;
+				}
+
+				string s_reg, s_data;
+				if( read_param(str,s_reg,s_data) )
+				{
+					ModbusRTU::ModbusData reg = ModbusRTU::str2mbData(s_reg);
+
+					/* we can write only registers > 40000 (see MTR-2 manual) */
+					if( reg <= 40000 )
+						continue;
+					reg -= 40000;
+
+//					cout << "reg=" << s_reg
+//						 << " data=" << s_data << endl;
+					DataList dlst;
+					int k=0;
+					std::vector<unsigned char> v(4);
+					for( int i=0; i<s_data.size(); i++ )
+					{
+						v[k++] = s_data[i];
+						if( k>3 )
+						{
+							k=0;
+							string tmp(v.begin(),v.end());
+							tmp = "0x" + tmp;
+//							cout << "find data=" << ModbusRTU::str2mbData(tmp) 
+//									<< "(" << tmp << ")" << endl;
+							dlst.push_back( ModbusRTU::str2mbData(tmp) );
+						}
+					}
+					
+					dmap[reg] = dlst;
+				}
+			}
+		}
+	}
+	
+	ifs.close();
+	
+	return dmap;
+}
+// --------------------------------------------------------------------------
+bool read_param( const std::string str, std::string& str1, std::string& str2 )
+{
+	string::size_type pos = str.find('=');
+	if( pos==string::npos )
+		return false;
+
+	str1 = str.substr(0,pos);
+	str2 = str.substr(pos+1,str.size());
+	return true;
+}
+// ------------------------------------------------------------------------------------------
+ComPort::Speed get_speed( ModbusRTU::ModbusData data )
+{
+	static const ComPort::Speed speed_conv[] = { ComPort::ComSpeed1200,
+		ComPort::ComSpeed2400, ComPort::ComSpeed4800, ComPort::ComSpeed9600,
+		ComPort::ComSpeed19200, ComPort::ComSpeed38400, ComPort::ComSpeed57600,
+		ComPort::ComSpeed115200 };
+
+	if( data >= sizeof(speed_conv)/sizeof(speed_conv[0]) )
+		return ComPort::ComSpeed0;
+	return speed_conv[data];
+}
+// ------------------------------------------------------------------------------------------
+ComPort::Parity get_parity( ModbusRTU::ModbusData data )
+{
+	static const ComPort::Parity parity_conv[] = {
+		ComPort::NoParity, ComPort::Odd, ComPort::Even };
+
+	if( data >= sizeof(parity_conv)/sizeof(parity_conv[0]) )
+		return ComPort::NoParity;
+	return parity_conv[data];
+}
+// ------------------------------------------------------------------------------------------
+void update_communication_params( ModbusRTU::ModbusAddr reg, ModbusRTU::ModbusData data,
+				  ModbusRTUMaster* mb, ModbusRTU::ModbusAddr& addr, int verb )
+{
+	if( reg == 55 )
+	{
+		addr = data;
+		if( verb )
+			cout << "(mtr-setup): slaveaddr is set to "
+				 << ModbusRTU::addr2str(addr) << endl;
+	}
+	else if( reg == 56 )
+	{
+		ComPort::Speed speed = get_speed(data);
+		if( speed != ComPort::ComSpeed0 )
+		{
+			mb->setSpeed(speed);
+			if( verb )
+				cout << "(mtr-setup): speed is set to "
+					 << ComPort::getSpeed(speed) << endl;
+		}
+	}
+	else if( reg == 57 )
+	{
+		if( data == 0 )
+			mb->setStopBits(ComPort::OneBit);
+		else if( data == 1)
+			mb->setStopBits(ComPort::TwoBits);
+		else return;
+		if( verb )
+			cout << "(mtr-setup): number of stop bits is set to "
+				 << data + 1 << endl;
+	}
+	else if( reg == 58 )
+	{
+		if (data != 0 && data != 1 && data != 2)
+			return;
+		mb->setParity(get_parity(data));
+		if( verb )
+			cout << "(mtr-setup): parity is set to "
+				 << (data ? ((data == 1) ? "odd" : "even") : "no") << endl;
+	}
+}
+// ------------------------------------------------------------------------------------------
+bool send_param( ModbusRTUMaster* mb, DataMap& dmap, ModbusRTU::ModbusAddr addr, int verb )
+{
+	if( !mb )
+	{
+		cerr << "(MTR::send_param): mb=NULL!" << endl;
+		return false;
+	}
+
+	for( DataMap::iterator it=dmap.begin(); it!=dmap.end(); ++it )
+	{
+//		ModbusRTU::WriteOutputMessage msg(addr,it->first);
+//		cout << "send reg=" << ModbusRTU::dat2str(it->first) 
+//							<< "(" << it->first << ")" << endl;
+		int reg = it->first;
+		bool ok = false;
+
+		for( DataList::iterator it1=it->second.begin(); it1!=it->second.end(); ++it1, reg++ )
+		{
+			const ModbusRTU::ModbusData *last = skip + sizeof(skip)/sizeof(skip[0]);
+			if( std::find(skip, last, reg) != last)
+				continue;
+
+			cout << "send reg=" << ModbusRTU::dat2str(reg) 
+							<< "(" << reg << ")" 
+				<< "=" << ModbusRTU::dat2str( (*it1) )  << endl;
+//			ok=true;
+//			continue;
+			for( int i=0; i<attempts; i++ )
+			{
+				try
+				{
+					ModbusRTU::WriteSingleOutputRetMessage ret = mb->write06(addr,reg,(*it1));
+					if( verb )
+						cout << "(mtr-setup): write reply: " << ret << endl;
+					update_communication_params(reg, *it1, mb, addr, verb);
+					ok = true;
+					break;
+				}
+				catch( ModbusRTU::mbException& ex )
+				{
+					/* if speed is changed we receive a timeout error */
+					if( reg == 56 && it->first == ModbusRTU::erTimeOut )
+					{
+						update_communication_params(reg, *it1, mb, addr, verb);
+						ok = true;
+						break;
+					}
+					else
+					{
+						cerr << "(mtr-setup): error for write reg="
+							 << ModbusRTU::dat2str(reg)
+							 << "(" << it->first << "): " << ex << endl;
+					}
+				}
+			}
+		}
+
+//		if( !ok )
+//			return false;
+	}
+	
+	return true;
+}
+// ------------------------------------------------------------------------------------------
+bool update_configuration( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr slaveaddr,
+						    const std::string mtrconfile,  int verb )
+{
+	std::string m = MTR::getModelNumber(mb, slaveaddr);
+	if( m != "MTR315Transducer" )
+	{
+		cerr << "(mtr-setup): model number != 'MTR315Transducer' (read: " << m << ")" << endl;
+		return false;
+	}
+
+	DataMap dmap = MTR::read_confile(mtrconfile);
+	if( dmap.empty() )
+	{
+		cerr << "(mtr-setup): error read confile=" << mtrconfile << endl;
+		return false;
+	}
+
+	if( send_param(mb,dmap,slaveaddr,verb) )
+		return true;
+
+	return false;
+}
+// ------------------------------------------------------------------------------------------
 } // end of namespace MTR
 // -----------------------------------------------------------------------------

include/Configuration.h

@@ -107,6 +107,7 @@ namespace UniSetTypes
 		xmlNode* getXMLObjectsSection();
 		xmlNode* getXMLControllersSection();
 		xmlNode* getXMLServicesSection();
+		xmlNode* getXMLObjectNode( UniSetTypes::ObjectId );
 	
 		// net
 		inline unsigned int getCountOfNet() const { return countOfNet; }

include/IONotifyController.h

@@ -280,6 +280,7 @@ class IONotifyController:
 
 		void onChangeUndefined( DependsList::iterator it, bool undefined );
 
+		UniSetTypes::uniset_mutex sig_mutex;
 		ChangeSignal changeSignal;
 
 	private:

include/UniSetTypes.h

@@ -118,9 +118,14 @@ namespace UniSetTypes
 	/*! Информация об имени объекта */
 	struct ObjectInfo
 	{
+		ObjectInfo():
+			id(DefaultObjectId),
+			repName(0),textName(0),data(0){}
+
 	    ObjectId id;		/*!< идентификатор */
 	    char* repName;		/*!< текстовое имя для регистрации в репозитории */
 	    char* textName;		/*!< текстовое имя */
+	    void* data;
 	};
 	
 	typedef std::list<NodeInfo> ListOfNode;

include/UniversalInterface.h

@@ -196,6 +196,9 @@ class UniversalInterface
 		UniSetTypes::ObjectType getType(UniSetTypes::ObjectId id, UniSetTypes::ObjectId node) throw(IO_THROW_EXCEPTIONS);
 		UniSetTypes::ObjectType getType(UniSetTypes::ObjectId id);
 
+		// read from xml (only for xml!)
+		UniversalIO::IOTypes getConfIOType( UniSetTypes::ObjectId id );
+
 		IOController_i::ShortIOInfo getChangedTime( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node );
 		IOController_i::ShortMapSeq* getSensors( UniSetTypes::ObjectId id, 
 													UniSetTypes::ObjectId node=UniSetTypes::conf->getLocalNode() );

src/Interfaces/UniversalInterface.cc

@@ -3101,3 +3101,16 @@ bool UniversalInterface::waitWorking( UniSetTypes::ObjectId id, int msec, int pm
 
 }
 // -----------------------------------------------------------------------------
+UniversalIO::IOTypes UniversalInterface::getConfIOType( UniSetTypes::ObjectId id )
+{
+	if( !conf )
+		return UniversalIO::UnknownIOType;
+		
+	xmlNode* x = conf->getXMLObjectNode(id);
+	if( !x )
+		return UniversalIO::UnknownIOType;
+	
+	UniXML_iterator it(x);
+	return UniSetTypes::getIOType( it.getProp("iotype") );
+}
+// -----------------------------------------------------------------------------

src/ObjectRepository/ObjectIndex_XML.cc

@@ -188,6 +188,8 @@ unsigned int ObjectIndex_XML::read_section( UniXML& xml, const std::string sec,
 		delete[] omap[ind].textName;
 		omap[ind].textName = new char[textname.size()+1];
 		strcpy( omap[ind].textName, textname.c_str() );
+		
+		omap[ind].data = (void*)(xmlNode*)it;
 
 //		cout << "read: " << "(" << ind << ") " << omap[ind].repName << "\t" << omap[ind].textName << endl;
 		ind++;
@@ -257,6 +259,7 @@ unsigned int ObjectIndex_XML::read_nodes( UniXML& xml, const std::string sec, un
 		omap[ind].textName = new char[textname.size()+1];
 		strcpy( omap[ind].textName, textname.c_str() );
 
+		omap[ind].data = (void*)(xmlNode*)(it);
 		// 
 		mok[omap[ind].repName] = ind;
 

src/ObjectRepository/ObjectIndex_idXML.cc

@@ -157,6 +157,9 @@ void ObjectIndex_idXML::read_section( UniXML& xml, const std::string sec )
 
 		inf.textName = new char[textname.size()+1];
 		strcpy( inf.textName, textname.c_str() );
+		
+		inf.data = (void*)(xmlNode*)(it);
+
 		omap[inf.id] = inf;
 	}
 }
@@ -211,6 +214,8 @@ void ObjectIndex_idXML::read_nodes( UniXML& xml, const std::string sec )
 
 		inf.textName = new char[textname.size()+1];
 		strcpy( inf.textName, textname.c_str() );
+		
+		inf.data = (void*)(xmlNode*)(it);
 
 		omap[inf.id] = inf;
 	}

src/Processes/IONotifyController.cc

@@ -494,6 +494,7 @@ void IONotifyController::localSaveState( IOController::DIOStateList::iterator& i
 
 	try
 	{	
+		uniset_mutex_lock l(sig_mutex,500);
 		changeSignal.emit(&sm);
 	}
 	catch(...){}
@@ -557,6 +558,7 @@ void IONotifyController::localSaveValue( IOController::AIOStateList::iterator& l
 
 	try
 	{	
+		uniset_mutex_lock l(sig_mutex,500);
 		changeSignal.emit(&sm);
 	}
 	catch(...){}
@@ -1201,6 +1203,7 @@ void IONotifyController::localSetState( IOController::DIOStateList::iterator& it
 
 	try
 	{	
+		uniset_mutex_lock l(sig_mutex,500);
 		changeSignal.emit(&sm);
 	}
 	catch(...){}
@@ -1257,6 +1260,7 @@ void IONotifyController::localSetValue( IOController::AIOStateList::iterator& li
 
 	try
 	{	
+		uniset_mutex_lock l(sig_mutex,500);
 		changeSignal.emit(&sm);
 	}
 	catch(...){}

src/Various/Configuration.cc

@@ -1012,6 +1012,15 @@ xmlNode* Configuration::getXMLServicesSection()
 	return xmlServicesSec;
 }
 // -------------------------------------------------------------------------
+xmlNode* Configuration::getXMLObjectNode( UniSetTypes::ObjectId id )
+{
+	const ObjectInfo* i = oind->getObjectInfo(id);
+	if( i )
+		return (xmlNode*)(i->data);
+
+	return 0;
+}
+// -------------------------------------------------------------------------
 void uniset_init( int argc, const char* const* argv, const std::string xmlfile )
 {
 	string confile = UniSetTypes::getArgParam( "--confile", argc, argv, xmlfile );

src/Various/NCRestorer_XML.cc

@@ -469,7 +469,7 @@ bool NCRestorer_XML::getThresholdInfo( UniXML& xml,xmlNode* node,
 bool NCRestorer_XML::check_thresholds_item( UniXML_iterator& it )
 {	
 	// формат тот же как и <sensors> 
-	return check_list_item(it);
+	return check_consumer_item(it);
 }
 // ------------------------------------------------------------------------------------------
 void NCRestorer_XML::setReadThresholdItem( ReaderSlot sl )

tests/ui.cc

@@ -11,6 +11,25 @@ int main( int argc, const char **argv )
 	{
 
 		uniset_init(argc,argv,"test.xml");
+		UniversalInterface ui;
+
+
+		cout << "** check getSensorID function **" << endl;
+		ObjectId id1 = conf->getSensorID("Input1_S");
+		if( id1 != 1 )
+		{
+			cout << "** FAILED! check getSensorID function **" << endl;
+			return 1;
+		}
+
+		cout << "** check getConfIOType function **" << endl;
+		UniversalIO::IOTypes t = ui.getConfIOType(id1);
+		cout << "sensor ID=" << id1 << " iotype=" << t << endl;
+		if( t != UniversalIO::DigitalInput )
+		{
+			cout << "** FAILED! check getSensorID function **" << endl;
+			return 1;
+		}
 
 		int id = conf->getArgInt("--sid");
 		if( id <= 0 )
@@ -19,9 +38,8 @@ int main( int argc, const char **argv )
 			return 1;
 		}
 	
-		UniversalInterface ui;
 
-		cout << "getChangedTime for ID=" << id << ":" << endl;
+		cout << "** check getChangedTime for ID=" << id << ":" << endl;
 
 		IOController_i::ShortIOInfo inf = ui.getChangedTime(id,conf->getLocalNode());
 
@@ -33,6 +51,7 @@ int main( int argc, const char **argv )
 		cout << "id=" << id
 			<< " value=" << inf.value
 			<< " last changed: " << string(t_str) << endl;
+
 	}
 	catch( Exception& ex )
 	{