backported to p8 as 2.6-alt11.M80P.12 (with rpmbph script)

.travis.yml

@@ -33,7 +33,7 @@ before_script:
   # due broken comedi
   - export CXXFLAGS="$CXXFLAGS -Wl,--unresolved-symbols=ignore-in-shared-libs"
   - autoreconf -fiv
-  - ./configure --enable-tests --enable-mysql --enable-sqlite --enable-rrd --enable-io --enable-logicproc --disable-python --disable-mqtt --disable-pgsql --disable-api --disable-pkgchecklibev
+  - ./configure --enable-tests --enable-mysql --enable-sqlite --enable-rrd --enable-io --enable-logicproc --disable-python --disable-mqtt --disable-pgsql --disable-api --disable-pkgchecklibev --disable-netdata
 
 script:
   - if [ ${COVERITY_SCAN_BRANCH} != 1 ]; then make ; fi

TODO

@@ -52,20 +52,13 @@ LogServer:
 - подумать насчёт буфера для хранения последних n-сообщений (с возможностью вытащить через REST API)
 
 HTTP API:
-- запрос списка заказчиков по конкретным датчикам
-- запрос о том, кто последний сохранил указанный датчик
 - список объектов возвращать с их типом (чтобы можно было SM вычислять)
-= Сделать возможность настраивать параметры httpserver-а из командной строки (количество потоков и т.п.)
+- Сделать возможность настраивать параметры httpserver-а из командной строки (количество потоков и т.п.)
 - ТЕСТЫ (как вариант поизучать про тестовые фреймворки на питоне (pytest?)
-- /sensors/XXX?config=name,textname,...  - запрос полей (из configure.xml)
-- /conf/objects?prop1,prop2,prop3,.. - props from condigure.xml
-- /conf/nodes?prop1,prop2,prop3,.. - props from condigure.xml
-- /conf/controlers?..
-- /conf/services?...
-- /conf/...
-
-Version 2.5
-============
+- Запрос у процесса обмена (MBSlave,MBxxMaster,UNet и т.п.) получение списка опрашиваемых датчиков
+(датчиков с которыми ведётся работа данным процессом обмена)
+
+
 - smonit запись значений в файл (csv?,sqlite?,gnuplot)
 - python: gui sensor monitor 
 
@@ -108,11 +101,12 @@ DB: Сделать регулируемый буфер на INSERT-ы БД, чт
 -----
 - ведение статистики по типам сообщений в каждом объекте (и в SM). Чтобы увидеть где происходит потеря пакетов (если происходит).
 (т.е. идея в том, что сколько "успешно" послала SM столько должно придти и быть обработано (разные счётчики) в объекте)
+- NoSQL база (в памяти) как буфер (держит интенсивную запись) перед "не спешной" записью в реляционную (MySQL,Postgre и т.п.)
+
 
 ==================
 
-Но тогда стоит вводить и namespace uniset
-=================
+lock-free: mentomic
 
 
 version 3
@@ -133,5 +127,3 @@ UResolver (или ObjectRepository) позволяющего манипулир
 - Перепроектировать OIndex и Configure.. Инициализироват для Configure(объектом OIndex)
 
 - подумать возможно стоит переходить на lockfree-библиотеку libcds..(актуально для многопроцессорных систем)
-
-- Ввести namespace uniset::  ust::  uns:: ?

Utilities/Admin/admin.cc

@@ -244,8 +244,9 @@ int main(int argc, char** argv)
 
 					std::string userparam = { "" };
 
-					if( checkArg(optind + 1, argc, argv) )
-						userparam = string(argv[optind + 1]);
+					// смотрим второй параметр
+					if( checkArg(optind, argc, argv) )
+						userparam = string(argv[optind]);
 
 					return oinfo(optarg, ui, userparam);
 				}
@@ -253,6 +254,7 @@ int main(int argc, char** argv)
 
 				case 'a':    //--apiRequest
 				{
+					// смотрим второй параметр
 					if( checkArg(optind, argc, argv) == 0 )
 					{
 						if( !quiet )
@@ -338,6 +340,7 @@ int main(int argc, char** argv)
 					auto conf = uniset_init(argc, argv, conffile);
 					UInterface ui(conf);
 					ui.initBackId(uniset::AdminID);
+
 					string name = ( optarg ) ? optarg : "";
 					return logRotate(name, ui);
 				}

Utilities/codegen/ctl-cpp-common.xsl

@@ -250,7 +250,7 @@
         std::string strval( uniset::ObjectId id, bool showLinkName=true ) const;        
         
         /*! Вывод состояния внутренних переменных */
-        inline std::string dumpVars(){ return std::move(vmon.pretty_str()); }
+        inline std::string dumpVars(){ return vmon.pretty_str(); }
         // ------------------------------------------------------------
         std::string help() noexcept;
 
@@ -416,6 +416,8 @@
 		
 		std::unordered_map<const uniset::ObjectId,size_t, StatHashFn> smStat; /*!< количество сообщений по датчикам */
 		size_t processingMessageCatchCount = { 0 }; /*!< количество исключений пойманных в processingMessage */
+		
+		std::string ostate = { "" }; /*!< состояние процесса (выводится в getInfo()) */
 		</xsl:if>
 </xsl:template>
 
@@ -476,22 +478,42 @@ void <xsl:value-of select="$CLASSNAME"/>_SK::preSysCommand( const SystemMessage*
 			}
 		case SystemMessage::StartUp:
 		{
+			ostate = "StartUp...";
+			try
+			{
 				if( !logserv_host.empty() &amp;&amp; logserv_port != 0 &amp;&amp; !logserv-&gt;isRunning() )
 				{
+					ostate = "StartUp: run log server...";
 					myinfo &lt;&lt; myname &lt;&lt; "(preSysCommand): run log server " &lt;&lt; logserv_host &lt;&lt; ":" &lt;&lt; logserv_port &lt;&lt; endl;
 					logserv-&gt;run(logserv_host, logserv_port, true);
 				}
+			}
+			catch( std::exception&amp; ex )
+			{
+				mywarn &lt;&lt; myname &lt;&lt; "(preSysCommand): CAN`t run log server err: " &lt;&lt; ex.what() &lt;&lt; endl;
+			}
+			catch( ... )
+			{
+				mywarn &lt;&lt; myname &lt;&lt; "(preSysCommand): CAN`t run log server err: catch ..." &lt;&lt; endl;
+			}
 
+			ostate = "StartUp: wait sm ready..";
 			waitSM(smReadyTimeout);
 			ptStartUpTimeout.reset();
 			// т.к. для io-переменных важно соблюдать последовательность!
 			// сперва обновить входы..
+			ostate = "StartUp: update values..";
 			updateValues();
+			ostate = "StartUp: init from SM..";
 			initFromSM(); // потом обновить значения переменных, помеченных как инициализируемые из SM
+			ostate = "StartUp: update outputs..";
 			updateOutputs(true); // а потом уже выходы (принудительное обновление)
+			ostate = "StartUp: pre ask sensors..";
 			preAskSensors(UniversalIO::UIONotify);
+			ostate = "StartUp: ask sensors..";
 			askSensors(UniversalIO::UIONotify);
 			active = true;
+			ostate = "StartUp: [OK]";
 			break;
 		}
 		
@@ -514,9 +536,20 @@ void <xsl:value-of select="$CLASSNAME"/>_SK::preSysCommand( const SystemMessage*
 			
 			if( logserv &amp;&amp; !logserv_host.empty() &amp;&amp; logserv_port != 0 )
 			{
+				try
+				{
 					mylogany &lt;&lt; myname &lt;&lt; "(preSysCommand): try restart logserver.." &lt;&lt; endl;
 					logserv-&gt;check(true);
 				}
+				catch( std::exception&amp; ex )
+				{
+					mywarn &lt;&lt; myname &lt;&lt; "(preSysCommand): CAN`t restart log server err: " &lt;&lt; ex.what() &lt;&lt; endl;
+				}
+				catch( ... )
+				{
+					mywarn &lt;&lt; myname &lt;&lt; "(preSysCommand): CAN`t restart log server err: catch ..." &lt;&lt; endl;
+				}
+			}
 		}
 		break;
 
@@ -536,6 +569,8 @@ uniset::SimpleInfo* <xsl:value-of select="$CLASSNAME"/>_SK::getInfo( const char*
 	ostringstream inf;
 	
 	inf &lt;&lt; i->info &lt;&lt; endl;
+	inf &lt;&lt; "process state: " &lt;&lt; ostate &lt;&lt; endl;
+	
 	if( logserv /* &amp;&amp; userparam &lt; 0 */ )
 	{
 		inf &lt;&lt; "LogServer: " &lt;&lt; logserv_host &lt;&lt; ":" &lt;&lt; logserv_port 
@@ -654,7 +689,7 @@ Poco::JSON::Object::Ptr <xsl:value-of select="$CLASSNAME"/>_SK::httpRequest( con
 Poco::JSON::Object::Ptr <xsl:value-of select="$CLASSNAME"/>_SK::httpRequestLog( const Poco::URI::QueryParameters&amp; p )
 {
 	Poco::JSON::Object::Ptr jret = new Poco::JSON::Object();
-	jret->set(myname,uniset::json::make_object("log", Debug::str(mylog->level())));
+	jret->set("log",Debug::str(mylog->level()));
 	return jret;
 }
 // -----------------------------------------------------------------------------
@@ -801,10 +836,7 @@ void <xsl:value-of select="$CLASSNAME"/>_SK::waitSM( int wait_msec, ObjectId _te
 			&lt;&lt; wait_msec &lt;&lt; " мсек";
 
         mycrit &lt;&lt; err.str() &lt;&lt; endl;
-//		terminate();
-//		abort();
-//		raise(SIGTERM);
-		std::terminate();
+		std::abort();
 //		throw uniset::SystemError(err.str());
 	}
 
@@ -816,10 +848,7 @@ void <xsl:value-of select="$CLASSNAME"/>_SK::waitSM( int wait_msec, ObjectId _te
 			&lt;&lt; wait_msec &lt;&lt; " мсек";
 	
 		mycrit &lt;&lt; err.str() &lt;&lt; endl;
-//		terminate();
-//		abort();
-		//raise(SIGTERM);
-		std::terminate();
+		std::abort();
 //		throw uniset::SystemError(err.str());
 	}
 }
@@ -849,7 +878,7 @@ std::string <xsl:value-of select="$CLASSNAME"/>_SK::help() noexcept
 	s &lt;&lt; " ****************************************************************************************** " &lt;&lt; endl;
 	
 	
-	return std::move(s.str());
+	return s.str();
 }
 // ----------------------------------------------------------------------------
 </xsl:template>
@@ -1230,9 +1259,9 @@ end_private(false)
 	if( smTestID == DefaultObjectId )
 		smTestID = getSMTestID();
 
-	activateTimeout	= conf->getArgPInt("--" + argprefix + "activate-timeout", 20000);
+	activateTimeout	= conf->getArgPInt("--" + argprefix + "activate-timeout", 90000);
 
-	int msec = conf->getArgPInt("--" + argprefix + "startup-timeout", 10000);
+	int msec = conf->getArgPInt("--" + argprefix + "startup-timeout", 50000);
 	ptStartUpTimeout.setTiming(msec);
 
 	// ===================== &lt;variables&gt; =====================
@@ -1500,7 +1529,7 @@ std::string  <xsl:value-of select="$CLASSNAME"/>_SK::dumpIO()
 			s &lt;&lt; std::endl;
 	}
 	
-	return std::move(s.str());
+	return s.str();
 }
 // ----------------------------------------------------------------------------
 std::string  <xsl:value-of select="$CLASSNAME"/>_SK::str( uniset::ObjectId id, bool showLinkName ) const
@@ -1511,7 +1540,7 @@ std::string  <xsl:value-of select="$CLASSNAME"/>_SK::str( uniset::ObjectId id, b
 	{
 		s &lt;&lt; "<xsl:call-template name="setprefix"/><xsl:value-of select="@name"/>";
 		if( showLinkName ) s &lt;&lt; "(" &lt;&lt; ORepHelpers::getShortName( uniset_conf()->oind->getMapName(<xsl:value-of select="@name"/>)) &lt;&lt; ")";
-		return std::move(s.str());
+		return s.str();
 	}
 	</xsl:for-each>	
 	return "";
@@ -1527,7 +1556,7 @@ std::string  <xsl:value-of select="$CLASSNAME"/>_SK::strval( uniset::ObjectId id
 		s &lt;&lt; "<xsl:call-template name="setprefix"/><xsl:value-of select="@name"/>";
 		if( showLinkName ) s &lt;&lt; "(" &lt;&lt; ORepHelpers::getShortName( uniset_conf()->oind->getMapName(<xsl:value-of select="@name"/>)) &lt;&lt; ")";		
 		s &lt;&lt; "=" &lt;&lt; <xsl:call-template name="setprefix"/><xsl:value-of select="@name"/>;
-		return std::move(s.str());
+		return s.str();
 	}
 	</xsl:for-each>	
 	return "";
@@ -1699,10 +1728,11 @@ askPause(uniset_conf()->getPIntProp(cnode,"askPause",2000))
 
 	vmonit(smTestID);
 	vmonit(smReadyTimeout);
+	vmonit(activateTimeout);
 
-	activateTimeout	= conf->getArgPInt("--" + argprefix + "activate-timeout", 20000);
+	activateTimeout	= conf->getArgPInt("--" + argprefix + "activate-timeout", 90000);
 
-	int msec = conf->getArgPInt("--" + argprefix + "startup-timeout", 10000);
+	int msec = conf->getArgPInt("--" + argprefix + "startup-timeout", 60000);
 	ptStartUpTimeout.setTiming(msec);
 }
 
@@ -1868,7 +1898,7 @@ std::string  <xsl:value-of select="$CLASSNAME"/>_SK::dumpIO()
 		  s &lt;&lt; endl;
 	}
 	
-	return std::move(s.str());
+	return s.str();
 }
 // ----------------------------------------------------------------------------
 std::string  <xsl:value-of select="$CLASSNAME"/>_SK::str( uniset::ObjectId id, bool showLinkName ) const
@@ -1881,7 +1911,7 @@ std::string  <xsl:value-of select="$CLASSNAME"/>_SK::str( uniset::ObjectId id, b
 	{
 		s &lt;&lt; "<xsl:call-template name="setprefix"/><xsl:value-of select="../../@name"/>";
 		if( showLinkName ) s &lt;&lt; "(<xsl:value-of select="../../@name"/>)";
-		return std::move(s.str());
+		return s.str();
 	}
 	</xsl:if>
 	</xsl:if>
@@ -1900,7 +1930,7 @@ std::string <xsl:value-of select="$CLASSNAME"/>_SK::strval( uniset::ObjectId id,
 		s &lt;&lt; "<xsl:call-template name="setprefix"/><xsl:value-of select="../../@name"/>";
 		if( showLinkName ) s &lt;&lt; " ( <xsl:value-of select="../../@name"/> )";
 		s &lt;&lt; "=" &lt;&lt; <xsl:call-template name="setprefix"/><xsl:value-of select="../../@name"/>;
-		return std::move(s.str());
+		return s.str();
 	}
 	</xsl:if>
 	</xsl:if>

conf/libuniset2.spec

@@ -18,7 +18,7 @@
 
 Name: libuniset2
 Version: 2.6
-Release: alt3.M80P.4
+Release: alt11.M80P.12
 Summary: UniSet - library for building distributed industrial control systems
 
 License: LGPL
@@ -79,7 +79,7 @@ BuildRequires(pre): rpm-build-python
 %endif
 
 %if_enabled docs
-BuildRequires: doxygen
+BuildRequires: doxygen graphviz ImageMagick-tools
 %endif
 
 %if_enabled tests
@@ -317,23 +317,23 @@ SharedMemoryPlus extension ('all in one') for libuniset
 
 %build
 %autoreconf
-%configure %{subst_enable docs} %{subst_enable mysql} %{subst_enable sqlite} %{subst_enable pgsql} %{subst_enable python} %{subst_enable rrd} %{subst_enable io} %{subst_enable logicproc} %{subst_enable tests} %{subst_enable mqtt} %{subst_enable api}
-%make
+%configure %{subst_enable docs} %{subst_enable mysql} %{subst_enable sqlite} %{subst_enable pgsql} %{subst_enable python} %{subst_enable rrd} %{subst_enable io} %{subst_enable logicproc} %{subst_enable tests} %{subst_enable mqtt} %{subst_enable api} %{subst_enable netdata}
+%make_build
+
+# fix for ALTLinux build (noarch)
+%if_enabled docs
+cd docs/html
+PNGFILES=`find ./ -name '*.png' -type f`
+for F in ${PNGFILES}; do
+#   echo "$F"
+    convert ${F} -flatten +matte ${F}
+done
+%endif
 
 %install
 %makeinstall_std
 rm -f %buildroot%_libdir/*.la
 
-%if_enabled python
-mkdir -p %buildroot%python_sitelibdir/%oname
-mv -f %buildroot%python_sitelibdir/*.* %buildroot%python_sitelibdir/%oname/
-
-%ifarch x86_64
-mv -f %buildroot%python_sitelibdir_noarch/* %buildroot%python_sitelibdir/%oname
-%endif
-
-%endif
-
 %files utils
 %_bindir/%oname-admin
 %_bindir/%oname-mb*
@@ -400,7 +400,8 @@ mv -f %buildroot%python_sitelibdir_noarch/* %buildroot%python_sitelibdir/%oname
 
 %if_enabled python
 %files -n python-module-%oname
-%python_sitelibdir/%oname/
+%python_sitelibdir/*
+%python_sitelibdir_noarch/%oname/*
 %endif
 
 %if_enabled netdata
@@ -509,9 +510,40 @@ mv -f %buildroot%python_sitelibdir_noarch/* %buildroot%python_sitelibdir/%oname
 # history of current unpublished changes
 
 %changelog
-* Wed Dec 07 2016 Pavel Vainerman <pv@altlinux.ru> 2.6-alt3.M80P.4
+* Mon Mar 06 2017 Pavel Vainerman <pv@altlinux.ru> 2.6-alt11.M80P.12
 - backport to ALTLinux p8 (by rpmbph script)
 
+* Mon Feb 27 2017 Pavel Vainerman <pv@altlinux.ru> 2.6-alt12
+- up version
+
+* Tue Feb 21 2017 Alexei Takaseev <taf@altlinux.org> 2.6-alt10.1
+- Rebuild with poco 1.7.7
+
+* Mon Jan 09 2017 Pavel Vainerman <pv@altlinux.ru> 2.6-alt10
+- add tests for REST API (with RPC)
+- python: refactoring UInterface (add UInterfaceModbus and UInterfaceUniSet)
+- refactoring TCPCheck (use future)
+- minor refactoring and fixes
+
+* Fri Dec 16 2016 Pavel Vainerman <pv@altlinux.ru> 2.6-alt9
+- UObject: added attempts to activate the object
+
+* Wed Dec 14 2016 Pavel Vainerman <pv@altlinux.ru> 2.6-alt8
+- SM: terminate if read dump (configuration) failed
+
+* Tue Dec 13 2016 Pavel Vainerman <pv@altlinux.ru> 2.6-alt7
+- Modbus: refactoring code and test (for 64bit)
+- iobase: refactoring tests for 64bit
+- TCPCheck: fixed bug (for exit thread)
+- UNetUDP: minor fixes in tests
+
+* Mon Dec 12 2016 Pavel Vainerman <pv@altlinux.ru> 2.6-alt6
+- codegen: up timeout or activate
+- codegen: add logs for startup
+
+* Thu Dec 08 2016 Pavel Vainerman <pv@altlinux.ru> 2.6-alt5
+- fixed bug in uniset2-admin --oinfo
+
 * Wed Dec 07 2016 Pavel Vainerman <pv@altlinux.ru> 2.6-alt4
 - new version
 - getChangedTime --> getTimeChange

conf/release_helper.sh

@@ -9,7 +9,6 @@ REL=eter
 MAILDOMAIN=server
 
 [ -z "$TOPDIR" ] && TOPDIR=/var/ftp/pub/Ourside
-[ -z "$GEN" ] && GEN=/var/ftp/pub/Ourside/$PLATFORM/genb.sh
 
 PKGNAME=uniset2
 SPECNAME=libuniset2.spec
@@ -22,6 +21,7 @@ fi
 PROJECT=$1
 test -n "$PROJECT" || PROJECT=$PKGNAME
 
+[ -z "$GEN" ] && GEN=/var/ftp/pub/Ourside/$PLATFORM/genb.sh
 [ -a "$GEN" ] || GEN="genbasedir --create --progress --topdir=$TOPDIR $PLATFORM $PROJECT"
 
 [ -z "$FTPDIR" ] && FTPDIR=$TOPDIR/$PLATFORM/RPMS.$PROJECT
@@ -62,13 +62,38 @@ function cp2ftp()
 
 # ------------------------------------------------------------------------
 
-add_changelog_helper "- new build" $SPECNAME
+ # Увеличиваем подрелиз (.x+1) до сборки!
+if [ -n "$BUILD_AUTOINCREMENT_SUBRELEASE" ]; then
+	inc_subrelease $SPECNAME
+
+	COMMIT="$(git rev-parse --verify HEAD)"
+	add_changelog -e "- (autobuild): commit $COMMIT" $SPECNAME
+
+elif [ -n "$JENKINS_BUILD_AUTOINCREMENT" ]; then
+	
+	rel="$(get_release $SPECNAME)"
+	
+	# Смотрим номер сборки в JENKINS
+	if [ -n "$BUILD_NUMBER" ]; then
+		rel="${rel}.${JENKINS_PREFIX}${BUILD_NUMBER}"
+		set_release $SPECNAME $rel
+	else
+		# просто увеличиваем subrelease
+		inc_subrelease $SPECNAME
+	fi
+
+	COMMIT="$(git rev-parse --verify HEAD)"
+	add_changelog -e "- (jenkinsbuild): commit $COMMIT" $SPECNAME
+else
+	# обычный build
+   add_changelog_helper "- new build" $SPECNAME
+fi
 
 rpmbb ${UNISET_BUILD_ADDON_OPTIONS} $SPECNAME || fatal "Can't build"
 
 cp2ftp
              
-rpmbs $SPECNAME
+#rpmbs $SPECNAME
 #send_notify
 
 # Увеличиваем релиз и запоминаем спек после успешной сборки

configure.ac

@@ -32,7 +32,7 @@ AC_ENABLE_SHARED(yes)
 AC_ENABLE_STATIC(no)
 AM_PROG_LIBTOOL
 
-ASTYLE_OPT="-A1 -T -C -S -L -w -Y -M -f -p --mode=c --lineend=linux --align-reference=type --align-pointer=type --suffix=none --style=ansi --max-instatement-indent=50"
+ASTYLE_OPT="-A1 -T -C -S -N -L -w -Y -M -f -p --mode=c --lineend=linux --align-reference=type --align-pointer=type --suffix=none --style=ansi"
 AC_SUBST(ASTYLE_OPT)
 
 # Checks for libraries.
@@ -40,19 +40,17 @@ PKG_CHECK_MODULES(XML, libxml-2.0)
 PKG_CHECK_MODULES(OMNI, omniORB4)
 PKG_CHECK_MODULES(SIGC, sigc++-2.0)
 
-nopkgchecklibev=false
-AC_ARG_ENABLE(pkgchecklibev, AC_HELP_STRING([--disable-pkgchecklibev], [disable pkg check modules for libev]),
-[ if test $enableval = yes; then nopkgchecklibev=false; else nopkgchecklibev=true; fi],[ nopkgchecklibev=false; ])
+checklibev=true
+PKG_CHECK_MODULES(EV, libev, [ checklibev=false; ], [ checklibev=true; ])
 
-if test ${nopkgchecklibev} = false; then
-	PKG_CHECK_MODULES(EV, libev)
-else	
+if test $checklibev = true; then
 	AC_CHECK_HEADER(ev++.h,,exit)
 	AC_SEARCH_LIBS(ev_run,ev,[],[],exit)
 	EV_LIBS="-lev"
 	EV_CFLAGS=
 	AC_SUBST(EV_LIBS)
 	AC_SUBST(EV_CFLAGS)
+    AC_MSG_RESULT([ok])
 fi
 
 #check rest api support
@@ -239,10 +237,24 @@ if test ${buildpython} = true; then
 	AC_MSG_RESULT([enabled])
 	dnl Python
 	AM_PATH_PYTHON(,,)
-	PKG_CHECK_MODULES(PYTHON,python,,exit)
+	PKG_CHECK_MODULES(PYTHON,python-2.7,,exit)
 #	AC_CHECK_PROG(SWIG, swig, yes, exit)
+
+	AC_MSG_CHECKING([netdata python plugin])
+	netdata=true
+	AC_ARG_ENABLE(netdata,AC_HELP_STRING([--disable-netdata], [disable build netdata python plugin]),
+	[ if test $enableval = yes; then netdata=true; else netdata=false;  fi],[ netdata=true; ])
+
+	if test ${netdata} = true; then
+		AC_MSG_RESULT([enabled])
+	else
+		AC_MSG_RESULT([disabled])
+	fi
+
+	AM_CONDITIONAL(HAVE_NETDATA, test ${netdata} = true)
 else
 	AC_MSG_RESULT([disabled])
+	AM_CONDITIONAL(HAVE_NETDATA, false)
 fi
 
 AM_CONDITIONAL(DISABLE_PYTHON, test ${buildpython} = false)
@@ -361,7 +373,7 @@ AM_CONDITIONAL(HAVE_TESTS, test ${buildtests} = true)
 # -D_GLIBCXX_USE_NANOSLEEP - for std::this_thread::sleep_for
 
 # -Weffc++ -Wno-unused-variable -Werror -Wctor-dtor-privacy
-CXX_EXTRA_FLAGS="-Wnon-virtual-dtor -Woverloaded-virtual -Woverflow -D_GLIBCXX_USE_NANOSLEEP"
+CXX_EXTRA_FLAGS="-Wnon-virtual-dtor -Woverloaded-virtual -Woverflow -D_GLIBCXX_USE_NANOSLEEP -fstack-protector"
 
 # export
 LDFLAGS="$LDFLAGS ${OMNI_LIBS} ${XML_LIBS} ${SIGC_LIBS} ${COV_LIBS} ${POCO_LIBS} ${EV_LIBS}"

extensions/DBServer-MySQL/DBServer_MySQL.h

@@ -29,8 +29,8 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-//------------------------------------------------------------------------------------------
-/*!
+	//------------------------------------------------------------------------------------------
+	/*!
 	      \page page_DBServer_MySQL (DBServer_MySQL) Реализация сервиса ведения БД на основе MySQL
 
 	      - \ref sec_DBS_Comm
@@ -84,9 +84,9 @@ namespace uniset
 
 	    \section sec_DBS_Tables Таблицы MySQL
 	      К основным таблицам относятся следующие:
-\code
-DROP TABLE IF EXISTS `main_history`;
-CREATE TABLE `main_history` (
+	\code
+	DROP TABLE IF EXISTS `main_history`;
+	CREATE TABLE `main_history` (
 	  `id` int(11) NOT NULL AUTO_INCREMENT,
 	  `date` date NOT NULL,
 	  `time` time NOT NULL,
@@ -98,10 +98,10 @@ CREATE TABLE `main_history` (
 	  PRIMARY KEY (`id`),
 	  KEY `main_history_sensor_id` (`sensor_id`),
 	  CONSTRAINT `sensor_id_refs_id_3d679168` FOREIGN KEY (`sensor_id`) REFERENCES `main_sensor` (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-DROP TABLE IF EXISTS `main_emergencylog`;
-CREATE TABLE `main_emergencylog` (
+	DROP TABLE IF EXISTS `main_emergencylog`;
+	CREATE TABLE `main_emergencylog` (
 	  `id` int(11) NOT NULL AUTO_INCREMENT,
 	  `date` date NOT NULL,
 	  `time` time NOT NULL,
@@ -110,11 +110,11 @@ CREATE TABLE `main_emergencylog` (
 	  PRIMARY KEY (`id`),
 	  KEY `main_emergencylog_type_id` (`type_id`),
 	  CONSTRAINT `type_id_refs_id_a3133ca` FOREIGN KEY (`type_id`) REFERENCES `main_emergencytype` (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
 
-DROP TABLE IF EXISTS `main_emergencyrecords`;
-CREATE TABLE `main_emergencyrecords` (
+	DROP TABLE IF EXISTS `main_emergencyrecords`;
+	CREATE TABLE `main_emergencyrecords` (
 	  `id` int(11) NOT NULL AUTO_INCREMENT,
 	  `date` date NOT NULL,
 	  `time` time NOT NULL,
@@ -127,16 +127,16 @@ CREATE TABLE `main_emergencyrecords` (
 	  KEY `main_emergencyrecords_sensor_id` (`sensor_id`),
 	  CONSTRAINT `log_id_refs_id_77a37ea9` FOREIGN KEY (`log_id`) REFERENCES `main_emergencylog` (`id`),
 	  CONSTRAINT `sensor_id_refs_id_436bab5e` FOREIGN KEY (`sensor_id`) REFERENCES `main_sensor` (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-\endcode
+	\endcode
 
-\warning Временно, для обратной совместимости поле 'time_usec' в таблицах оставлено с таким названием,
-хотя фактически туда сейчас сохраняется значение в наносекундах!
-*/
-class DBServer_MySQL:
+	\warning Временно, для обратной совместимости поле 'time_usec' в таблицах оставлено с таким названием,
+	хотя фактически туда сейчас сохраняется значение в наносекундах!
+	*/
+	class DBServer_MySQL:
 		public DBServer
-{
+	{
 		public:
 			DBServer_MySQL( uniset::ObjectId id, const std::string& prefix );
 			explicit DBServer_MySQL( const std::string& prefix );
@@ -204,8 +204,8 @@ class DBServer_MySQL:
 		private:
 			DBTableMap tblMap;
 
-};
-// ----------------------------------------------------------------------------------
+	};
+	// ----------------------------------------------------------------------------------
 } // end of namespace uniset
 //------------------------------------------------------------------------------------------
 #endif

extensions/DBServer-MySQL/MySQLInterface.cc

@@ -177,7 +177,7 @@ string MySQLInterface::addslashes( const string& str )
 		tmp << str[i];
 	}
 
-	return std::move(tmp.str());
+	return tmp.str();
 }
 // -----------------------------------------------------------------------------------------
 void MySQLInterface::makeResult(DBResult& dbres, MYSQL_RES* myres, bool finalize )

extensions/DBServer-MySQL/MySQLInterface.h

@@ -32,10 +32,10 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// ----------------------------------------------------------------------------
-class MySQLInterface:
+	// ----------------------------------------------------------------------------
+	class MySQLInterface:
 		public DBNetInterface
-{
+	{
 		public:
 
 			MySQLInterface();
@@ -80,8 +80,8 @@ class MySQLInterface:
 			MYSQL* mysql;
 			std::string lastQ;
 			bool connected;
-};
-// ----------------------------------------------------------------------------------
+	};
+	// ----------------------------------------------------------------------------------
 } // end of namespace uniset
 // ----------------------------------------------------------------------------------
 #endif

extensions/DBServer-PostgreSQL/DBServer_PostgreSQL.h

@@ -25,8 +25,8 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-//------------------------------------------------------------------------------------------
-/*!
+	//------------------------------------------------------------------------------------------
+	/*!
 	 * \brief The DBServer_PostgreSQL class
 	 * Реализация работы с PostgreSQL.
 	 *
@@ -51,9 +51,9 @@ namespace uniset
 	 * \warning Временно, для обратной совместимости поле 'time_usec' в таблицах оставлено с таким названием,
 	 * хотя фактически туда сейчас сохраняется значение в наносекундах!
 	 */
-class DBServer_PostgreSQL:
+	class DBServer_PostgreSQL:
 		public DBServer
-{
+	{
 		public:
 			DBServer_PostgreSQL( uniset::ObjectId id, const std::string& prefix );
 			DBServer_PostgreSQL();
@@ -133,8 +133,8 @@ class DBServer_PostgreSQL:
 		private:
 			DBTableMap tblMap;
 
-};
-// ----------------------------------------------------------------------------------
+	};
+	// ----------------------------------------------------------------------------------
 } // end of namespace uniset
 //------------------------------------------------------------------------------------------
 #endif

extensions/DBServer-PostgreSQL/PostgreSQLInterface.cc

@@ -182,7 +182,7 @@ DBResult PostgreSQLInterface::query( const string& q )
 		result res( n.exec(q) );
 		DBResult dbres;
 		makeResult(dbres, res);
-		return std::move(dbres);
+		return dbres;
 	}
 	catch( const std::exception& e )
 	{

extensions/DBServer-PostgreSQL/PostgreSQLInterface.h

@@ -28,10 +28,10 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// ----------------------------------------------------------------------------
-class PostgreSQLInterface:
+	// ----------------------------------------------------------------------------
+	class PostgreSQLInterface:
 		public DBNetInterface
-{
+	{
 		public:
 
 			PostgreSQLInterface();
@@ -69,8 +69,8 @@ class PostgreSQLInterface:
 			std::string lastQ;
 			std::string lastE;
 			double last_inserted_id;
-};
-// ----------------------------------------------------------------------------------
+	};
+	// ----------------------------------------------------------------------------------
 } // end of namespace uniset
 // ----------------------------------------------------------------------------
 #endif

extensions/DBServer-SQLite/DBServer_SQLite.h

@@ -29,8 +29,8 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-//------------------------------------------------------------------------------------------
-/*!
+	//------------------------------------------------------------------------------------------
+	/*!
 	      \page page_DBServer_SQLite (DBServer_SQLite) Реализация сервиса ведения БД на основе SQLite
 
 	      - \ref sec_DBS_Comm
@@ -84,9 +84,9 @@ namespace uniset
 
 	    \section sec_DBS_Tables Таблицы SQLite
 	      К основным таблицам относятся следующие (описание в формате MySQL!):
-\code
-DROP TABLE IF EXISTS `main_history`;
-CREATE TABLE `main_history` (
+	\code
+	DROP TABLE IF EXISTS `main_history`;
+	CREATE TABLE `main_history` (
 	  `id` int(11) NOT NULL AUTO_INCREMENT,
 	  `date` date NOT NULL,
 	  `time` time NOT NULL,
@@ -98,10 +98,10 @@ CREATE TABLE `main_history` (
 	  PRIMARY KEY (`id`),
 	  KEY `main_history_sensor_id` (`sensor_id`),
 	  CONSTRAINT `sensor_id_refs_id_3d679168` FOREIGN KEY (`sensor_id`) REFERENCES `main_sensor` (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-DROP TABLE IF EXISTS `main_emergencylog`;
-CREATE TABLE `main_emergencylog` (
+	DROP TABLE IF EXISTS `main_emergencylog`;
+	CREATE TABLE `main_emergencylog` (
 	  `id` int(11) NOT NULL AUTO_INCREMENT,
 	  `date` date NOT NULL,
 	  `time` time NOT NULL,
@@ -110,11 +110,11 @@ CREATE TABLE `main_emergencylog` (
 	  PRIMARY KEY (`id`),
 	  KEY `main_emergencylog_type_id` (`type_id`),
 	  CONSTRAINT `type_id_refs_id_a3133ca` FOREIGN KEY (`type_id`) REFERENCES `main_emergencytype` (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
 
-DROP TABLE IF EXISTS `main_emergencyrecords`;
-CREATE TABLE `main_emergencyrecords` (
+	DROP TABLE IF EXISTS `main_emergencyrecords`;
+	CREATE TABLE `main_emergencyrecords` (
 	  `id` int(11) NOT NULL AUTO_INCREMENT,
 	  `date` date NOT NULL,
 	  `time` time NOT NULL,
@@ -127,16 +127,16 @@ CREATE TABLE `main_emergencyrecords` (
 	  KEY `main_emergencyrecords_sensor_id` (`sensor_id`),
 	  CONSTRAINT `log_id_refs_id_77a37ea9` FOREIGN KEY (`log_id`) REFERENCES `main_emergencylog` (`id`),
 	  CONSTRAINT `sensor_id_refs_id_436bab5e` FOREIGN KEY (`sensor_id`) REFERENCES `main_sensor` (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+	) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-\endcode
+	\endcode
 
-\warning Временно, для обратной совместимости поле 'time_usec' в таблицах оставлено с таким названием,
-хотя фактически туда сейчас сохраняется значение в наносекундах!
-*/
-class DBServer_SQLite:
+	\warning Временно, для обратной совместимости поле 'time_usec' в таблицах оставлено с таким названием,
+	хотя фактически туда сейчас сохраняется значение в наносекундах!
+	*/
+	class DBServer_SQLite:
 		public DBServer
-{
+	{
 		public:
 			DBServer_SQLite( uniset::ObjectId id, const std::string& prefix );
 			explicit DBServer_SQLite( const std::string& prefix );
@@ -204,8 +204,8 @@ class DBServer_SQLite:
 		private:
 			DBTableMap tblMap;
 
-};
-// ----------------------------------------------------------------------------------
+	};
+	// ----------------------------------------------------------------------------------
 } // end of namespace uniset
 //------------------------------------------------------------------------------------------
 #endif

extensions/DBServer-SQLite/SQLiteInterface.h

@@ -31,11 +31,11 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// ----------------------------------------------------------------------------
-/*!  \page SQLiteIntarface  Интерфейс к SQLite
+	// ----------------------------------------------------------------------------
+	/*!  \page SQLiteIntarface  Интерфейс к SQLite
 
 	   Пример использования:
-\code
+	\code
 	    try
 	    {
 	        SQLiteInterface db;
@@ -74,17 +74,17 @@ namespace uniset
 	    {
 	        cerr << "(test): catch ..." << endl;
 	    }
-\endcode
-*/
-// ----------------------------------------------------------------------------
-// Памятка:
-// Включение режима для журнала - "вести в памяти" (чтобы поберечь CompactFlash)
-// PRAGMA journal_mode = MEMORY
-// При этом конечно есть риск потерять данные при выключении..
-// ----------------------------------------------------------------------------
-class SQLiteInterface:
+	\endcode
+	*/
+	// ----------------------------------------------------------------------------
+	// Памятка:
+	// Включение режима для журнала - "вести в памяти" (чтобы поберечь CompactFlash)
+	// PRAGMA journal_mode = MEMORY
+	// При этом конечно есть риск потерять данные при выключении..
+	// ----------------------------------------------------------------------------
+	class SQLiteInterface:
 		public DBInterface
-{
+	{
 		public:
 
 			SQLiteInterface();
@@ -137,8 +137,8 @@ class SQLiteInterface:
 
 			timeout_t opTimeout;
 			timeout_t opCheckPause;
-};
-// ----------------------------------------------------------------------------------
+	};
+	// ----------------------------------------------------------------------------------
 } // end of namespace uniset
 // ----------------------------------------------------------------------------
 #endif

extensions/IOControl/ComediInterface.h

@@ -23,10 +23,10 @@
 //--------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*! Интерфейс для работы с в/в */
-class ComediInterface
-{
+	// -----------------------------------------------------------------------------
+	/*! Интерфейс для работы с в/в */
+	class ComediInterface
+	{
 		public:
 			explicit ComediInterface( const std::string& dev );
 			~ComediInterface();
@@ -81,8 +81,8 @@ class ComediInterface
 			std::string dname;
 
 		private:
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // ComediInterface_H_

extensions/IOControl/IOControl.h

@@ -42,8 +42,8 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*!
+	// -----------------------------------------------------------------------------
+	/*!
 	      \page page_IOControl (IOControl) Реализация процесса ввода/вывода
 
 	      - \ref sec_IOC_Comm
@@ -180,13 +180,13 @@ namespace uniset
 	        указан параметр disable_testmode="1".
 	    <br>\b "4" - Режим "только входы"
 	    <br>\b "5" - Режим "только выходы"
-*/
-// -----------------------------------------------------------------------------
-/*! \todo (IOControl): Сделать обработку сигналов завершения */
+	*/
+	// -----------------------------------------------------------------------------
+	/*! \todo (IOControl): Сделать обработку сигналов завершения */
 
-class CardList:
+	class CardList:
 		public std::vector<ComediInterface*>
-{
+	{
 		public:
 
 			explicit CardList( size_t size ) : std::vector<ComediInterface * >(size) { }
@@ -205,9 +205,9 @@ class CardList:
 				return NULL;
 			}
 
-};
+	};
 
-/*!
+	/*!
 	    Процесс работы с картами в/в.
 	    Задачи:
 	    - опрос дискретных и аналоговых входов, выходов
@@ -221,10 +221,10 @@ class CardList:
 	    - определение обрыва провода (для аналоговых сигналов)
 	    - мигание лампочками
 	    - тест ламп
-*/
-class IOControl:
+	*/
+	class IOControl:
 		public UniSetObject
-{
+	{
 		public:
 			IOControl( uniset::ObjectId id, uniset::ObjectId icID, const std::shared_ptr<SharedMemory>& shm = nullptr, int numcards = 2, const std::string& prefix = "io" );
 			virtual ~IOControl();
@@ -418,8 +418,8 @@ class IOControl:
 			int logserv_port = {0};
 
 		private:
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // IOControl_H_

extensions/LogicProcessor/Element.cc

@@ -20,14 +20,14 @@
 // -----------------------------------------------------------------------------
 namespace uniset
 {
-// -------------------------------------------------------------------------
-using namespace std;
-// -------------------------------------------------------------------------
-const Element::ElementID Element::DefaultElementID = "?id?";
-// -------------------------------------------------------------------------
+	// -------------------------------------------------------------------------
+	using namespace std;
+	// -------------------------------------------------------------------------
+	const Element::ElementID Element::DefaultElementID = "?id?";
+	// -------------------------------------------------------------------------
 
-void Element::addChildOut( std::shared_ptr<Element> el, size_t num )
-{
+	void Element::addChildOut( std::shared_ptr<Element> el, size_t num )
+	{
 		if( el.get() == this )
 		{
 			ostringstream msg;
@@ -57,10 +57,10 @@ void Element::addChildOut( std::shared_ptr<Element> el, size_t num )
 		}
 
 		outs.emplace_front(el, num);
-}
-// -------------------------------------------------------------------------
-void Element::delChildOut( std::shared_ptr<Element> el )
-{
+	}
+	// -------------------------------------------------------------------------
+	void Element::delChildOut( std::shared_ptr<Element> el )
+	{
 		for( auto it = outs.begin(); it != outs.end(); ++it )
 		{
 			if( it->el == el )
@@ -69,19 +69,19 @@ void Element::delChildOut( std::shared_ptr<Element> el )
 				return;
 			}
 		}
-}
+	}
 
-// -------------------------------------------------------------------------
-void Element::setChildOut()
-{
+	// -------------------------------------------------------------------------
+	void Element::setChildOut()
+	{
 		bool _myout = getOut();
 
 		for( auto && it : outs )
 			it.el->setIn(it.num, _myout);
-}
-// -------------------------------------------------------------------------
-std::shared_ptr<Element> Element::find(const ElementID& id )
-{
+	}
+	// -------------------------------------------------------------------------
+	std::shared_ptr<Element> Element::find(const ElementID& id )
+	{
 		for( const auto& it : outs )
 		{
 			if( it.el->getId() == id )
@@ -91,10 +91,10 @@ std::shared_ptr<Element> Element::find(const ElementID& id )
 		}
 
 		return nullptr;
-}
-// -------------------------------------------------------------------------
-void Element::addInput(size_t num, bool state)
-{
+	}
+	// -------------------------------------------------------------------------
+	void Element::addInput(size_t num, bool state)
+	{
 		for( auto& it : ins )
 		{
 			if( it.num == num )
@@ -106,10 +106,10 @@ void Element::addInput(size_t num, bool state)
 		}
 
 		ins.emplace_front(num, state);
-}
-// -------------------------------------------------------------------------
-void Element::delInput(size_t num )
-{
+	}
+	// -------------------------------------------------------------------------
+	void Element::delInput(size_t num )
+	{
 		for( auto it = ins.begin(); it != ins.end(); ++it )
 		{
 			if( it->num == num )
@@ -118,6 +118,6 @@ void Element::delInput(size_t num )
 				return;
 			}
 		}
-}
-// -------------------------------------------------------------------------
+	}
+	// -------------------------------------------------------------------------
 } // end of namespace uniset

extensions/LogicProcessor/Element.h

@@ -25,19 +25,19 @@
 //--------------------------------------------------------------------------
 namespace uniset
 {
-// --------------------------------------------------------------------------
+	// --------------------------------------------------------------------------
 
-class LogicException:
+	class LogicException:
 		public uniset::Exception
-{
+	{
 		public:
 			LogicException(): uniset::Exception("LogicException") {}
 			explicit LogicException( const std::string& err): uniset::Exception(err) {}
-};
+	};
 
 
-class Element
-{
+	class Element
+	{
 		public:
 
 			typedef std::string ElementID;
@@ -135,11 +135,11 @@ class Element
 		private:
 
 
-};
-// ---------------------------------------------------------------------------
-class TOR:
+	};
+	// ---------------------------------------------------------------------------
+	class TOR:
 		public Element
-{
+	{
 
 		public:
 			TOR( ElementID id, size_t numbers = 0, bool st = false );
@@ -162,11 +162,11 @@ class TOR:
 
 
 		private:
-};
-// ---------------------------------------------------------------------------
-class TAND:
+	};
+	// ---------------------------------------------------------------------------
+	class TAND:
 		public TOR
-{
+	{
 
 		public:
 			TAND(ElementID id, size_t numbers = 0, bool st = false );
@@ -182,13 +182,13 @@ class TAND:
 			TAND() {}
 
 		private:
-};
+	};
 
-// ---------------------------------------------------------------------------
-// элемент с одним входом и выходом
-class TNOT:
+	// ---------------------------------------------------------------------------
+	// элемент с одним входом и выходом
+	class TNOT:
 		public Element
-{
+	{
 
 		public:
 			TNOT( ElementID id, bool out_default );
@@ -214,8 +214,8 @@ class TNOT:
 			bool myout;
 
 		private:
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // ---------------------------------------------------------------------------
 #endif

extensions/LogicProcessor/LProcessor.h

@@ -110,9 +110,9 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// --------------------------------------------------------------------------
-class LProcessor
-{
+	// --------------------------------------------------------------------------
+	class LProcessor
+	{
 		public:
 			explicit LProcessor( const std::string& name = "" );
 			virtual ~LProcessor();
@@ -186,8 +186,8 @@ class LProcessor
 			std::string fSchema = {""};
 
 		private:
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // ---------------------------------------------------------------------------
 #endif

extensions/LogicProcessor/PassiveLProcessor.h

@@ -29,12 +29,12 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -------------------------------------------------------------------------
-/*! Реализация LogicProccessor основанная на заказе датчиков */
-class PassiveLProcessor:
+	// -------------------------------------------------------------------------
+	/*! Реализация LogicProccessor основанная на заказе датчиков */
+	class PassiveLProcessor:
 		public UniSetObject,
 		protected LProcessor
-{
+	{
 		public:
 
 			PassiveLProcessor(uniset::ObjectId objId,
@@ -78,8 +78,8 @@ class PassiveLProcessor:
 			int maxHeartBeat = { 10 };
 			IOController::IOStateList::iterator itHeartBeat;
 			std::mutex mutex_start;
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // ---------------------------------------------------------------------------
 #endif

extensions/LogicProcessor/Schema.cc

@@ -21,21 +21,21 @@
 // -----------------------------------------------------------------------------
 namespace uniset
 {
-// -------------------------------------------------------------------------
-using namespace std;
-using namespace uniset::extensions;
-// -------------------------------------------------------------------------
+	// -------------------------------------------------------------------------
+	using namespace std;
+	using namespace uniset::extensions;
+	// -------------------------------------------------------------------------
 
-Schema::Schema()
-{
-}
+	Schema::Schema()
+	{
+	}
 
-Schema::~Schema()
-{
-}
-// -------------------------------------------------------------------------
-void Schema::link( Element::ElementID rootID, Element::ElementID childID, int numIn )
-{
+	Schema::~Schema()
+	{
+	}
+	// -------------------------------------------------------------------------
+	void Schema::link( Element::ElementID rootID, Element::ElementID childID, int numIn )
+	{
 		std::shared_ptr<Element> e1;
 		std::shared_ptr<Element> e2;
 
@@ -65,10 +65,10 @@ void Schema::link( Element::ElementID rootID, Element::ElementID childID, int nu
 
 		// сохраняем в список соединений
 		inLinks.emplace_front(e1, e2, numIn);
-}
-// -------------------------------------------------------------------------
-void Schema::unlink( Element::ElementID rootID, Element::ElementID childID )
-{
+	}
+	// -------------------------------------------------------------------------
+	void Schema::unlink( Element::ElementID rootID, Element::ElementID childID )
+	{
 		std::shared_ptr<Element> e1;
 		std::shared_ptr<Element> e2;
 
@@ -105,10 +105,10 @@ void Schema::unlink( Element::ElementID rootID, Element::ElementID childID )
 				break;
 			}
 		}
-}
-// -------------------------------------------------------------------------
-void Schema::extlink( const string& name, Element::ElementID childID, int numIn )
-{
+	}
+	// -------------------------------------------------------------------------
+	void Schema::extlink( const string& name, Element::ElementID childID, int numIn )
+	{
 		auto it = emap.find(childID);
 
 		if( it == emap.end() )
@@ -126,20 +126,20 @@ void Schema::extlink( const string& name, Element::ElementID childID, int numIn
 
 		// заносим в список
 		extLinks.emplace_front(name, el, numIn);
-}
-// -------------------------------------------------------------------------
-std::shared_ptr<Element> Schema::manage( std::shared_ptr<Element> el )
-{
+	}
+	// -------------------------------------------------------------------------
+	std::shared_ptr<Element> Schema::manage( std::shared_ptr<Element> el )
+	{
 		dinfo << "Schema: manage new element id=" << el->getId()
 			  << " type=" << el->getType()
 			  << " inputs=" << el->inCount() << endl;
 
 		emap[el->getId()] = el;
 		return el;
-}
-// -------------------------------------------------------------------------
-void Schema::remove( std::shared_ptr<Element> el )
-{
+	}
+	// -------------------------------------------------------------------------
+	void Schema::remove( std::shared_ptr<Element> el )
+	{
 		for( auto && it = emap.begin(); it != emap.end(); ++it )
 		{
 			if( it->second == el )
@@ -166,18 +166,18 @@ void Schema::remove( std::shared_ptr<Element> el )
 				lit.to = 0;
 		}
 
-}
-// -------------------------------------------------------------------------
-void Schema::setIn( Element::ElementID ID, int inNum, bool state )
-{
+	}
+	// -------------------------------------------------------------------------
+	void Schema::setIn( Element::ElementID ID, int inNum, bool state )
+	{
 		auto it = emap.find(ID);
 
 		if( it != emap.end() )
 			it->second->setIn(inNum, state);
-}
-// -------------------------------------------------------------------------
-bool Schema::getOut( Element::ElementID ID )
-{
+	}
+	// -------------------------------------------------------------------------
+	bool Schema::getOut( Element::ElementID ID )
+	{
 		auto it = emap.find(ID);
 
 		if( it != emap.end() )
@@ -186,20 +186,20 @@ bool Schema::getOut( Element::ElementID ID )
 		ostringstream msg;
 		msg << "Schema: element id=" << ID << " NOT FOUND!";
 		throw LogicException(msg.str());
-}
-// -------------------------------------------------------------------------
-std::shared_ptr<Element> Schema::find( Element::ElementID id )
-{
+	}
+	// -------------------------------------------------------------------------
+	std::shared_ptr<Element> Schema::find( Element::ElementID id )
+	{
 		auto it = emap.find(id);
 
 		if( it != emap.end() )
 			return it->second;
 
 		return nullptr;
-}
-// -------------------------------------------------------------------------
-std::shared_ptr<Element> Schema::findExtLink( const string& name )
-{
+	}
+	// -------------------------------------------------------------------------
+	std::shared_ptr<Element> Schema::findExtLink( const string& name )
+	{
 		// помечаем внешние связи
 		for( const auto& it : extLinks )
 		{
@@ -208,10 +208,10 @@ std::shared_ptr<Element> Schema::findExtLink( const string& name )
 		}
 
 		return nullptr;
-}
-// -------------------------------------------------------------------------
-std::shared_ptr<Element> Schema::findOut( const string& name )
-{
+	}
+	// -------------------------------------------------------------------------
+	std::shared_ptr<Element> Schema::findOut( const string& name )
+	{
 		// помечаем внешние связи
 		for( const auto& it : outList )
 		{
@@ -220,6 +220,6 @@ std::shared_ptr<Element> Schema::findOut( const string& name )
 		}
 
 		return nullptr;
-}
-// -------------------------------------------------------------------------
+	}
+	// -------------------------------------------------------------------------
 } // end of namespace uniset

extensions/LogicProcessor/Schema.h

@@ -24,9 +24,9 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// --------------------------------------------------------------------------
-class Schema
-{
+	// --------------------------------------------------------------------------
+	class Schema
+	{
 		public:
 			Schema();
 			virtual ~Schema();
@@ -177,11 +177,11 @@ class Schema
 			OutputsList outList;
 
 		private:
-};
-// ---------------------------------------------------------------------------
-class SchemaXML:
+	};
+	// ---------------------------------------------------------------------------
+	class SchemaXML:
 		public Schema
-{
+	{
 		public:
 			SchemaXML();
 			virtual ~SchemaXML();
@@ -189,8 +189,8 @@ class SchemaXML:
 			void read( const std::string& xmlfile );
 
 		protected:
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // ---------------------------------------------------------------------------
 #endif

extensions/LogicProcessor/SchemaXML.cc

@@ -23,20 +23,20 @@
 // -----------------------------------------------------------------------------
 namespace uniset
 {
-// -------------------------------------------------------------------------
-using namespace std;
-using namespace uniset::extensions;
-// -------------------------------------------------------------------------
-SchemaXML::SchemaXML()
-{
-}
+	// -------------------------------------------------------------------------
+	using namespace std;
+	using namespace uniset::extensions;
+	// -------------------------------------------------------------------------
+	SchemaXML::SchemaXML()
+	{
+	}
 
-SchemaXML::~SchemaXML()
-{
-}
-// -------------------------------------------------------------------------
-void SchemaXML::read( const string& xmlfile )
-{
+	SchemaXML::~SchemaXML()
+	{
+	}
+	// -------------------------------------------------------------------------
+	void SchemaXML::read( const string& xmlfile )
+	{
 		UniXML xml;
 
 		const string sec("elements");
@@ -146,6 +146,6 @@ void SchemaXML::read( const string& xmlfile )
 				outList.emplace_front(tID, el);
 			}
 		}
-}
-// -------------------------------------------------------------------------
+	}
+	// -------------------------------------------------------------------------
 } // end of namespace uniset

extensions/LogicProcessor/TAND.cc

@@ -20,21 +20,21 @@
 // -----------------------------------------------------------------------------
 namespace uniset
 {
-// -------------------------------------------------------------------------
-using namespace std;
-using namespace uniset::extensions;
-// -------------------------------------------------------------------------
-TAND::TAND(ElementID id, size_t num, bool st):
+	// -------------------------------------------------------------------------
+	using namespace std;
+	using namespace uniset::extensions;
+	// -------------------------------------------------------------------------
+	TAND::TAND(ElementID id, size_t num, bool st):
 		TOR(id, num, st)
-{
-}
+	{
+	}
 
-TAND::~TAND()
-{
-}
-// -------------------------------------------------------------------------
-void TAND::setIn(size_t num, bool state )
-{
+	TAND::~TAND()
+	{
+	}
+	// -------------------------------------------------------------------------
+	void TAND::setIn(size_t num, bool state )
+	{
 		//    cout << this << ": input " << num << " set " << state << endl;
 		for( auto& it : ins )
 		{
@@ -70,6 +70,6 @@ void TAND::setIn(size_t num, bool state )
 
 		if( prev != myout )
 			Element::setChildOut();
-}
-// -------------------------------------------------------------------------
+	}
+	// -------------------------------------------------------------------------
 } // end of namespace uniset

extensions/LogicProcessor/TDelay.cc

@@ -20,29 +20,29 @@
 // -----------------------------------------------------------------------------
 namespace uniset
 {
-// -------------------------------------------------------------------------
-using namespace std;
-using namespace uniset::extensions;
-// -------------------------------------------------------------------------
-TDelay::TDelay(Element::ElementID id, timeout_t delayMS, size_t inCount):
+	// -------------------------------------------------------------------------
+	using namespace std;
+	using namespace uniset::extensions;
+	// -------------------------------------------------------------------------
+	TDelay::TDelay(Element::ElementID id, timeout_t delayMS, size_t inCount):
 		Element(id),
 		myout(false),
 		delay(delayMS)
-{
+	{
 		if( inCount != 0 )
 		{
 			// создаём заданное количество входов
 			for( unsigned int i = 1; i <= inCount; i++ )
 				ins.emplace_front(i, false); // addInput(i,st);
 		}
-}
+	}
 
-TDelay::~TDelay()
-{
-}
-// -------------------------------------------------------------------------
-void TDelay::setIn( size_t num, bool state )
-{
+	TDelay::~TDelay()
+	{
+	}
+	// -------------------------------------------------------------------------
+	void TDelay::setIn( size_t num, bool state )
+	{
 		bool prev = myout;
 
 		// сбрасываем сразу
@@ -79,10 +79,10 @@ void TDelay::setIn( size_t num, bool state )
 			dinfo << this << ": set timer " << delay << " [msec]" << endl;
 			pt.setTiming(delay);
 		}
-}
-// -------------------------------------------------------------------------
-void TDelay::tick()
-{
+	}
+	// -------------------------------------------------------------------------
+	void TDelay::tick()
+	{
 		if( pt.getInterval() != 0 && pt.checkTime() )
 		{
 			myout = true;
@@ -90,16 +90,16 @@ void TDelay::tick()
 			dinfo << getType() << "(" << myid << "): TIMER!!!! myout=" << myout << endl;
 			Element::setChildOut();
 		}
-}
-// -------------------------------------------------------------------------
-bool TDelay::getOut() const
-{
+	}
+	// -------------------------------------------------------------------------
+	bool TDelay::getOut() const
+	{
 		return myout;
-}
-// -------------------------------------------------------------------------
-void TDelay::setDelay( timeout_t timeMS )
-{
+	}
+	// -------------------------------------------------------------------------
+	void TDelay::setDelay( timeout_t timeMS )
+	{
 		delay = timeMS;
-}
-// -------------------------------------------------------------------------
+	}
+	// -------------------------------------------------------------------------
 } // end of namespace uniset

extensions/LogicProcessor/TDelay.h

@@ -22,12 +22,12 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// ---------------------------------------------------------------------------
-// "ON" delay element
-// Сбрасывается без задержки.. а срабатывает с задержкой.
-class TDelay:
+	// ---------------------------------------------------------------------------
+	// "ON" delay element
+	// Сбрасывается без задержки.. а срабатывает с задержкой.
+	class TDelay:
 		public Element
-{
+	{
 
 		public:
 			TDelay( Element::ElementID id, timeout_t delayMS = 0, size_t inCount = 0 );
@@ -55,8 +55,8 @@ class TDelay:
 			timeout_t delay;
 
 		private:
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // ---------------------------------------------------------------------------
 #endif

extensions/LogicProcessor/TNOT.cc

@@ -21,28 +21,28 @@
 // -----------------------------------------------------------------------------
 namespace uniset
 {
-// -------------------------------------------------------------------------
-using namespace std;
-using namespace uniset::extensions;
-// -------------------------------------------------------------------------
-TNOT::TNOT( ElementID id, bool out_default ):
+	// -------------------------------------------------------------------------
+	using namespace std;
+	using namespace uniset::extensions;
+	// -------------------------------------------------------------------------
+	TNOT::TNOT( ElementID id, bool out_default ):
 		Element(id),
 		myout(out_default)
-{
+	{
 		ins.emplace_front(1, !out_default);
-}
-// -------------------------------------------------------------------------
-TNOT::~TNOT()
-{
-}
-// -------------------------------------------------------------------------
-void TNOT::setIn( size_t num, bool state )
-{
+	}
+	// -------------------------------------------------------------------------
+	TNOT::~TNOT()
+	{
+	}
+	// -------------------------------------------------------------------------
+	void TNOT::setIn( size_t num, bool state )
+	{
 		bool prev = myout;
 		myout = !state;
 
 		if( prev != myout )
 			Element::setChildOut();
-}
-// -------------------------------------------------------------------------
+	}
+	// -------------------------------------------------------------------------
 } // end of namespace uniset

extensions/LogicProcessor/TOR.cc

@@ -21,14 +21,14 @@
 // -----------------------------------------------------------------------------
 namespace uniset
 {
-// -------------------------------------------------------------------------
-using namespace std;
-using namespace uniset::extensions;
-// -------------------------------------------------------------------------
-TOR::TOR(ElementID id, size_t num, bool st):
+	// -------------------------------------------------------------------------
+	using namespace std;
+	using namespace uniset::extensions;
+	// -------------------------------------------------------------------------
+	TOR::TOR(ElementID id, size_t num, bool st):
 		Element(id),
 		myout(false)
-{
+	{
 		if( num != 0 )
 		{
 			// создаём заданное количество входов
@@ -40,14 +40,14 @@ TOR::TOR(ElementID id, size_t num, bool st):
 					myout = true;
 			}
 		}
-}
+	}
 
-TOR::~TOR()
-{
-}
-// -------------------------------------------------------------------------
-void TOR::setIn( size_t num, bool state )
-{
+	TOR::~TOR()
+	{
+	}
+	// -------------------------------------------------------------------------
+	void TOR::setIn( size_t num, bool state )
+	{
 		//    cout << getType() << "(" << myid << "):  input " << num << " set " << state << endl;
 
 		for( auto& it : ins )
@@ -84,6 +84,6 @@ void TOR::setIn( size_t num, bool state )
 
 		if( prev != myout )
 			Element::setChildOut();
-}
-// -------------------------------------------------------------------------
+	}
+	// -------------------------------------------------------------------------
 } // end of namespace uniset

extensions/MQTTPublisher/MQTTPublisher.cc

@@ -412,6 +412,6 @@ std::string MQTTPublisher::MQTTTextInfo::replace( RangeInfo* ri, long value )
 	txt = replace_all(txt, "%rmax", smax.str());
 	txt = replace_all(txt, "%r", r.str());
 
-	return std::move(txt);
+	return txt;
 }
 //--------------------------------------------------------------------------------

extensions/MQTTPublisher/MQTTPublisher.h

@@ -28,8 +28,8 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*!
+	// -----------------------------------------------------------------------------
+	/*!
 		\page page_MQTTPublisher Реализация MQTT издателя
 
 		  - \ref sec_MQTT_Comm
@@ -102,11 +102,11 @@ namespace uniset
 
 		\note Если заданные "одиночные" значения совпадают с диапазоном, то будет сгенерировано несколько сообщений. Т.е. диапазоны могут пересекатся.
 
-*/
-class MQTTPublisher:
+	*/
+	class MQTTPublisher:
 		protected mosqpp::mosquittopp,
 		public UObject_SK
-{
+	{
 		public:
 			MQTTPublisher( uniset::ObjectId objId, xmlNode* cnode, uniset::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr,
 						   const std::string& prefix = "mqtt" );
@@ -185,8 +185,8 @@ class MQTTPublisher:
 			std::string host = { "localhost" };
 			int port = { 1883 };
 			int keepalive = { 60 };
-};
-// ----------------------------------------------------------------------------------
+	};
+	// ----------------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // _MQTTPublisher_H_

extensions/ModbusMaster/MBExchange.h

@@ -48,13 +48,13 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*!
+	// -----------------------------------------------------------------------------
+	/*!
 	    \par Базовый класс для реализация обмена по протоколу Modbus [RTU|TCP].
-*/
-class MBExchange:
+	*/
+	class MBExchange:
 		public UniSetObject
-{
+	{
 		public:
 			MBExchange( uniset::ObjectId objId, uniset::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr,
 						const std::string& prefix = "mb" );
@@ -407,8 +407,8 @@ class MBExchange:
 		private:
 			MBExchange();
 
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // _MBExchange_H_

extensions/ModbusMaster/MBTCPMaster.h

@@ -27,8 +27,8 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*!
+	// -----------------------------------------------------------------------------
+	/*!
 	      \page page_ModbusTCP Реализация ModbusTCP master
 
 	      - \ref sec_MBTCP_Comm
@@ -150,7 +150,7 @@ namespace uniset
 	     />
 	    ...
 	  </sensors>
-\endcode
+	\endcode
 
 	   \warning По умолчанию для свойств используется префикс "tcp_". Но если задано поле \b filter-field,
 	    то для свойств будет использован префикс <b>"filter-fileld"_</b>.
@@ -207,9 +207,9 @@ namespace uniset
 	    Режимы переключаются при помощи датчика, который можно задать либо аргументом командной строки
 	    \b --prefix-exchange-mode-id либо в конф. файле параметром \b exchangeModeID="". Константы определяющие режимы объявлены в MBTCPMaster::ExchangeMode.
 
-*/
-// -----------------------------------------------------------------------------
-/*!
+	*/
+	// -----------------------------------------------------------------------------
+	/*!
 	    \par Реализация Modbus TCP Master для обмена с многими ModbusRTU устройствами
 	    через один modbus tcp шлюз.
 
@@ -217,10 +217,10 @@ namespace uniset
 	    на создании соединения с недоступным хостом. Обмен вынесен в отдельный поток.
 	    При этом в этом же потоке обновляются данные в SM. В свою очередь информация о датчиках
 	    связи обновляется в основном потоке (чтобы не зависеть от TCP).
-*/
-class MBTCPMaster:
+	*/
+	class MBTCPMaster:
 		public MBExchange
-{
+	{
 		public:
 			MBTCPMaster( uniset::ObjectId objId, uniset::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr,
 						 const std::string& prefix = "mbtcp" );
@@ -257,8 +257,8 @@ class MBTCPMaster:
 			// т.к. TCP может "зависнуть" на подключении к недоступному узлу
 			// делаем опрос в отдельном потоке
 			std::shared_ptr<ThreadCreator<MBTCPMaster>> pollThread; /*!< поток опроса */
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // _MBTCPMaster_H_

extensions/ModbusMaster/MBTCPMultiMaster.cc

@@ -758,7 +758,7 @@ const std::string MBTCPMultiMaster::MBSlaveInfo::getShortInfo() const
 	  << " persistent-connection=" << !force_disconnect
 	  << ")";
 
-	return std::move(s.str());
+	return s.str();
 }
 // -----------------------------------------------------------------------------
 uniset::SimpleInfo* MBTCPMultiMaster::getInfo( const char* userparam )

extensions/ModbusMaster/MBTCPMultiMaster.h

@@ -26,8 +26,8 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*!
+	// -----------------------------------------------------------------------------
+	/*!
 	      \page page_ModbusTCPMulti Реализация ModbusTCP 'multi' master
 
 	      - \ref sec_MBTCPM_Comm
@@ -182,7 +182,7 @@ namespace uniset
 	     />
 	    ...
 	  </sensors>
-\endcode
+	\endcode
 
 	   \warning По умолчанию для свойств используется префикс "tcp_". Но если задано поле \b filter-field,
 	    то для свойств будет использован префикс <b>"filter-fileld"_</b>.
@@ -271,9 +271,9 @@ namespace uniset
 		постоянным, в отличие от "первого способа" при котором оно создаётся и сразу рвётся и если проверка
 		настроена достаточно часто ( < TIME_WAIT для сокетов), то при длительной работе могут закончится дескрипторы
 		на создание сокетов.
-*/
-// -----------------------------------------------------------------------------
-/*!
+	*/
+	// -----------------------------------------------------------------------------
+	/*!
 		\par Реализация Modbus TCP MultiMaster для обмена с многими ModbusRTU устройствами
 	    через один modbus tcp шлюз, доступный по нескольким ip-адресам.
 
@@ -281,10 +281,10 @@ namespace uniset
 	    на создании соединения с недоступным хостом. Обмен вынесен в отдельный поток.
 	    При этом в этом же потоке обновляются данные в SM. В свою очередь информация о датчиках
 	    связи обновляется в основном потоке (чтобы не зависеть от TCP).
-*/
-class MBTCPMultiMaster:
+	*/
+	class MBTCPMultiMaster:
 		public MBExchange
-{
+	{
 		public:
 			MBTCPMultiMaster( uniset::ObjectId objId, uniset::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr,
 							  const std::string& prefix = "mbtcp" );
@@ -381,8 +381,8 @@ class MBTCPMultiMaster:
 			// делаем опрос в отдельном потоке
 			std::shared_ptr< ThreadCreator<MBTCPMultiMaster> > pollThread; /*!< поток опроса */
 			std::shared_ptr< ThreadCreator<MBTCPMultiMaster> > checkThread; /*!< поток проверки связи по другим каналам */
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // _MBTCPMultiMaster_H_

extensions/ModbusMaster/RTUExchange.h

@@ -27,10 +27,10 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-class RTUExchange:
+	// -----------------------------------------------------------------------------
+	class RTUExchange:
 		public MBExchange
-{
+	{
 		public:
 			RTUExchange( uniset::ObjectId objId, uniset::ObjectId shmID,
 						 const std::shared_ptr<SharedMemory>& ic = nullptr, const std::string& prefix = "rs" );
@@ -62,8 +62,8 @@ class RTUExchange:
 			RTUExchange();
 
 			bool rs_pre_clean;
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // _RS_EXCHANGE_H_

extensions/ModbusMaster/RTUStorage.cc

@@ -23,17 +23,17 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-using namespace std;
-// -----------------------------------------------------------------------------
-RTUStorage::RTUStorage( ModbusRTU::ModbusAddr a ):
+	// -----------------------------------------------------------------------------
+	using namespace std;
+	// -----------------------------------------------------------------------------
+	RTUStorage::RTUStorage( ModbusRTU::ModbusAddr a ):
 		addr(a),
 		pingOK(false),
 		pollADC(true),
 		pollDI(true),
 		pollDIO(true),
 		pollUNIO(true)
-{
+	{
 		memset(adc, 0, sizeof(adc));
 		memset(di, 0, sizeof(di));
 		memset(dio_do, 0, sizeof(dio_do));
@@ -44,15 +44,15 @@ RTUStorage::RTUStorage( ModbusRTU::ModbusAddr a ):
 		memset(unio_do, 0, sizeof(unio_do));
 		memset(unio_ai, 0, sizeof(unio_ai));
 		memset(unio_ao, 0, sizeof(unio_ao));
-}
-// -----------------------------------------------------------------------------
-RTUStorage::~RTUStorage()
-{
+	}
+	// -----------------------------------------------------------------------------
+	RTUStorage::~RTUStorage()
+	{
 
-}
-// -----------------------------------------------------------------------------
-void RTUStorage::poll( const std::shared_ptr<ModbusRTUMaster>& mb ) throw( ModbusRTU::mbException )
-{
+	}
+	// -----------------------------------------------------------------------------
+	void RTUStorage::poll( const std::shared_ptr<ModbusRTUMaster>& mb ) throw( ModbusRTU::mbException )
+	{
 		try
 		{
 			pingOK = true;
@@ -206,15 +206,15 @@ void RTUStorage::poll( const std::shared_ptr<ModbusRTUMaster>& mb ) throw( Modbu
 			pingOK = false;
 			throw;
 		}
-}
-// -----------------------------------------------------------------------------
-long RTUStorage::getInt( RTUJack jack, unsigned short int chan, UniversalIO::IOType t )
-{
+	}
+	// -----------------------------------------------------------------------------
+	long RTUStorage::getInt( RTUJack jack, unsigned short int chan, UniversalIO::IOType t )
+	{
 		return lroundf( getFloat(jack, chan, t) );
-}
-// -----------------------------------------------------------------------------
-float RTUStorage::getFloat( RTUJack jack, unsigned short int chan, UniversalIO::IOType t )
-{
+	}
+	// -----------------------------------------------------------------------------
+	float RTUStorage::getFloat( RTUJack jack, unsigned short int chan, UniversalIO::IOType t )
+	{
 		if( t == UniversalIO::AI )
 		{
 			switch( jack )
@@ -268,10 +268,10 @@ float RTUStorage::getFloat( RTUJack jack, unsigned short int chan, UniversalIO::
 		}
 
 		return 0;
-}
-// -----------------------------------------------------------------------------
-bool RTUStorage::getState( RTUJack jack, unsigned short int chan, UniversalIO::IOType t )
-{
+	}
+	// -----------------------------------------------------------------------------
+	bool RTUStorage::getState( RTUJack jack, unsigned short int chan, UniversalIO::IOType t )
+	{
 		if( t == UniversalIO::DI )
 		{
 			switch( jack )
@@ -319,10 +319,10 @@ bool RTUStorage::getState( RTUJack jack, unsigned short int chan, UniversalIO::I
 		}
 
 		return false;
-}
-// -----------------------------------------------------------------------------
-ModbusRTU::ModbusData RTUStorage::getRegister( RTUJack jack, unsigned short chan, UniversalIO::IOType t )
-{
+	}
+	// -----------------------------------------------------------------------------
+	ModbusRTU::ModbusData RTUStorage::getRegister( RTUJack jack, unsigned short chan, UniversalIO::IOType t )
+	{
 		if( t == UniversalIO::AI )
 		{
 			switch( jack )
@@ -422,10 +422,10 @@ ModbusRTU::ModbusData RTUStorage::getRegister( RTUJack jack, unsigned short chan
 		}
 
 		return -1;
-}
-// -----------------------------------------------------------------------------
-ModbusRTU::SlaveFunctionCode RTUStorage::getFunction( RTUJack jack, unsigned short chan, UniversalIO::IOType t )
-{
+	}
+	// -----------------------------------------------------------------------------
+	ModbusRTU::SlaveFunctionCode RTUStorage::getFunction( RTUJack jack, unsigned short chan, UniversalIO::IOType t )
+	{
 		if( t == UniversalIO::AI )
 		{
 			switch( jack )
@@ -499,11 +499,11 @@ ModbusRTU::SlaveFunctionCode RTUStorage::getFunction( RTUJack jack, unsigned sho
 		}
 
 		return ModbusRTU::fnUnknown;
-}
-// -----------------------------------------------------------------------------
+	}
+	// -----------------------------------------------------------------------------
 
-std::ostream& operator<<(std::ostream& os, RTUStorage& m )
-{
+	std::ostream& operator<<(std::ostream& os, RTUStorage& m )
+	{
 		os << "-------------------" << endl
 		   << " АЦП (8 каналов): " << endl;
 
@@ -674,20 +674,20 @@ std::ostream& operator<<(std::ostream& os, RTUStorage& m )
 		os << endl;
 
 		return os;
-}
-// -----------------------------------------------------------------------------
-std::ostream& operator<<(std::ostream& os, RTUStorage* m )
-{
+	}
+	// -----------------------------------------------------------------------------
+	std::ostream& operator<<(std::ostream& os, RTUStorage* m )
+	{
 		return os << (*m);
-}
-// -----------------------------------------------------------------------------
-void RTUStorage::print()
-{
+	}
+	// -----------------------------------------------------------------------------
+	void RTUStorage::print()
+	{
 		cout << this;
-}
-// -----------------------------------------------------------------------------
-RTUStorage::RTUJack RTUStorage::s2j( const std::string& jack )
-{
+	}
+	// -----------------------------------------------------------------------------
+	RTUStorage::RTUJack RTUStorage::s2j( const std::string& jack )
+	{
 		if( jack == "J1" || jack == "j1" )
 			return nJ1;
 
@@ -710,10 +710,10 @@ RTUStorage::RTUJack RTUStorage::s2j( const std::string& jack )
 			return nX5;
 
 		return nUnknown;
-}
-// -----------------------------------------------------------------------------
-std::string RTUStorage::j2s( RTUStorage::RTUJack jack )
-{
+	}
+	// -----------------------------------------------------------------------------
+	std::string RTUStorage::j2s( RTUStorage::RTUJack jack )
+	{
 		if( jack == nJ1 )
 			return "J1";
 
@@ -736,6 +736,6 @@ std::string RTUStorage::j2s( RTUStorage::RTUJack jack )
 			return "X5";
 
 		return "";
-}
-// -----------------------------------------------------------------------------
+	}
+	// -----------------------------------------------------------------------------
 } // end of namespace uniset

extensions/ModbusMaster/RTUStorage.h

@@ -25,11 +25,11 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-class ModbusRTUMaster;
-// -----------------------------------------------------------------------------
-class RTUStorage
-{
+	// -----------------------------------------------------------------------------
+	class ModbusRTUMaster;
+	// -----------------------------------------------------------------------------
+	class RTUStorage
+	{
 		public:
 			explicit RTUStorage( ModbusRTU::ModbusAddr addr );
 			~RTUStorage();
@@ -112,8 +112,8 @@ class RTUStorage
 			bool unio_di[48];     // Порт UNIO48 DI
 			float unio_ai[24];     // Порт UNIO48 AI
 			float unio_ao[24];     // Порт UNIO48 AO
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // --------------------------------------------------------------------------
 #endif // _RTUSTORAGE_H_

extensions/ModbusMaster/mtr-read.cc

@@ -19,8 +19,10 @@
 #include <iomanip>
 #include <getopt.h>
 #include "Debug.h"
+#include "UniSetTypes.h"
 #include "modbus/ModbusRTUMaster.h"
 #include "modbus/ModbusHelpers.h"
+#include "modbus/ModbusTCPMaster.h"
 #include "MTR.h"
 // --------------------------------------------------------------------------
 using namespace uniset;
@@ -39,6 +41,8 @@ static struct option longopts[] =
 	{ "use485F", no_argument, 0, 'y' },
 	{ "num-cycles", required_argument, 0, 'l' },
 	{ "timeout", required_argument, 0, 't' },
+	{ "iaddr", required_argument, 0, 'i' },
+	{ "port", required_argument, 0, 'p' },
 	{ NULL, 0, 0, 0 }
 };
 // --------------------------------------------------------------------------
@@ -49,12 +53,16 @@ static void print_help()
 	printf("[--read04] slaveaddr reg mtrtype  - read from MTR (mtrtype: T1...T10,T16,T17,F1)\n");
 	printf("[-m|--read-model] slaveaddr     - read model name from MTR\n");
 	printf("[-n|--read-serial] slaveaddr    - read serial number from MTR\n");
-	printf("[-y|--use485F]                  - use RS485 Fastwel.\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("[-t|--timeout] msec             - Timeout. Default: 2000.\n");
 	printf("[-l|--num-cycles] num           - Number of cycles of exchange. Default: -1 infinitely.\n");
 	printf("[-v|--verbose]                  - Print all messages to stdout\n");
+	printf("\nRTU prameters:\n");
+	printf("[-y|--use485F]                  - use RS485 Fastwel.\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("\nTCP prameters:\n");
+	printf("[-i|--iaddr] ip                 - Modbus server ip. Default: 127.0.0.1\n");
+	printf("[-p|--port] port                - Modbus server port. Default: 502.\n");
 }
 // --------------------------------------------------------------------------
 enum Command
@@ -67,7 +75,7 @@ enum Command
 };
 // --------------------------------------------------------------------------
 static char* checkArg( int ind, int argc, char* argv[] );
-static void readMTR( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr,
+static void readMTR( ModbusClient* mb, ModbusRTU::ModbusAddr addr,
 					 ModbusRTU::ModbusData reg, MTR::MTRType t, Command cmd );
 // --------------------------------------------------------------------------
 
@@ -88,12 +96,14 @@ int main( int argc, char** argv )
 	int use485 = 0;
 	int ncycles = -1;
 	MTR::MTRType mtrtype = MTR::mtUnknown;
+	string iaddr("127.0.0.1");
+	int port = 502;
 
 	try
 	{
 		while(1)
 		{
-			opt = getopt_long(argc, argv, "hvyq:r:d:s:t:x:m:n:", longopts, &optindex);
+			opt = getopt_long(argc, argv, "hvyq:r:d:s:t:x:m:n:i:p:", longopts, &optindex);
 
 			if( opt == -1 )
 				break;
@@ -176,6 +186,14 @@ int main( int argc, char** argv )
 					ncycles = uni_atoi(optarg);
 					break;
 
+				case 'i':
+					iaddr = string(optarg);
+					break;
+
+				case 'p':
+					port = uni_atoi(optarg);
+					break;
+
 				case '?':
 				default:
 					printf("? argumnet\n");
@@ -190,14 +208,27 @@ int main( int argc, char** argv )
 				 << endl;
 		}
 
-		ModbusRTUMaster mb(dev, use485);
+		ModbusClient* mb = nullptr;
+
+		if( !iaddr.empty() )
+		{
+			auto mbtcp = new ModbusTCPMaster();
+			mbtcp->connect(iaddr, port);
+//			mbtcp->setForceDisconnect(!persist);
+			mb = mbtcp;
+		}
+		else
+		{
+			auto mbrtu = new ModbusRTUMaster(dev, use485);
+			mbrtu->setSpeed(speed);
+			mb = mbrtu;
+		}
 
 		if( verb )
 			dlog->addLevel(Debug::ANY);
 
-		mb.setTimeout(tout);
-		mb.setSpeed(speed);
-		mb.setLog(dlog);
+		mb->setTimeout(tout);
+		mb->setLog(dlog);
 
 		int nc = 1;
 
@@ -222,7 +253,7 @@ int main( int argc, char** argv )
 								 << endl;
 						}
 
-						readMTR( &mb, slaveaddr, reg, mtrtype, cmd );
+						readMTR( mb, slaveaddr, reg, mtrtype, cmd );
 					}
 					break;
 
@@ -234,7 +265,7 @@ int main( int argc, char** argv )
 								 << endl;
 						}
 
-						string s(MTR::getModelNumber(&mb, slaveaddr));
+						string s = MTR::getModelNumber(mb, slaveaddr);
 						cout << (s.empty() ? "Don`t read model name." : s) << endl;
 						return 0;
 					}
@@ -248,7 +279,7 @@ int main( int argc, char** argv )
 								 << endl;
 						}
 
-						string s(MTR::getSerialNumber(&mb, slaveaddr));
+						string s(MTR::getSerialNumber(mb, slaveaddr));
 						cout << (s.empty() ? "Don`t read serial number." : s) << endl;
 						return 0;
 					}
@@ -303,7 +334,7 @@ char* checkArg( int i, int argc, char* argv[] )
 	return 0;
 }
 // --------------------------------------------------------------------------
-void readMTR( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr,
+void readMTR( ModbusClient* mb, ModbusRTU::ModbusAddr addr,
 			  ModbusRTU::ModbusData reg, MTR::MTRType mtrType, Command cmd )
 {
 	int count = MTR::wsize(mtrType);

extensions/ModbusMaster/mtr-setup.cc

@@ -23,6 +23,7 @@
 #include <math.h>
 #include "Debug.h"
 #include "modbus/ModbusRTUMaster.h"
+#include "modbus/ModbusTCPMaster.h"
 #include "modbus/ModbusHelpers.h"
 #include "extensions/MTR.h"
 // --------------------------------------------------------------------------
@@ -40,13 +41,15 @@ static struct option longopts[] =
 	{ "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' },
+	{ "stop-bits", required_argument, 0, 'o' },
+	{ "parity", required_argument, 0, 'a' },
 	{ "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' },
+	{ "iaddr", required_argument, 0, 'i' },
+	{ "port", required_argument, 0, 'p' },
 	{ NULL, 0, 0, 0 }
 };
 // --------------------------------------------------------------------------
@@ -56,21 +59,26 @@ static void print_help()
 	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: 254\n");
+	printf("\nRTU prameters:\n");
+	printf("[-y|--use485F]            - use RS485 Fastwel.\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("[--parity] par            - parity [odd,even,no]. Default: no\n");
+	printf("[--stop-bits] n           - stop bits [1,2]. Default: 1\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("\nTCP prameters:\n");
+	printf("[-i|--iaddr] ip                 - Modbus server ip. Default: 127.0.0.1\n");
+	printf("[-p|--port] port                - Modbus server port. Default: 502.\n");
+
 	printf("\n");
 }
 // --------------------------------------------------------------------------
@@ -109,17 +117,14 @@ int main( int argc, char** argv )
 	int use485 = 0;
 	ComPort::StopBits sbits = ComPort::OneBit;
 	ComPort::Parity parity = ComPort::NoParity;
-
-	//    ModbusRTU::ModbusAddr b=255;
-	//
-	//    cout << "b=" << (int)b << " b++=" << (int)(b++) << endl;
-	//    return 0;
+	string iaddr("127.0.0.1");
+	int port = 502;
 
 	try
 	{
 		while(1)
 		{
-			opt = getopt_long(argc, argv, "hvw:r:x:d:s:t:l:n:yb:e:x:z:", longopts, &optindex);
+			opt = getopt_long(argc, argv, "hvw:r:x:d:s:t:l:n:yb:e:x:z:i:p:o:a:", longopts, &optindex);
 
 			if( opt == -1 )
 				break;
@@ -171,7 +176,7 @@ int main( int argc, char** argv )
 					speed = string(optarg);
 					break;
 
-				case 'p':
+				case 'a':
 					par = string(optarg);
 
 					if( !par.compare("odd") )
@@ -187,7 +192,7 @@ int main( int argc, char** argv )
 					tout = atoi(optarg);
 					break;
 
-				case 'i':
+				case 'o':
 					if( atoi(optarg) == 2 )
 						sbits = ComPort::TwoBits;
 
@@ -245,6 +250,14 @@ int main( int argc, char** argv )
 				}
 				break;
 
+				case 'i':
+					iaddr = string(optarg);
+					break;
+
+				case 'p':
+					port = uni_atoi(optarg);
+					break;
+
 				case '?':
 				default:
 					printf("? argumnet\n");
@@ -259,16 +272,29 @@ int main( int argc, char** argv )
 				 << endl;
 		}
 
-		ModbusRTUMaster mb(dev, use485);
+		ModbusClient* mb = nullptr;
+
+		if( !iaddr.empty() )
+		{
+			auto mbtcp = new ModbusTCPMaster();
+			mbtcp->connect(iaddr, port);
+//			mbtcp->setForceDisconnect(!persist);
+			mb = mbtcp;
+		}
+		else
+		{
+			auto mbrtu = new ModbusRTUMaster(dev, use485);
+			mbrtu->setSpeed(speed);
+			mbrtu->setParity(parity);
+			mbrtu->setStopBits(sbits);
+			mb = mbrtu;
+		}
 
 		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);
+		mb->setTimeout(tout);
+		mb->setLog(dlog);
 
 		switch(cmd)
 		{
@@ -286,9 +312,9 @@ int main( int argc, char** argv )
 					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);
+					mb->setTimeout(50);
+					slaveaddr = ModbusHelpers::autodetectSlave(mb, beg, end, MTR::regModelNumber, ModbusRTU::fnReadInputRegisters);
+					mb->setTimeout(tout);
 				}
 
 				if( speed.empty() )
@@ -296,10 +322,14 @@ int main( int argc, char** argv )
 					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);
+					auto mbrtu = dynamic_cast<ModbusRTUMaster*>(mb);
+					if( mbrtu )
+					{
+						mb->setTimeout(50);
+						ComPort::Speed s = ModbusHelpers::autodetectSpeed(mbrtu, slaveaddr, MTR::regModelNumber, ModbusRTU::fnReadInputRegisters);
+						mbrtu->setSpeed(s);
+						mbrtu->setTimeout(tout);
+					}
 				}
 
 				if( verb )
@@ -309,7 +339,7 @@ int main( int argc, char** argv )
 						 << " speed=" << speed
 						 << endl;
 
-				return  MTR::update_configuration(&mb, slaveaddr, mtrconfile, verb) ? 0 : 1;
+				return  MTR::update_configuration(mb, slaveaddr, mtrconfile, verb) ? 0 : 1;
 			}
 			break;
 
@@ -327,7 +357,7 @@ int main( int argc, char** argv )
 
 				try
 				{
-					ModbusRTU::ModbusAddr a = ModbusHelpers::autodetectSlave(&mb, beg, end, reg, fn);
+					ModbusRTU::ModbusAddr a = ModbusHelpers::autodetectSlave(mb, beg, end, reg, fn);
 					cout << "(mtr-setup): autodetect modbus slave: " << ModbusRTU::addr2str(a) << endl;
 				}
 				catch( uniset::TimeOut )
@@ -340,6 +370,14 @@ int main( int argc, char** argv )
 
 			case cmdDetectSpeed:
 			{
+				auto mbrtu = dynamic_cast<ModbusRTUMaster*>(mb);
+
+				if( !mbrtu )
+				{
+					cerr << "autodetect speed only for RTU interface.." << endl;
+					return 1;
+				}
+
 				if( verb )
 				{
 					cout << "(mtr-setup): autodetect speed: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
@@ -350,7 +388,7 @@ int main( int argc, char** argv )
 
 				try
 				{
-					ComPort::Speed s = ModbusHelpers::autodetectSpeed(&mb, slaveaddr, reg, fn);
+					ComPort::Speed s = ModbusHelpers::autodetectSpeed(mbrtu, slaveaddr, reg, fn);
 					cout << "(mtr-setup): autodetect: slaveaddr=" << ModbusRTU::addr2str(slaveaddr)
 						 << " speed=" << ComPort::getSpeed(s) << endl;
 				}
@@ -371,7 +409,7 @@ int main( int argc, char** argv )
 						 << endl;
 				}
 
-				cout << "model: " << MTR::getModelNumber(&mb, slaveaddr) << endl;
+				cout << "model: " << MTR::getModelNumber(mb, slaveaddr) << endl;
 			}
 			break;
 
@@ -384,7 +422,7 @@ int main( int argc, char** argv )
 						 << endl;
 				}
 
-				cout << "serial: " << MTR::getSerialNumber(&mb, slaveaddr) << endl;
+				cout << "serial: " << MTR::getSerialNumber(mb, slaveaddr) << endl;
 			}
 			break;
 

extensions/ModbusMaster/tests/MBTCPTestServer.cc

 // -------------------------------------------------------------------------
 #include <sstream>
+#include <limits>
 #include <Poco/Net/NetException.h>
 #include "UniSetTypes.h"
 #include "MBTCPTestServer.h"
@@ -23,7 +24,7 @@ MBTCPTestServer::MBTCPTestServer( const std::unordered_set<ModbusAddr>& _vaddr,
 	sslot(NULL),
 	vaddr(_vaddr),
 	verbose(verb),
-	replyVal(-1),
+	replyVal(std::numeric_limits<uint32_t>::max()),
 	forceSingleCoilCmd(false),
 	lastWriteOutputSingleRegister(0),
 	lastForceCoilsQ(0, 0),
@@ -122,7 +123,7 @@ ModbusRTU::mbErrCode MBTCPTestServer::readCoilStatus( ReadCoilMessage& query,
 
 	if( query.count <= 1 )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(d);
@@ -136,7 +137,7 @@ ModbusRTU::mbErrCode MBTCPTestServer::readCoilStatus( ReadCoilMessage& query,
 
 	for( ; num < query.count; num++, reg++ )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(d);
@@ -167,7 +168,7 @@ ModbusRTU::mbErrCode MBTCPTestServer::readInputStatus( ReadInputStatusMessage& q
 	d.b[3] = 1;
 	d.b[7] = 1;
 
-	if( replyVal == -1 )
+	if( replyVal == std::numeric_limits<uint32_t>::max() )
 	{
 		size_t bnum = 0;
 		size_t i = 0;
@@ -207,7 +208,7 @@ mbErrCode MBTCPTestServer::readInputRegisters( ReadInputMessage& query,
 
 	if( query.count <= 1 )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(query.start);
@@ -221,7 +222,7 @@ mbErrCode MBTCPTestServer::readInputRegisters( ReadInputMessage& query,
 
 	for( ; num < query.count; num++, reg++ )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(reg);
@@ -252,7 +253,7 @@ ModbusRTU::mbErrCode MBTCPTestServer::readOutputRegisters(
 
 	if( query.count <= 1 )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(query.start);
@@ -266,7 +267,7 @@ ModbusRTU::mbErrCode MBTCPTestServer::readOutputRegisters(
 
 	for( ; num < query.count; num++, reg++ )
 	{
-		if( replyVal != -1 )
+		if( replyVal != std::numeric_limits<uint32_t>::max() )
 			reply.addData(replyVal);
 		else
 			reply.addData(reg);

extensions/ModbusMaster/tests/MBTCPTestServer.h

@@ -19,7 +19,7 @@ class MBTCPTestServer
 			verbose = state;
 		}
 
-		inline void setReply( long val )
+		inline void setReply( uint32_t val )
 		{
 			replyVal = val;
 		}
@@ -47,7 +47,7 @@ class MBTCPTestServer
 		{
 			return forceSingleCoilCmd;
 		}
-		inline int getLastWriteOutputSingleRegister()
+		inline int16_t getLastWriteOutputSingleRegister()
 		{
 			return lastWriteOutputSingleRegister;
 		}
@@ -131,9 +131,9 @@ class MBTCPTestServer
 		std::unordered_set<uniset::ModbusRTU::ModbusAddr> vaddr; /*!< адреса данного узла */
 
 		bool verbose;
-		long replyVal;
+		uint32_t replyVal;
 		bool forceSingleCoilCmd;
-		int lastWriteOutputSingleRegister;
+		int16_t lastWriteOutputSingleRegister;
 		uniset::ModbusRTU::ForceCoilsMessage lastForceCoilsQ;
 		uniset::ModbusRTU::WriteOutputMessage lastWriteOutputQ;
 		float f2_test_value = {0.0};

extensions/ModbusMaster/tests/test_mbtcpmaster.cc

@@ -222,12 +222,12 @@ TEST_CASE("MBTCPMaster: 0x03 (read register outputs or memories or read word out
 	REQUIRE( ui->getValue(1004) == -10 );
 	REQUIRE( ui->getValue(1005) == -10 );
 	REQUIRE( ui->getValue(1006) == -10 );
-	mbs->setReply(0);
+	mbs->setReply(1);
 	msleep(polltime + 200);
-	REQUIRE( ui->getValue(1003) == 0 );
-	REQUIRE( ui->getValue(1004) == 0 );
-	REQUIRE( ui->getValue(1005) == 0 );
-	REQUIRE( ui->getValue(1006) == 0 );
+	REQUIRE( ui->getValue(1003) == 1 );
+	REQUIRE( ui->getValue(1004) == 1 );
+	REQUIRE( ui->getValue(1005) == 1 );
+	REQUIRE( ui->getValue(1006) == 1 );
 	mbs->setReply(65535);
 	msleep(polltime + 200);
 	REQUIRE( ui->getValue(1003) == -1 );
@@ -236,10 +236,14 @@ TEST_CASE("MBTCPMaster: 0x03 (read register outputs or memories or read word out
 	REQUIRE( ui->getValue(1006) == -1 );
 	REQUIRE( ui->getValue(1007) == 65535 ); // unsigned
 
-	mbs->setReply(0xffff);
+	mbs->setReply( std::numeric_limits<uint16_t>::max() );
+	msleep(polltime + 200);
+	REQUIRE( (uint16_t)ui->getValue(1009) == std::numeric_limits<uint16_t>::max() ); // U2
+
+	mbs->setReply( std::numeric_limits<int16_t>::max() );
 	msleep(polltime + 200);
-	REQUIRE( ui->getValue(1008) == 0xffffffff ); // I2
-	REQUIRE( ui->getValue(1009) == 0xffffffff ); // U2
+	REQUIRE( (int16_t)ui->getValue(1008) == std::numeric_limits<int16_t>::max() ); // I2
+
 	mbs->setReply(0xff);
 	msleep(polltime + 200);
 	REQUIRE( ui->getValue(1008) == 0x00ff00ff ); // I2
@@ -281,10 +285,14 @@ TEST_CASE("MBTCPMaster: 0x04 (read input registers or memories or read word outp
 	REQUIRE( ui->getValue(1013) == -1 );
 	REQUIRE( ui->getValue(1014) == 65535 ); // unsigned
 
-	mbs->setReply(0xffff);
+	mbs->setReply( std::numeric_limits<uint16_t>::max() );
 	msleep(polltime + 200);
-	REQUIRE( ui->getValue(1015) == 0xffffffff ); // I2
-	REQUIRE( ui->getValue(1016) == 0xffffffff ); // U2
+	REQUIRE( (uint16_t)ui->getValue(1009) == std::numeric_limits<uint16_t>::max() ); // U2
+
+	mbs->setReply( std::numeric_limits<int16_t>::max() );
+	msleep(polltime + 200);
+	REQUIRE( (int16_t)ui->getValue(1008) == std::numeric_limits<int16_t>::max() ); // I2
+
 	mbs->setReply(0xff);
 	msleep(polltime + 200);
 	REQUIRE( ui->getValue(1015) == 0x00ff00ff ); // I2
@@ -457,23 +465,23 @@ TEST_CASE("MBTCPMaster: 0x10 (write register outputs or memories)", "[modbus][0x
 		REQUIRE( q.addr == slaveADDR );
 		REQUIRE( q.start == 31 );
 		REQUIRE( q.quant == 6 );
-		REQUIRE( q.data[0] == (unsigned short)(-100) );
-		REQUIRE( q.data[2] == (unsigned short)(-10) );
-		REQUIRE( q.data[3] == (unsigned short)(-32767) );
+		REQUIRE( q.data[0] == (uint16_t)(-100) );
+		REQUIRE( q.data[2] == (uint16_t)(-10) );
+		REQUIRE( q.data[3] == (uint16_t)(-32767) );
 	}
 
 	SECTION("I2")
 	{
-		ui->setValue(1023, 0xffffffff);
-		REQUIRE( ui->getValue(1023) == 0xffffffff );
+		ui->setValue(1023, std::numeric_limits<uint32_t>::max());
+		REQUIRE( (uint32_t)ui->getValue(1023) == std::numeric_limits<uint32_t>::max() );
 		msleep(polltime + 200);
 
 		ModbusRTU::WriteOutputMessage q = mbs->getLastWriteOutput();
 		REQUIRE( q.addr == slaveADDR );
 		REQUIRE( q.start == 31 );
 		REQUIRE( q.quant == 6 );
-		REQUIRE( q.data[4] == 0xffff );
-		REQUIRE( q.data[5] == 0xffff );
+		REQUIRE( q.data[4] == std::numeric_limits<uint16_t>::max() );
+		REQUIRE( q.data[5] == std::numeric_limits<uint16_t>::max() );
 	}
 }
 // -----------------------------------------------------------------------------

extensions/ModbusMaster/tests/test_mbtcpmultimaster.cc

@@ -127,6 +127,8 @@ TEST_CASE("MBTCPMultiMaster: rotate channel", "[modbus][mbmaster][mbtcpmultimast
 	InitTest();
 	CHECK( ui->isExist(mbID) );
 
+	mbs1->setReply(0);
+	msleep(polltime + 1000);
 	REQUIRE( ui->getValue(1003) == 0 );
 	mbs1->setReply(100);
 	mbs2->setReply(10);

extensions/ModbusSlave/MBSlave.h

@@ -49,8 +49,8 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*!
+	// -----------------------------------------------------------------------------
+	/*!
 	      \page page_ModbusSlave Реализация Modbus slave
 
 	      - \ref sec_MBSlave_Comm
@@ -60,6 +60,7 @@ namespace uniset
 	      - \ref sec_MBSlave_MEIRDI
 		  - \ref sec_MBSlave_DIAG
 		  - \ref sec_MBSlave_TCP
+		  - \ref sec_MBSlave_REST_API
 
 	      \section sec_MBSlave_Comm Общее описание Modbus slave
 	      Класс реализует базовые функции для протокола Modbus в slave режиме. Реализацию Modbus RTU - см. RTUExchange.
@@ -206,7 +207,7 @@ namespace uniset
 		 />
 	    ...
 	  </sensors>
-\endcode
+	\endcode
 
 	   \warning По умолчанию для свойств используется заданный в конструктроре префикс "mbs_".
 
@@ -303,12 +304,21 @@ namespace uniset
 		</MBTCPPersistentSlave>
 		\endcode
 
-*/
-// -----------------------------------------------------------------------------
-/*! Реализация slave-интерфейса */
-class MBSlave:
+		\section sec_MBSlave_REST_API MBSlave HTTP API
+
+
+		/help                            - Получение списка доступных команд
+		/                                - получение стандартной информации
+		/regs?regs=reg1,reg2,reg3,..&addr=addr1,addr2,addr3  - получение списка регистров
+									 Не обязательные параметры:
+									   regs - выдать информацию только по указанным регистрам
+									   addr - выдать информацию только по указанным адресам устройств
+	*/
+	// -----------------------------------------------------------------------------
+	/*! Реализация slave-интерфейса */
+	class MBSlave:
 		public UniSetObject
-{
+	{
 		public:
 			MBSlave( uniset::ObjectId objId, uniset::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr, const std::string& prefix = "mbs" );
 			virtual ~MBSlave();
@@ -330,6 +340,8 @@ class MBSlave:
 				amWO
 			};
 
+			std::string amode2str( AccessMode m );
+
 			struct BitRegProperty;
 
 			struct IOProperty:
@@ -388,6 +400,12 @@ class MBSlave:
 
 			virtual uniset::SimpleInfo* getInfo( const char* userparam = 0 ) override;
 
+#ifndef DISABLE_REST_API
+			// http API
+			virtual Poco::JSON::Object::Ptr httpHelp( const Poco::URI::QueryParameters& p ) override;
+			virtual Poco::JSON::Object::Ptr httpRequest( const string& req, const Poco::URI::QueryParameters& p ) override;
+#endif
+
 		protected:
 
 			/*! обработка 0x01 */
@@ -514,6 +532,12 @@ class MBSlave:
 			ModbusRTU::mbErrCode real_bitreg_write_it( std::shared_ptr<BitRegProperty>& bp, const ModbusRTU::ModbusData val );
 			ModbusRTU::mbErrCode real_write_prop(IOProperty* p, ModbusRTU::ModbusData* dat, size_t& i, size_t count );
 
+#ifndef DISABLE_REST_API
+			// http api
+			Poco::JSON::Object::Ptr request_regs( const std::string& req, const Poco::URI::QueryParameters& p );
+			Poco::JSON::Object::Ptr get_regs(ModbusRTU::ModbusAddr addr, const RegMap& rmap, const std::vector<std::string>& q_regs );
+			Poco::JSON::Object::Ptr get_reginfo( const IOProperty& prop );
+#endif
 			MBSlave();
 			timeout_t initPause = { 3000 };
 			uniset::uniset_rwmutex mutex_start;
@@ -622,8 +646,8 @@ class MBSlave:
 			IOController::IOStateList::iterator sesscount_it;
 
 			std::atomic_bool tcpCancelled = { true };
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // _MBSlave_H_

extensions/RRDServer/RRDServer.h

@@ -27,8 +27,8 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*!
+	// -----------------------------------------------------------------------------
+	/*!
 	    \page page_RRDServer Реализация RRD хранилища
 
 	      - \ref sec_RRD_Comm
@@ -44,7 +44,7 @@ namespace uniset
 	    \section sec_RRD_Conf Настройка RRDServer
 
 	    Пример секции конфигурации:
-\code
+	\code
 	        <RRDServer1 name="RRDServer1">
 	            <rrd filename="rrdtest.rrd" filter_field="rrd" filter_value="1" step="5" ds_field="rrd1_ds" overwrite="0">
 	                <item rra="RRA:AVERAGE:0.5:1:4320"/>
@@ -55,7 +55,7 @@ namespace uniset
 	                <item rra="RRA:MAX:0.5:1:4320"/>
 	            </rrd>
 	        </RRDServer1>
-\endcode
+	\endcode
 	    Где:
 	    - \b filename - имя создаваемого rrd-файла
 	    - \b filter_field - поле у датчика, определяющее, что его нужно сохранять в БД
@@ -66,7 +66,7 @@ namespace uniset
 	    - \b overwrite - [0,1]. Пересоздавать ли БД, если файл уже существует.
 
 	    При этом в секции <sensors> у датчиков прописываются параметры относящиеся к источнику:
-\code
+	\code
 	    <sensors>
 	        ...
 	        <item id="54" iotype="AI" name="AI54_S" textname="AI sensor 54" rrd="1" rrd1_ds="GAUGE:20:U:U"/>
@@ -75,15 +75,15 @@ namespace uniset
 			<item id="57" iotype="AI" name="AI57_S" rrd2_ds_dsname='A57MyRRDName' textname="AI sensor 57" rrd="2" rrd2_ds="DERIVE:20:U:U"/>
 	        ...
 	    </sensors>
-\endcode
+	\endcode
 
 	  \section sec_RRD_DSName Именование параметров
 	   По умолчанию в качестве имени параметра берётся поле \b 'ds_field'_dsname='', если это поле не указано, то берётся \b name датчика.
 	   \warning Имя не может превышать RRDServer::RRD_MAX_DSNAME_LEN.
-*/
-class RRDServer:
+	*/
+	class RRDServer:
 		public UObject_SK
-{
+	{
 		public:
 			RRDServer( uniset::ObjectId objId, xmlNode* cnode, uniset::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr,
 					   const std::string& prefix = "rrd" );
@@ -157,8 +157,8 @@ class RRDServer:
 		private:
 
 			std::string prefix;
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // _RRDServer_H_

extensions/SharedMemory/SharedMemory.h

@@ -38,9 +38,9 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
+	// -----------------------------------------------------------------------------
 
-/*! \page page_SharedMemory Реализация разделямой между процессами памяти (SharedMemory)
+	/*! \page page_SharedMemory Реализация разделямой между процессами памяти (SharedMemory)
 
 
 	      \section sec_SM_Common Задачи решаемые объектом SharedMemory
@@ -199,7 +199,7 @@ namespace uniset
 	      <br>_31_04_AS - аналоговый (счётчик)
 	      <br>_41_04_S - дискретный ("доступность процесса")
 
-\code
+	\code
 	    <item default="10" heartbeat="1" heartbeat_ds_name="_41_04_S" heartbeat_node="ses" heartbeat_reboot_msec="10000"
 	          id="103104" iotype="AI" name="_31_04_AS" textname="SES: IO heartbeat"/>
 
@@ -208,7 +208,7 @@ namespace uniset
 	                <msg mtype="1" text="КСЭС: отключился ввод/вывод" value="0"/>
 	            </MessagesList>
 	    </item>
-\endcode
+	\endcode
 
 
 	    \section sec_SM_History Механизм аварийного дампа
@@ -318,10 +318,13 @@ namespace uniset
 										 Не обязательные параметры:
 										   sens1,... - список по каким датчикам выдать ответ
 		/lost                            - получить список заказчиков с которыми терялась связь (и они удалялись из списка)
-*/
-class SharedMemory:
+
+		/conf/get?id,name,...&props=textname,iotype,...  - Получить указанные параметры объектов (по id или name) из configure.xml.
+													 Если props не указаны, то отдаются все поля какие есть.
+	*/
+	class SharedMemory:
 		public IONotifyController
-{
+	{
 		public:
 			SharedMemory( uniset::ObjectId id, const std::string& datafile, const std::string& confname = "" );
 			virtual ~SharedMemory();
@@ -532,8 +535,8 @@ class SharedMemory:
 
 		private:
 			HistorySlot m_historySignal;
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // SharedMemory_H_

extensions/UNetUDP/UDPPacket.h

@@ -24,10 +24,10 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-namespace UniSetUDP
-{
-/*! Для оптимизации размера передаваемх данных, но с учётом того, что ID могут идти не подряд.
+	// -----------------------------------------------------------------------------
+	namespace UniSetUDP
+	{
+		/*! Для оптимизации размера передаваемх данных, но с учётом того, что ID могут идти не подряд.
 		    Сделан следующий формат:
 		    Для аналоговых величин передаётся массив пар "id-value"(UDPAData).
 		    Для булевых величин - отдельно массив ID и отдельно битовый массив со значениями,
@@ -38,12 +38,12 @@ namespace UniSetUDP
 
 			\warning ТЕКУЩАЯ ВЕРСИЯ ПРОТОКОЛА НЕ БУДЕТ РАБОТАТЬ МЕЖДУ 32-битными и 64-битными системами (из-за отличия в типе long).
 			т.к. это не сильно актуально, пока не переделываю.
-*/
+		*/
 
-const uint32_t UNETUDP_MAGICNUM = 0x1337A1D; // идентификатор протокола
+		const uint32_t UNETUDP_MAGICNUM = 0x1337A1D; // идентификатор протокола
 
-struct UDPHeader
-{
+		struct UDPHeader
+		{
 			UDPHeader() noexcept: magic(UNETUDP_MAGICNUM), num(0), nodeID(0), procID(0), dcount(0), acount(0) {}
 			uint32_t magic;
 			size_t num;
@@ -55,12 +55,12 @@ struct UDPHeader
 
 			friend std::ostream& operator<<( std::ostream& os, UDPHeader& p );
 			friend std::ostream& operator<<( std::ostream& os, UDPHeader* p );
-} __attribute__((packed));
+		} __attribute__((packed));
 
-const size_t MaxPacketNum = std::numeric_limits<size_t>::max();
+		const size_t MaxPacketNum = std::numeric_limits<size_t>::max();
 
-struct UDPAData
-{
+		struct UDPAData
+		{
 			UDPAData() noexcept: id(uniset::DefaultObjectId), val(0) {}
 			UDPAData(long id, long val) noexcept: id(id), val(val) {}
 
@@ -68,31 +68,31 @@ struct UDPAData
 			long val;
 
 			friend std::ostream& operator<<( std::ostream& os, UDPAData& p );
-} __attribute__((packed));
+		} __attribute__((packed));
 
 
-// Теоретический размер данных в UDP пакете (исключая заголовки) 65507
-// Фактически желательно не вылезать за размер MTU (обычно 1500) - заголовки = 1432 байта
-// т.е. надо чтобы sizeof(UDPPacket) < 1432
+		// Теоретический размер данных в UDP пакете (исключая заголовки) 65507
+		// Фактически желательно не вылезать за размер MTU (обычно 1500) - заголовки = 1432 байта
+		// т.е. надо чтобы sizeof(UDPPacket) < 1432
 
-// При текущих настройках sizeof(UDPPacket) = 32654 (!)
-static const size_t MaxACount = 1500;
-static const size_t MaxDCount = 5000;
-static const size_t MaxDDataCount = 1 + MaxDCount / 8 * sizeof(unsigned char);
+		// При текущих настройках sizeof(UDPPacket) = 32654 (!)
+		static const size_t MaxACount = 1500;
+		static const size_t MaxDCount = 5000;
+		static const size_t MaxDDataCount = 1 + MaxDCount / 8 * sizeof(unsigned char);
 
-struct UDPPacket
-{
+		struct UDPPacket
+		{
 			UDPPacket() noexcept: len(0) {}
 
 			size_t len;
 			uint8_t data[ sizeof(UDPHeader) + MaxDCount * sizeof(long) + MaxDDataCount + MaxACount * sizeof(UDPAData) ];
-} __attribute__((packed));
+		} __attribute__((packed));
 
-static const size_t MaxDataLen = sizeof(UDPPacket);
+		static const size_t MaxDataLen = sizeof(UDPPacket);
 
-struct UDPMessage:
+		struct UDPMessage:
 			public UDPHeader
-{
+		{
 			UDPMessage() noexcept;
 
 			UDPMessage(UDPMessage&& m) noexcept = default;
@@ -168,11 +168,11 @@ struct UDPMessage:
 			uint8_t d_dat[MaxDDataCount];  /*!< битовые значения */
 
 			friend std::ostream& operator<<( std::ostream& os, UDPMessage& p );
-};
+		};
 
-uint16_t makeCRC( unsigned char* buf, size_t len ) noexcept;
-}
-// --------------------------------------------------------------------------
+		uint16_t makeCRC( unsigned char* buf, size_t len ) noexcept;
+	}
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // UDPPacket_H_

extensions/UNetUDP/UNetExchange.h

@@ -41,8 +41,8 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*!
+	// -----------------------------------------------------------------------------
+	/*!
 	    \page pageUNetExchangeUDP Сетевой обмен на основе UDP (UNetUDP)
 
 	        - \ref pgUNetUDP_Common
@@ -120,11 +120,11 @@ namespace uniset
 		При загрузке все датчики (относщиеся к данному процессу) разбиваются на группы пакетов согласно своей частоте посылки.
 		При этом внутри одной группы датчики разбиваются по пакетам согласно заданному максимальному размеру пакета
 		(см. конструктор класса UNetSender()).
-*/
-// -----------------------------------------------------------------------------
-class UNetExchange:
+	*/
+	// -----------------------------------------------------------------------------
+	class UNetExchange:
 		public UniSetObject
-{
+	{
 		public:
 			UNetExchange( uniset::ObjectId objId, uniset::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr, const std::string& prefix = "unet" );
 			virtual ~UNetExchange();
@@ -267,8 +267,8 @@ class UNetExchange:
 			int logserv_port = {0};
 
 			VMonitor vmon;
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // UNetExchange_H_

extensions/UNetUDP/UNetReceiver.cc

@@ -948,7 +948,7 @@ const std::string UNetReceiver::getShortInfo() const noexcept
 	  << endl
 	  << "\t[ qsize=" << qpack.size() << " recv=" << statRecvPerSec << " update=" << statUpPerSec << " per sec ]";
 
-	return std::move(s.str());
+	return s.str();
 }
 // -----------------------------------------------------------------------------
 UNetReceiver::pack_guard::pack_guard( mutex& _m, UNetReceiver::UpdateStrategy _s ):

extensions/UNetUDP/UNetReceiver.h

@@ -35,8 +35,8 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*  Основная идея: сделать проверку очерёдности пакетов, но при этом использовать UDP.
+	// -----------------------------------------------------------------------------
+	/*  Основная идея: сделать проверку очерёдности пакетов, но при этом использовать UDP.
 	 * ===============
 	 * Собственно реализация сделана так:
 	 * В данных передаётся номер пакета. На случай если несколько пакетов придут не в той последовательности
@@ -94,12 +94,12 @@ namespace uniset
 	 * Поддерживается два варианта:
 	 * 'thread' - отдельный поток обновления
 	 * 'evloop' - использование общего с приёмом event loop (libev)
-*/
-// -----------------------------------------------------------------------------
-class UNetReceiver:
+	*/
+	// -----------------------------------------------------------------------------
+	class UNetReceiver:
 		protected EvWatcher,
 		public std::enable_shared_from_this<UNetReceiver>
-{
+	{
 		public:
 			UNetReceiver( const std::string& host, int port, const std::shared_ptr<SMInterface>& smi, bool nocheckConnection = false );
 			virtual ~UNetReceiver();
@@ -343,8 +343,8 @@ class UNetReceiver:
 
 			void initDCache( UniSetUDP::UDPMessage& pack, bool force = false ) noexcept;
 			void initACache( UniSetUDP::UDPMessage& pack, bool force = false ) noexcept;
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // UNetReceiver_H_

extensions/UNetUDP/UNetSender.cc

@@ -24,11 +24,11 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-using namespace std;
-using namespace uniset::extensions;
-// -----------------------------------------------------------------------------
-UNetSender::UNetSender(const std::string& _host, const int _port, const std::shared_ptr<SMInterface>& smi,
+	// -----------------------------------------------------------------------------
+	using namespace std;
+	using namespace uniset::extensions;
+	// -----------------------------------------------------------------------------
+	UNetSender::UNetSender(const std::string& _host, const int _port, const std::shared_ptr<SMInterface>& smi,
 						   bool nocheckConnection, const std::string& s_f, const std::string& s_val,
 						   const std::string& s_prefix, size_t maxDCount, size_t maxACount ):
 		s_field(s_f),
@@ -45,7 +45,7 @@ UNetSender::UNetSender(const std::string& _host, const int _port, const std::sha
 		lastcrc(0),
 		maxAData(maxACount),
 		maxDData(maxDCount)
-{
+	{
 		items.reserve(100);
 
 		{
@@ -102,14 +102,14 @@ UNetSender::UNetSender(const std::string& _host, const int _port, const std::sha
 				unetinfo << myname << "(init): dlist size = " << items.size() << endl;
 			}
 		}
-}
-// -----------------------------------------------------------------------------
-UNetSender::~UNetSender()
-{
-}
-// -----------------------------------------------------------------------------
-bool UNetSender::createConnection( bool throwEx )
-{
+	}
+	// -----------------------------------------------------------------------------
+	UNetSender::~UNetSender()
+	{
+	}
+	// -----------------------------------------------------------------------------
+	bool UNetSender::createConnection( bool throwEx )
+	{
 		unetinfo << myname << "(createConnection): .." << endl;
 
 		try
@@ -144,20 +144,20 @@ bool UNetSender::createConnection( bool throwEx )
 		}
 
 		return (udp != nullptr);
-}
-// -----------------------------------------------------------------------------
-void UNetSender::updateFromSM()
-{
+	}
+	// -----------------------------------------------------------------------------
+	void UNetSender::updateFromSM()
+	{
 		for( auto && it : items )
 		{
 			UItem& i = it.second;
 			long value = shm->localGetValue(i.ioit, i.id);
 			updateItem(i, value);
 		}
-}
-// -----------------------------------------------------------------------------
-void UNetSender::updateSensor( uniset::ObjectId id, long value )
-{
+	}
+	// -----------------------------------------------------------------------------
+	void UNetSender::updateSensor( uniset::ObjectId id, long value )
+	{
 		if( !shm->isLocalwork() )
 			return;
 
@@ -165,10 +165,10 @@ void UNetSender::updateSensor( uniset::ObjectId id, long value )
 
 		if( it != items.end() )
 			updateItem( it->second, value );
-}
-// -----------------------------------------------------------------------------
-void UNetSender::updateItem( UItem& it, long value )
-{
+	}
+	// -----------------------------------------------------------------------------
+	void UNetSender::updateItem( UItem& it, long value )
+	{
 		auto& pk = mypacks[it.pack_sendfactor];
 
 		auto& mypack(pk[it.pack_num]);
@@ -178,16 +178,16 @@ void UNetSender::updateItem( UItem& it, long value )
 			mypack.msg.setDData(it.pack_ind, value);
 		else if( it.iotype == UniversalIO::AI || it.iotype == UniversalIO::AO )
 			mypack.msg.setAData(it.pack_ind, value);
-}
-// -----------------------------------------------------------------------------
-void UNetSender::setCheckConnectionPause( int msec )
-{
+	}
+	// -----------------------------------------------------------------------------
+	void UNetSender::setCheckConnectionPause( int msec )
+	{
 		if( msec > 0 )
 			ptCheckConnection.setTiming(msec);
-}
-// -----------------------------------------------------------------------------
-void UNetSender::send() noexcept
-{
+	}
+	// -----------------------------------------------------------------------------
+	void UNetSender::send() noexcept
+	{
 		unetinfo << myname << "(send): dlist size = " << items.size() << endl;
 		ncycle = 0;
 
@@ -265,12 +265,12 @@ void UNetSender::send() noexcept
 		}
 
 		unetinfo << "************* execute FINISH **********" << endl;
-}
-// -----------------------------------------------------------------------------
-// #define UNETUDP_DISABLE_OPTIMIZATION_N1
+	}
+	// -----------------------------------------------------------------------------
+	// #define UNETUDP_DISABLE_OPTIMIZATION_N1
 
-void UNetSender::real_send( PackMessage& mypack ) noexcept
-{
+	void UNetSender::real_send( PackMessage& mypack ) noexcept
+	{
 		try
 		{
 			uniset::uniset_rwmutex_rlock l(mypack.mut);
@@ -311,28 +311,28 @@ void UNetSender::real_send( PackMessage& mypack ) noexcept
 		{
 			unetcrit << myname << "(real_send): error: " << ex.what() << endl;
 		}
-}
-// -----------------------------------------------------------------------------
-void UNetSender::stop()
-{
+	}
+	// -----------------------------------------------------------------------------
+	void UNetSender::stop()
+	{
 		activated = false;
 
 		//    s_thr->stop();
 		if( s_thr )
 			s_thr->join();
-}
-// -----------------------------------------------------------------------------
-void UNetSender::start()
-{
+	}
+	// -----------------------------------------------------------------------------
+	void UNetSender::start()
+	{
 		if( !activated )
 		{
 			activated = true;
 			s_thr->start();
 		}
-}
-// -----------------------------------------------------------------------------
-void UNetSender::readConfiguration()
-{
+	}
+	// -----------------------------------------------------------------------------
+	void UNetSender::readConfiguration()
+	{
 		xmlNode* root = uniset_conf()->getXMLSensorsSection();
 
 		if(!root)
@@ -355,18 +355,18 @@ void UNetSender::readConfiguration()
 			if( check_filter(it, s_field, s_fvalue) )
 				initItem(it);
 		}
-}
-// ------------------------------------------------------------------------------------------
-bool UNetSender::readItem( const std::shared_ptr<UniXML>& xml, UniXML::iterator& it, xmlNode* sec )
-{
+	}
+	// ------------------------------------------------------------------------------------------
+	bool UNetSender::readItem( const std::shared_ptr<UniXML>& xml, UniXML::iterator& it, xmlNode* sec )
+	{
 		if( uniset::check_filter(it, s_field, s_fvalue) )
 			initItem(it);
 
 		return true;
-}
-// ------------------------------------------------------------------------------------------
-bool UNetSender::initItem( UniXML::iterator& it )
-{
+	}
+	// ------------------------------------------------------------------------------------------
+	bool UNetSender::initItem( UniXML::iterator& it )
+	{
 		string sname( it.getProp("name") );
 
 		string tid(it.getProp("id"));
@@ -498,33 +498,33 @@ bool UNetSender::initItem( UniXML::iterator& it )
 
 		items.emplace(p.id, std::move(p));
 		return true;
-}
+	}
 
-// ------------------------------------------------------------------------------------------
-std::ostream& operator<<( std::ostream& os, UNetSender::UItem& p )
-{
+	// ------------------------------------------------------------------------------------------
+	std::ostream& operator<<( std::ostream& os, UNetSender::UItem& p )
+	{
 		return os << " sid=" << p.id;
-}
-// -----------------------------------------------------------------------------
-void UNetSender::initIterators()
-{
+	}
+	// -----------------------------------------------------------------------------
+	void UNetSender::initIterators()
+	{
 		for( auto && it : items )
 			shm->initIterator(it.second.ioit);
-}
-// -----------------------------------------------------------------------------
-void UNetSender::askSensors( UniversalIO::UIOCommand cmd )
-{
+	}
+	// -----------------------------------------------------------------------------
+	void UNetSender::askSensors( UniversalIO::UIOCommand cmd )
+	{
 		for( auto && it : items  )
 			shm->askSensor(it.second.id, cmd);
-}
-// -----------------------------------------------------------------------------
-size_t UNetSender::getDataPackCount() const
-{
+	}
+	// -----------------------------------------------------------------------------
+	size_t UNetSender::getDataPackCount() const
+	{
 		return mypacks.size();
-}
-// -----------------------------------------------------------------------------
-const std::string UNetSender::getShortInfo() const
-{
+	}
+	// -----------------------------------------------------------------------------
+	const std::string UNetSender::getShortInfo() const
+	{
 		// warning: будет вызываться из другого потока
 		// (считаем что чтение безопасно)
 
@@ -552,7 +552,7 @@ const std::string UNetSender::getShortInfo() const
 			}
 		}
 
-	return std::move(s.str());
-}
-// -----------------------------------------------------------------------------
+		return s.str();
+	}
+	// -----------------------------------------------------------------------------
 } // end of namespace uniset

extensions/UNetUDP/UNetSender.h

@@ -32,8 +32,8 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*
+	// -----------------------------------------------------------------------------
+	/*
 	 *    Распределение датчиков по пакетам
 	 *    =========================================================================
 	 *	  Все пересылаемые данные разбиваются на группы по частоте посылки("sendfactor").
@@ -65,8 +65,8 @@ namespace uniset
 	 * выкинуто исключение при неудачной попытке создания соединения.
 	 * \warning setCheckConnectionPause(msec) должно быть кратно sendpause!
 	 */
-class UNetSender
-{
+	class UNetSender
+	{
 		public:
 			UNetSender( const std::string& host, const int port, const std::shared_ptr<SMInterface>& smi, bool nocheckConnection = false,
 						const std::string& s_field = "", const std::string& s_fvalue = "", const std::string& prefix = "unet",
@@ -218,8 +218,8 @@ class UNetSender
 
 			size_t ncycle = { 0 }; /*!< номер цикла посылки */
 
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // UNetSender_H_

extensions/UNetUDP/tests/test_unetudp.cc

@@ -76,7 +76,7 @@ static UniSetUDP::UDPMessage receive( unsigned int pnum = 0, timeout_t tout = 20
 		ncycle--;
 	}
 
-	return std::move(pack);
+	return pack;
 }
 // -----------------------------------------------------------------------------
 void send( UniSetUDP::UDPMessage& pack, int tout = 2000 )
@@ -298,7 +298,7 @@ TEST_CASE("[UNetUDP]: check receiver", "[unetudp][receiver]")
 		REQUIRE( ui->getValue(11) == 0 );
 
 		send(pack);
-		msleep(200);
+		msleep(500);
 		REQUIRE( ui->getValue(8) == 100 );
 		REQUIRE( ui->getValue(9) == -100 );
 		REQUIRE( ui->getValue(10) == 1 );
@@ -316,7 +316,7 @@ TEST_CASE("[UNetUDP]: check receiver", "[unetudp][receiver]")
 		pack.addDData(10, false);
 		pack.addDData(11, true);
 		send(pack);
-		msleep(200);
+		msleep(500);
 		REQUIRE( ui->getValue(8) == 10 );
 		REQUIRE( ui->getValue(9) == -10 );
 		REQUIRE( ui->getValue(10) == 0 );

extensions/UniNetwork/UniExchange.h

@@ -27,8 +27,8 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*!
+	// -----------------------------------------------------------------------------
+	/*!
 	        \page pageUniExchange Обмен между узлами на основе TCP.
 
 	    \par Обмен построен на основе функций IOControl-ера получения списка дискретных
@@ -49,11 +49,11 @@ namespace uniset
 	        </UniExchange>
 	    \endcode
 	    Запись можно делать по "id" или по "name"
-*/
-// -----------------------------------------------------------------------------
-class UniExchange:
+	*/
+	// -----------------------------------------------------------------------------
+	class UniExchange:
 		public IOController
-{
+	{
 		public:
 			UniExchange( uniset::ObjectId id, uniset::ObjectId shmID,
 						 const std::shared_ptr<SharedMemory>& ic = nullptr, const std::string& prefix = "unet" );
@@ -145,8 +145,8 @@ class UniExchange:
 			timeout_t smReadyTimeout = { 15000 }; // msec
 
 		private:
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // UniExchange_H_

extensions/include/Calibration.h

@@ -25,12 +25,12 @@
 //--------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*!
+	// -----------------------------------------------------------------------------
+	/*!
 	    Класс позволяющий загружать калибровочную
-характеристику из конфигурационного (xml)файла и получать по ней точки.
-\code
-C, калиброванное значение
+	характеристику из конфигурационного (xml)файла и получать по ней точки.
+	\code
+	C, калиброванное значение
 	  ^
 	  |
 	  |
@@ -38,13 +38,13 @@ C, калиброванное значение
 	  |
 	   -------->
 	           R(raw value), сырое значение
-\endcode
+	\endcode
 
-Сами диаграммы представляют из себя следующую секцию в xml
-x - сырое значение (по которому ведётся поиск)
-y - калиброванное значение
-\code
-<Calibrations name="Calibrations">
+	Сами диаграммы представляют из себя следующую секцию в xml
+	x - сырое значение (по которому ведётся поиск)
+	y - калиброванное значение
+	\code
+	<Calibrations name="Calibrations">
 	    <diagram name="testcal">
 	        <point x="-200" y="-60"/>
 	        <point x="-100" y="-60"/>
@@ -61,23 +61,23 @@ y - калиброванное значение
 	    ...
 	    </diagram>
 	    ...
-</Calibrations>
-\endcode
+	</Calibrations>
+	\endcode
 
-Диаграмма позволяет задать множество точек. На отрезках между точками используется линейная аппроксимация.
+	Диаграмма позволяет задать множество точек. На отрезках между точками используется линейная аппроксимация.
 
-Т.е. часто большую часть времени (во многих задачах) аналоговое значение, меняется в небольших пределах,
-то добавлен кэш ( rawValue --> calValue ) по умолчанию на 5 значений. Размер кэша можно задать
-(поменять или отключить) при помощи Calibration::setCacheSize().
-\note Слишком большим задавать кэш не рекомендуется, т.к. тогда поиск по кэшу будет сопоставим с поиском по диаграмме.
+	Т.е. часто большую часть времени (во многих задачах) аналоговое значение, меняется в небольших пределах,
+	то добавлен кэш ( rawValue --> calValue ) по умолчанию на 5 значений. Размер кэша можно задать
+	(поменять или отключить) при помощи Calibration::setCacheSize().
+	\note Слишком большим задавать кэш не рекомендуется, т.к. тогда поиск по кэшу будет сопоставим с поиском по диаграмме.
 
 	  Помимо этого, с учётом того, что каждое попадание в кэш обновляет счётчик обращений к значению, необходимо
-пересортировывать весь кэш (чтобы наиболее часто используемые были в начале). Чтобы не делать эту операцию каждый
-раз, сделан счётчик циклов. Т.е. через какое количество обращений к кэшу, производить принудительную пересортировку.
-Значение по умолчанию - 5(размер кэша). Задать можно при помощи Calibration::setCacheResortCycle()
-*/
-class Calibration
-{
+	пересортировывать весь кэш (чтобы наиболее часто используемые были в начале). Чтобы не делать эту операцию каждый
+	раз, сделан счётчик циклов. Т.е. через какое количество обращений к кэшу, производить принудительную пересортировку.
+	Значение по умолчанию - 5(размер кэша). Задать можно при помощи Calibration::setCacheResortCycle()
+	*/
+	class Calibration
+	{
 		public:
 			Calibration();
 			Calibration( const std::string& name, const std::string& confile = "calibration.xml", size_t reserv = 50 );
@@ -316,8 +316,8 @@ class Calibration
 			ValueCache cache;
 			size_t numCacheResort; // количество обращений, при которых происходит перестроение (сортировка) кэша..
 			size_t numCallToCache; // текущий счётчик обращений к кэшу
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // Calibration_H_

extensions/include/DigitalFilter.h

@@ -26,9 +26,9 @@
 //--------------------------------------------------------------------------
 namespace uniset
 {
-//--------------------------------------------------------------------------
-class DigitalFilter
-{
+	//--------------------------------------------------------------------------
+	class DigitalFilter
+	{
 		public:
 			DigitalFilter ( unsigned int bufsize = 5, double T = 0, double lsq = 0.2,
 							int iir_thr = 10000, double iir_coeff_prev = 0.5,
@@ -121,8 +121,8 @@ class DigitalFilter
 			// Коэффициенты для рекурсивного фильтра
 			double coeff_prev;
 			double coeff_new;
-};
-// -------------------------------------------------------------------------
+	};
+	// -------------------------------------------------------------------------
 } // end of namespace uniset
 //--------------------------------------------------------------------------
 #endif // DigitalFilter_H_

extensions/include/Extensions.h

@@ -25,30 +25,30 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-//--------------------------------------------------------------------------
-namespace extensions
-{
-/*! Получение идентификатора объекта(процесса) разделяемой памяти */
-uniset::ObjectId getSharedMemoryID();
+	//--------------------------------------------------------------------------
+	namespace extensions
+	{
+		/*! Получение идентификатора объекта(процесса) разделяемой памяти */
+		uniset::ObjectId getSharedMemoryID();
 
-xmlNode* findNode( xmlNode* node, const std::string& snode, const std::string& field );
+		xmlNode* findNode( xmlNode* node, const std::string& snode, const std::string& field );
 
-xmlNode* getCalibrationsSection();
+		xmlNode* getCalibrationsSection();
 
-/*! замена служебных символов в строке
+		/*! замена служебных символов в строке
 		 * '\\' -> '\n'
-*/
-void escape_string( std::string& s );
+		*/
+		void escape_string( std::string& s );
 
-/*! Загрузка калибровочной диаграммы */
-Calibration* buildCalibrationDiagram( const std::string& dname );
+		/*! Загрузка калибровочной диаграммы */
+		Calibration* buildCalibrationDiagram( const std::string& dname );
 
-void on_sigchild( int sig );
+		void on_sigchild( int sig );
 
-std::shared_ptr<DebugStream> dlog();
-}
-// -------------------------------------------------------------------------
-// "синтаксический сахар"..для логов
+		std::shared_ptr<DebugStream> dlog();
+	}
+	// -------------------------------------------------------------------------
+	// "синтаксический сахар"..для логов
 #define dinfo if( uniset::extensions::dlog()->debugging(Debug::INFO) ) uniset::extensions::dlog()->info()
 #define dwarn if( uniset::extensions::dlog()->debugging(Debug::WARN) ) uniset::extensions::dlog()->warn()
 #define dcrit if( uniset::extensions::dlog()->debugging(Debug::CRIT) ) uniset::extensions::dlog()->crit()
@@ -64,7 +64,7 @@ std::shared_ptr<DebugStream> dlog();
 #define dlogsys if( uniset::extensions::dlog()->debugging(Debug::SYSTEM) ) uniset::extensions::dlog()->system()
 #define dlogrep if( uniset::extensions::dlog()->debugging(Debug::REPOSITORY) ) uniset::extensions::dlog()->repository()
 #define dlogany uniset::extensions::dlog()->any()
-// --------------------------------------------------------------------------
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -------------------------------------------------------------------------
 

extensions/include/IOBase.h

@@ -29,14 +29,14 @@
 // -------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-static const int DefaultSubdev  = -1;
-static const int DefaultChannel = -1;
-static const int NoSafety       = -1;
-// -----------------------------------------------------------------------------
-/*! Свойства переменной в/в */
-struct IOBase
-{
+	// -----------------------------------------------------------------------------
+	static const int DefaultSubdev  = -1;
+	static const int DefaultChannel = -1;
+	static const int NoSafety       = -1;
+	// -----------------------------------------------------------------------------
+	/*! Свойства переменной в/в */
+	struct IOBase
+	{
 		// т.к. IOBase содержит rwmutex с запрещённым конструктором копирования
 		// приходится здесь тоже объявлять разрешенными только операции "перемещения"
 		IOBase( const IOBase& r ) = delete;
@@ -198,8 +198,8 @@ struct IOBase
 		static std::string initProp( UniXML::iterator& it, const std::string& prop, const std::string& prefix, bool prefonly, const std::string& defval = "" );
 		static int initIntProp( UniXML::iterator& it, const std::string& prop, const std::string& prefix, bool prefonly, const int defval = 0 );
 		static timeout_t initTimeoutProp( UniXML::iterator& it, const std::string& prop, const std::string& prefix, bool prefonly, const timeout_t defval);
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // IOBase_H_

extensions/include/PID.h

@@ -22,17 +22,17 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-/*! ПИД
+	// -----------------------------------------------------------------------------
+	/*! ПИД
 	    Формулы выведены на основе разностных уравнений
 	    см. http://atm.h1.ru/root/theory/theory33.html
 
 	    Он даёт неплохой результат и опимальнее по расчётам
 	    (содержит только умножение, не переполняется
 	        т.к. учитывает только два последних шага)
-*/
-class PID
-{
+	*/
+	class PID
+	{
 		public:
 			PID();
 			~PID();
@@ -76,8 +76,8 @@ class PID
 
 		protected:
 		private:
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // -----------------------------------------------------------------------------
 #endif // PID_H_

extensions/include/SMInterface.h

@@ -26,9 +26,9 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// --------------------------------------------------------------------------
-class SMInterface
-{
+	// --------------------------------------------------------------------------
+	class SMInterface
+	{
 		public:
 
 			SMInterface( uniset::ObjectId _shmID, const std::shared_ptr<UInterface>& ui,
@@ -68,23 +68,27 @@ class SMInterface
 			bool waitSMready( int msec, int pause = 5000 );
 			bool waitSMworking( uniset::ObjectId, int msec, int pause = 3000 );
 
-		inline bool isLocalwork()
+			inline bool isLocalwork() const noexcept
 			{
 				return (ic == NULL);
 			}
-		inline uniset::ObjectId ID()
+			inline uniset::ObjectId ID() const noexcept
 			{
 				return myid;
 			}
-		inline const std::shared_ptr<IONotifyController> SM()
+			inline const std::shared_ptr<IONotifyController> SM() noexcept
 			{
 				return ic;
 			}
-		inline uniset::ObjectId getSMID()
+			inline uniset::ObjectId getSMID() const noexcept
 			{
 				return shmID;
 			}
 
+#ifndef DISABLE_REST_API
+			std::string apiRequest( const std::string& query );
+#endif
+
 		protected:
 			const std::shared_ptr<IONotifyController> ic;
 			const std::shared_ptr<UInterface> ui;
@@ -92,8 +96,8 @@ class SMInterface
 			uniset::ObjectId shmID;
 			uniset::ObjectId myid;
 			uniset::uniset_rwmutex shmMutex;
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 //--------------------------------------------------------------------------
 #endif

extensions/include/SingleProcess.h

@@ -21,13 +21,13 @@
 // --------------------------------------------------------------------------
 namespace uniset
 {
-// --------------------------------------------------------------------------
-/*! Базовый класс для одиночных процессов.
+	// --------------------------------------------------------------------------
+	/*! Базовый класс для одиночных процессов.
 	    Обеспечивает корректное завершение процесса,
 	    даже по сигналам...
-*/
-class SingleProcess
-{
+	*/
+	class SingleProcess
+	{
 		public:
 			SingleProcess();
 			virtual ~SingleProcess();
@@ -42,8 +42,8 @@ class SingleProcess
 			static void terminated( int signo );
 			static void finishterm( int signo );
 
-};
-// --------------------------------------------------------------------------
+	};
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // --------------------------------------------------------------------------
 #endif // SingleProcess_H_

extensions/include/UObject_SK.h

@@ -8,7 +8,7 @@
  ВСЕ ВАШИ ИЗМЕНЕНИЯ БУДУТ ПОТЕРЯНЫ.
 */ 
 // --------------------------------------------------------------------------
-// generate timestamp: 2016-12-01+03:00
+// generate timestamp: 2017-01-06+03:00
 // -----------------------------------------------------------------------------
 #ifndef UObject_SK_H_
 #define UObject_SK_H_
@@ -29,7 +29,7 @@ class UObject_SK:
 	public uniset::UniSetObject
 {
 	public:
-		UObject_SK( uniset::ObjectId id, xmlNode* node = uniset::uniset_conf()->getNode("UObject"), const std::string& argprefix = "" );
+		UObject_SK( uniset::ObjectId id, xmlNode* node=uniset::uniset_conf()->getNode("UObject"), const std::string& argprefix="" );
 		UObject_SK();
 		virtual ~UObject_SK();
 
@@ -43,60 +43,54 @@ class UObject_SK:
 
 		virtual bool setMsg( uniset::ObjectId code, bool state = true ) noexcept;
 
-		inline std::shared_ptr<DebugStream> log() noexcept
-		{
-			return mylog;
-		}
-		inline std::shared_ptr<uniset::LogAgregator> logAgregator() noexcept
-		{
-			return loga;
-		}
+		inline std::shared_ptr<DebugStream> log() noexcept { return mylog; }
+		inline std::shared_ptr<uniset::LogAgregator> logAgregator() noexcept { return loga; }
 
 		void init_dlog( std::shared_ptr<DebugStream> d ) noexcept;
 
         // "синтаксический сахар"..для логов
-#ifndef myinfo
-#define myinfo if( log()->debugging(Debug::INFO) ) log()->info()
-#endif
-#ifndef mywarn
-#define mywarn if( log()->debugging(Debug::WARN) ) log()->warn()
-#endif
-#ifndef mycrit
-#define mycrit if( log()->debugging(Debug::CRIT) ) log()->crit()
-#endif
-#ifndef mylog1
-#define mylog1 if( log()->debugging(Debug::LEVEL1) ) log()->level1()
-#endif
-#ifndef mylog2
-#define mylog2 if( log()->debugging(Debug::LEVEL2) ) log()->level2()
-#endif
-#ifndef mylog3
-#define mylog3 if( log()->debugging(Debug::LEVEL3) ) log()->level3()
-#endif
-#ifndef mylog4
-#define mylog4 if( log()->debugging(Debug::LEVEL4) ) log()->level4()
-#endif
-#ifndef mylog5
-#define mylog5 if( log()->debugging(Debug::LEVEL5) ) log()->level5()
-#endif
-#ifndef mylog6
-#define mylog6 if( log()->debugging(Debug::LEVEL6) ) log()->level6()
-#endif
-#ifndef mylog7
-#define mylog7 if( log()->debugging(Debug::LEVEL7) ) log()->level7()
-#endif
-#ifndef mylog8
-#define mylog8 if( log()->debugging(Debug::LEVEL8) ) log()->level8()
-#endif
-#ifndef mylog9
-#define mylog9 if( log()->debugging(Debug::LEVEL9) ) log()->level9()
-#endif
-#ifndef mylogany
-#define mylogany log()->any()
-#endif
-#ifndef vmonit
-#define vmonit( var ) vmon.add( #var, var )
-#endif
+        #ifndef myinfo 
+        	#define myinfo if( log()->debugging(Debug::INFO) ) log()->info() 
+        #endif
+        #ifndef mywarn
+	        #define mywarn if( log()->debugging(Debug::WARN) ) log()->warn()
+        #endif
+        #ifndef mycrit
+    	    #define mycrit if( log()->debugging(Debug::CRIT) ) log()->crit()
+        #endif
+        #ifndef mylog1
+        	#define mylog1 if( log()->debugging(Debug::LEVEL1) ) log()->level1()
+        #endif
+        #ifndef mylog2
+	        #define mylog2 if( log()->debugging(Debug::LEVEL2) ) log()->level2()
+        #endif
+        #ifndef mylog3
+    	    #define mylog3 if( log()->debugging(Debug::LEVEL3) ) log()->level3()
+        #endif
+        #ifndef mylog4
+        	#define mylog4 if( log()->debugging(Debug::LEVEL4) ) log()->level4()
+        #endif
+        #ifndef mylog5
+	        #define mylog5 if( log()->debugging(Debug::LEVEL5) ) log()->level5()
+        #endif
+        #ifndef mylog6
+    	    #define mylog6 if( log()->debugging(Debug::LEVEL6) ) log()->level6()
+        #endif
+        #ifndef mylog7
+        	#define mylog7 if( log()->debugging(Debug::LEVEL7) ) log()->level7()
+        #endif
+        #ifndef mylog8
+	        #define mylog8 if( log()->debugging(Debug::LEVEL8) ) log()->level8()
+        #endif
+        #ifndef mylog9
+    	    #define mylog9 if( log()->debugging(Debug::LEVEL9) ) log()->level9()
+        #endif
+        #ifndef mylogany
+        	#define mylogany log()->any()
+        #endif
+        #ifndef vmonit
+            #define vmonit( var ) vmon.add( #var, var )
+        #endif
         
         // Вспомогательные функции для удобства логирования
         // ------------------------------------------------------------
@@ -113,19 +107,16 @@ class UObject_SK:
            \param id           - идентификатор датчика
            \param showLinkName - TRUE - выводить SensorName, FALSE - не выводить
         */
-		std::string str( uniset::ObjectId id, bool showLinkName = true ) const;
+        std::string str( uniset::ObjectId id, bool showLinkName=true ) const;
         
         /*! Вывод значения входа/выхода в формате: in_xxx(SensorName)=val 
            \param id           - идентификатор датчика
            \param showLinkName - TRUE - выводить SensorName, FALSE - не выводить
         */
-		std::string strval( uniset::ObjectId id, bool showLinkName = true ) const;
+        std::string strval( uniset::ObjectId id, bool showLinkName=true ) const;        
         
         /*! Вывод состояния внутренних переменных */
-		inline std::string dumpVars()
-		{
-			return std::move(vmon.pretty_str());
-		}
+        inline std::string dumpVars(){ return vmon.pretty_str(); }
         // ------------------------------------------------------------
         std::string help() noexcept;
 
@@ -161,25 +152,22 @@ class UObject_SK:
 		
 		virtual void callback() noexcept override;
 		virtual void processingMessage( const uniset::VoidMessage* msg ) override;
-		virtual void sysCommand( const uniset::SystemMessage* sm ) {};
-		virtual void askSensors( UniversalIO::UIOCommand cmd ) {}
-		virtual void sensorInfo( const uniset::SensorMessage* sm ) override {}
-		virtual void timerInfo( const uniset::TimerMessage* tm ) override {}
+		virtual void sysCommand( const uniset::SystemMessage* sm ){};
+		virtual void askSensors( UniversalIO::UIOCommand cmd ){}
+		virtual void sensorInfo( const uniset::SensorMessage* sm ) override{}
+		virtual void timerInfo( const uniset::TimerMessage* tm ) override{}
 		virtual void sigterm( int signo ) override;
 		virtual bool activateObject() override;
-		virtual std::string getMonitInfo()
-		{
-			return "";    /*!< пользовательская информация выводимая в getInfo() */
-		}
+		virtual std::string getMonitInfo(){ return ""; } /*!< пользовательская информация выводимая в getInfo() */
 
 #ifndef DISABLE_REST_API
-		virtual void httpGetUserData( Poco::JSON::Object::Ptr& jdata ) {} /*!<  для пользовательских данных в httpGet() */
+		virtual void httpGetUserData( Poco::JSON::Object::Ptr& jdata ){} /*!<  для пользовательских данных в httpGet() */
         virtual Poco::JSON::Object::Ptr httpDumpIO();
         virtual Poco::JSON::Object::Ptr httpRequestLog( const Poco::URI::QueryParameters& p );
 #endif
 
         // Выполнение очередного шага программы
-		virtual void step() {}
+		virtual void step(){}
 
 		void preAskSensors( UniversalIO::UIOCommand cmd );
 		void preSysCommand( const uniset::SystemMessage* sm );
@@ -208,15 +196,9 @@ class UObject_SK:
 		
 		xmlNode* confnode;
 		/*! получить числовое свойство из конф. файла по привязанной confnode */
-		int getIntProp(const std::string& name)
-		{
-			return uniset::uniset_conf()->getIntProp(confnode, name);
-		}
+		int getIntProp(const std::string& name) { return uniset::uniset_conf()->getIntProp(confnode, name); }
 		/*! получить текстовое свойство из конф. файла по привязанной confnode */
-		inline const std::string getProp(const std::string& name)
-		{
-			return uniset::uniset_conf()->getProp(confnode, name);
-		}
+		inline const std::string getProp(const std::string& name) { return uniset::uniset_conf()->getProp(confnode, name); }
 
 		uniset::timeout_t smReadyTimeout; 	/*!< время ожидания готовности SM */
 		std::atomic_bool activated;
@@ -267,9 +249,11 @@ class UObject_SK:
 			}
 		};
 		
-		std::unordered_map<const uniset::ObjectId, size_t, StatHashFn> smStat; /*!< количество сообщений по датчикам */
+		std::unordered_map<const uniset::ObjectId,size_t, StatHashFn> smStat; /*!< количество сообщений по датчикам */
 		size_t processingMessageCatchCount = { 0 }; /*!< количество исключений пойманных в processingMessage */
 		
+		std::string ostate = { "" }; /*!< состояние процесса (выводится в getInfo()) */
+		
 
 		bool end_private; // вспомогательное поле (для внутреннего использования при генерировании кода)
 };

extensions/include/VTypes.h

@@ -19,6 +19,7 @@
 #define _RTUTypes_H_
 // -----------------------------------------------------------------------------
 #include <string>
+#include <stdint.h>
 #include <cmath>
 #include <cstring>
 #include <ostream>
@@ -26,12 +27,12 @@
 // -----------------------------------------------------------------------------
 namespace uniset
 {
-// -----------------------------------------------------------------------------
-namespace VTypes
-{
-/*! Тип переменной для Modbus[RTU|TCP] */
-enum VType
-{
+	// -----------------------------------------------------------------------------
+	namespace VTypes
+	{
+		/*! Тип переменной для Modbus[RTU|TCP] */
+		enum VType
+		{
 			vtUnknown,
 			vtF2,        /*!< двойное слово float(4 байта). В виде строки задаётся как \b "F2". */
 			vtF2r,       /*!< двойное слово float(4 байта). С перевёрнутой (reverse) последовательностью слов. \b "F2r". */
@@ -43,17 +44,17 @@ enum VType
 			vtI2r,       /*!< целое (4 байта). С перевёрнутой (reverse) последовательностью слов. В виде строки задаётся как \b "I2r".*/
 			vtU2,        /*!< беззнаковое целое (4 байта). В виде строки задаётся как \b "U2".*/
 			vtU2r        /*!< беззнаковое целое (4 байта). С перевёрнутой (reverse) последовательностью слов. В виде строки задаётся как \b "U2r".*/
-};
+		};
 
-std::ostream& operator<<( std::ostream& os, const VType& vt );
+		std::ostream& operator<<( std::ostream& os, const VType& vt );
 
-// -------------------------------------------------------------------------
-std::string type2str( VType t ) noexcept;           /*!< преобразование строки в тип */
-VType str2type( const std::string& s ) noexcept;    /*!< преобразование названия в строку */
-int wsize( VType t ) noexcept;                      /*!< длина данных в словах */
-// -------------------------------------------------------------------------
-class F2
-{
+		// -------------------------------------------------------------------------
+		std::string type2str( VType t ) noexcept;           /*!< преобразование строки в тип */
+		VType str2type( const std::string& s ) noexcept;    /*!< преобразование названия в строку */
+		int wsize( VType t ) noexcept;                      /*!< длина данных в словах */
+		// -------------------------------------------------------------------------
+		class F2
+		{
 			public:
 
 				// ------------------------------------------
@@ -61,7 +62,7 @@ class F2
 				/*! тип хранения в памяти */
 				typedef union
 				{
-			unsigned short v[f2Size];
+					uint16_t v[f2Size];
 					float val; //
 				} F2mem;
 				// ------------------------------------------
@@ -108,11 +109,11 @@ class F2
 				}
 
 				F2mem raw;
-};
-// --------------------------------------------------------------------------
-class F2r:
+		};
+		// --------------------------------------------------------------------------
+		class F2r:
 			public F2
-{
+		{
 			public:
 
 				// ------------------------------------------
@@ -137,17 +138,17 @@ class F2r:
 				~F2r() noexcept {}
 
 				F2mem raw_backorder;
-};
-// --------------------------------------------------------------------------
-class F4
-{
+		};
+		// --------------------------------------------------------------------------
+		class F4
+		{
 			public:
 				// ------------------------------------------
 				static const size_t f4Size = 4;
 				/*! тип хранения в памяти */
 				typedef union
 				{
-			unsigned short v[f4Size];
+					uint16_t v[f4Size];
 					float val; //
 				} F4mem;
 				// ------------------------------------------
@@ -190,10 +191,10 @@ class F4
 				}
 
 				F4mem raw;
-};
-// --------------------------------------------------------------------------
-class Byte
-{
+		};
+		// --------------------------------------------------------------------------
+		class Byte
+		{
 			public:
 
 				static const size_t bsize = 2;
@@ -202,8 +203,8 @@ class Byte
 				/*! тип хранения в памяти */
 				typedef union
 				{
-			unsigned short w;
-			unsigned char b[bsize];
+					uint16_t w;
+					uint8_t b[bsize];
 				} Bytemem;
 				// ------------------------------------------
 				// конструкторы на разные случаи...
@@ -212,15 +213,11 @@ class Byte
 					raw.w = 0;
 				}
 
-		Byte( unsigned char b1, unsigned char b2 ) noexcept
+				Byte( uint8_t b1, uint8_t b2 ) noexcept
 				{
 					raw.b[0] = b1;
 					raw.b[1] = b2;
 				}
-		Byte( const long& val ) noexcept
-		{
-			raw.w = val;
-		}
 
 				Byte( const ModbusRTU::ModbusData dat ) noexcept
 				{
@@ -240,25 +237,21 @@ class Byte
 					return vtByte;
 				}
 				// ------------------------------------------
-		operator long()
-		{
-			return lroundf(raw.w);
-		}
-		operator unsigned short()
+				operator uint16_t()
 				{
 					return raw.w;
 				}
 
-		unsigned char operator[]( const int i )
+				uint8_t operator[]( const size_t i )
 				{
 					return raw.b[i];
 				}
 
 				Bytemem raw;
-};
-// --------------------------------------------------------------------------
-class Unsigned
-{
+		};
+		// --------------------------------------------------------------------------
+		class Unsigned
+		{
 			public:
 
 				// ------------------------------------------
@@ -293,11 +286,11 @@ class Unsigned
 					return raw;
 				}
 
-		unsigned short raw;
-};
-// --------------------------------------------------------------------------
-class Signed
-{
+				uint16_t raw;
+		};
+		// --------------------------------------------------------------------------
+		class Signed
+		{
 			public:
 
 				// ------------------------------------------
@@ -332,11 +325,11 @@ class Signed
 					return raw;
 				}
 
-		signed short raw;
-};
-// --------------------------------------------------------------------------
-class I2
-{
+				int16_t raw;
+		};
+		// --------------------------------------------------------------------------
+		class I2
+		{
 			public:
 
 				// ------------------------------------------
@@ -344,8 +337,8 @@ class I2
 				/*! тип хранения в памяти */
 				typedef union
 				{
-			unsigned short v[i2Size];
-			int val; //
+					uint16_t v[i2Size];
+					int32_t val; //
 				} I2mem;
 				// ------------------------------------------
 				// конструкторы на разные случаи...
@@ -354,7 +347,7 @@ class I2
 					memset(raw.v, 0, sizeof(raw.v));
 				}
 
-		I2( int v ) noexcept
+				I2( int32_t v ) noexcept
 				{
 					raw.val = v;
 				}
@@ -377,24 +370,24 @@ class I2
 					return vtI2;
 				}
 				// ------------------------------------------
-		operator int()
+				operator int32_t()
 				{
 					return raw.val;
 				}
 
 				I2mem raw;
-};
-// --------------------------------------------------------------------------
-class I2r:
+		};
+		// --------------------------------------------------------------------------
+		class I2r:
 			public I2
-{
+		{
 			public:
 				I2r() noexcept
 				{
 					raw_backorder.val = 0;
 				}
 
-		I2r( const int v ) noexcept: I2(v)
+				I2r( const int32_t v ) noexcept: I2(v)
 				{
 					raw_backorder = raw;
 					std::swap(raw_backorder.v[0], raw_backorder.v[1]);
@@ -410,10 +403,10 @@ class I2r:
 				~I2r() noexcept {}
 
 				I2mem raw_backorder;
-};
-// --------------------------------------------------------------------------
-class U2
-{
+		};
+		// --------------------------------------------------------------------------
+		class U2
+		{
 			public:
 
 				// ------------------------------------------
@@ -421,8 +414,8 @@ class U2
 				/*! тип хранения в памяти */
 				typedef union
 				{
-			unsigned short v[u2Size];
-			unsigned int val; //
+					uint16_t v[u2Size];
+					uint32_t val; //
 				} U2mem;
 				// ------------------------------------------
 				// конструкторы на разные случаи...
@@ -431,7 +424,7 @@ class U2
 					memset(raw.v, 0, sizeof(raw.v));
 				}
 
-		U2( unsigned int v ) noexcept
+				U2( uint32_t v ) noexcept
 				{
 					raw.val = v;
 				}
@@ -454,24 +447,34 @@ class U2
 					return vtU2;
 				}
 				// ------------------------------------------
-		operator unsigned int()
+				operator uint32_t()
 				{
 					return raw.val;
 				}
 
+				operator long()
+				{
+					return raw.val;
+				}
+
+				operator unsigned long()
+				{
+					return (uint32_t)raw.val;
+				}
+
 				U2mem raw;
-};
-// --------------------------------------------------------------------------
-class U2r:
+		};
+		// --------------------------------------------------------------------------
+		class U2r:
 			public U2
-{
+		{
 			public:
 				U2r() noexcept
 				{
 					raw_backorder.val = 0;
 				}
 
-		U2r( int v ) noexcept: U2(v)
+				U2r( int32_t v ) noexcept: U2(v)
 				{
 					raw_backorder = raw;
 					std::swap(raw_backorder.v[0], raw_backorder.v[1]);
@@ -487,11 +490,11 @@ class U2r:
 				~U2r() {}
 
 				U2mem raw_backorder;
-};
-// --------------------------------------------------------------------------
+		};
+		// --------------------------------------------------------------------------
 
-} // end of namespace VTypes
-// --------------------------------------------------------------------------
+	} // end of namespace VTypes
+	// --------------------------------------------------------------------------
 } // end of namespace uniset
 // --------------------------------------------------------------------------
 #endif // _RTUTypes_H_

extensions/lib/DigitalFilter.cc

@@ -25,8 +25,8 @@ using namespace std;
 //--------------------------------------------------------------------------
 namespace uniset
 {
-//--------------------------------------------------------------------------
-DigitalFilter::DigitalFilter( unsigned int bufsize, double T, double lsq,
+	//--------------------------------------------------------------------------
+	DigitalFilter::DigitalFilter( unsigned int bufsize, double T, double lsq,
 								  int iir_thr, double iir_coeff_prev,
 								  double iir_coeff_new ):
 		Ti(T),
@@ -43,20 +43,20 @@ DigitalFilter::DigitalFilter( unsigned int bufsize, double T, double lsq,
 		prev(0),
 		coeff_prev(iir_coeff_prev),
 		coeff_new(iir_coeff_new)
-{
+	{
 		buf.resize(maxsize);
 		mvec.reserve(maxsize);
 		init(val);
-}
-//--------------------------------------------------------------------------
-DigitalFilter::~DigitalFilter()
-{
-}
-//--------------------------------------------------------------------------
-void DigitalFilter::setSettings( unsigned int bufsize, double T, double lsq,
+	}
+	//--------------------------------------------------------------------------
+	DigitalFilter::~DigitalFilter()
+	{
+	}
+	//--------------------------------------------------------------------------
+	void DigitalFilter::setSettings( unsigned int bufsize, double T, double lsq,
 									 int iir_thr, double iir_coeff_prev,
 									 double iir_coeff_new )
-{
+	{
 		Ti = T;
 		maxsize = bufsize;
 
@@ -85,10 +85,10 @@ void DigitalFilter::setSettings( unsigned int bufsize, double T, double lsq,
 
 		lsparam = lsq;
 		mvec.resize(maxsize);
-}
-//--------------------------------------------------------------------------
-void DigitalFilter::init( int val )
-{
+	}
+	//--------------------------------------------------------------------------
+	void DigitalFilter::init( int val )
+	{
 		buf.clear();
 
 		for( size_t i = 0; i < maxsize; i++ )
@@ -98,10 +98,10 @@ void DigitalFilter::init( int val )
 
 		tmr.reset();
 		this->val = val;
-}
-//--------------------------------------------------------------------------
-double DigitalFilter::firstLevel()
-{
+	}
+	//--------------------------------------------------------------------------
+	double DigitalFilter::firstLevel()
+	{
 		// считаем среднее арифметическое
 		M = 0;
 
@@ -143,19 +143,19 @@ double DigitalFilter::firstLevel()
 			return M;
 
 		return ( val / n );
-}
-//--------------------------------------------------------------------------
-int DigitalFilter::filterRC( int rawval )
-{
+	}
+	//--------------------------------------------------------------------------
+	int DigitalFilter::filterRC( int rawval )
+	{
 		if( Ti <= 0 )
 			return rawval;
 
 		return lroundf(secondLevel(rawval));
-}
-//--------------------------------------------------------------------------
+	}
+	//--------------------------------------------------------------------------
 
-double DigitalFilter::secondLevel( double rawval )
-{
+	double DigitalFilter::secondLevel( double rawval )
+	{
 		if( Ti <= 0 )
 			return rawval;
 
@@ -171,19 +171,19 @@ double DigitalFilter::secondLevel( double rawval )
 		val = (rawval + Ti * val / dt) / (Ti / dt + 1);
 
 		return val;
-}
-//--------------------------------------------------------------------------
-int DigitalFilter::filter1( int newval )
-{
+	}
+	//--------------------------------------------------------------------------
+	int DigitalFilter::filter1( int newval )
+	{
 		if( maxsize < 1 )
 			return newval;
 
 		add(newval);
 		return lroundf(firstLevel());
-}
-//--------------------------------------------------------------------------
-void DigitalFilter::add( int newval )
-{
+	}
+	//--------------------------------------------------------------------------
+	void DigitalFilter::add( int newval )
+	{
 		// помещаем очередное значение в буфер
 		// удаляя при этом старое (FIFO)
 
@@ -193,20 +193,20 @@ void DigitalFilter::add( int newval )
 		//        buf.pop_front();
 		buf.pop_front();
 		buf.push_back(newval);
-}
-//--------------------------------------------------------------------------
-int DigitalFilter::current1()
-{
+	}
+	//--------------------------------------------------------------------------
+	int DigitalFilter::current1()
+	{
 		return lroundf(firstLevel());
-}
-//--------------------------------------------------------------------------
-int DigitalFilter::currentRC()
-{
+	}
+	//--------------------------------------------------------------------------
+	int DigitalFilter::currentRC()
+	{
 		return lroundf(secondLevel(current1()));
-}
-//--------------------------------------------------------------------------
-std::ostream& operator<<(std::ostream& os, const DigitalFilter& d )
-{
+	}
+	//--------------------------------------------------------------------------
+	std::ostream& operator<<(std::ostream& os, const DigitalFilter& d )
+	{
 		os << "(" << d.buf.size() << ")[";
 
 		for( auto& i : d.buf )
@@ -214,15 +214,15 @@ std::ostream& operator<<(std::ostream& os, const DigitalFilter& d )
 
 		os << " ]";
 		return os;
-}
-//--------------------------------------------------------------------------
-std::ostream& operator<<(std::ostream& os, const DigitalFilter* d)
-{
+	}
+	//--------------------------------------------------------------------------
+	std::ostream& operator<<(std::ostream& os, const DigitalFilter* d)
+	{
 		return os << (*d);
-}
-//--------------------------------------------------------------------------
-int DigitalFilter::median( int newval )
-{
+	}
+	//--------------------------------------------------------------------------
+	int DigitalFilter::median( int newval )
+	{
 		if( maxsize < 1 )
 			return newval;
 
@@ -233,10 +233,10 @@ int DigitalFilter::median( int newval )
 		mvec_sorted = true;
 
 		return mvec[maxsize / 2];
-}
-//--------------------------------------------------------------------------
-int DigitalFilter::currentMedian()
-{
+	}
+	//--------------------------------------------------------------------------
+	int DigitalFilter::currentMedian()
+	{
 		if( !mvec_sorted )
 		{
 			mvec.assign(buf.begin(), buf.end());
@@ -245,10 +245,10 @@ int DigitalFilter::currentMedian()
 		}
 
 		return mvec[maxsize / 2];
-}
-//--------------------------------------------------------------------------
-int DigitalFilter::leastsqr( int newval )
-{
+	}
+	//--------------------------------------------------------------------------
+	int DigitalFilter::leastsqr( int newval )
+	{
 		ls = 0;
 
 		add(newval);
@@ -270,15 +270,15 @@ int DigitalFilter::leastsqr( int newval )
 			w[i] = w[i] + *it * u;
 
 		return lroundf(ls);
-}
-//--------------------------------------------------------------------------
-int DigitalFilter::currentLS()
-{
+	}
+	//--------------------------------------------------------------------------
+	int DigitalFilter::currentLS()
+	{
 		return lroundf(ls);
-}
-//--------------------------------------------------------------------------
-int DigitalFilter::filterIIR( int newval )
-{
+	}
+	//--------------------------------------------------------------------------
+	int DigitalFilter::filterIIR( int newval )
+	{
 		if( newval > prev + thr || newval < prev - thr || maxsize < 1 )
 		{
 			if( maxsize > 0 )
@@ -300,11 +300,11 @@ int DigitalFilter::filterIIR( int newval )
 		}
 
 		return prev;
-}
-//--------------------------------------------------------------------------
-int DigitalFilter::currentIIR()
-{
+	}
+	//--------------------------------------------------------------------------
+	int DigitalFilter::currentIIR()
+	{
 		return prev;
-}
-//--------------------------------------------------------------------------
+	}
+	//--------------------------------------------------------------------------
 } // end of namespace uniset