Skip to content

U
uniset2
Commit 07d7b048 authored by Pavel Vainerman's avatar Pavel Vainerman
Browse files
Options

(2.0): - Заменил ТАБУЛЯЦИИ НА ПРОБЕЛЫ по всем исходным файлам - Небольшая…

(2.0): - Заменил ТАБУЛЯЦИИ НА ПРОБЕЛЫ по всем исходным файлам - Небольшая оптимизация по преобразованию сообщений из VoidMessage.
parent c4af79f7
Show whitespace changes
Inline Side-by-side
Showing with 637 additions and 550 deletions
Utilities/MBTester/MBSlave.h
View file @ 07d7b048
......@@ -94,9 +94,6 @@ class MBSlave
ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
ModbusRTU::MEIMessageRetRDI& reply );
ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
ModbusRTU::MEIMessageRetRDI& reply );
/*! интерфейс ModbusRTUSlave для обмена по RS */
ModbusRTUSlaveSlot* rscomm;
ModbusRTU::ModbusAddr addr; /*!< адрес данного узла */
......
Utilities/MBTester/MBTCPServer.h
View file @ 07d7b048
......@@ -23,11 +23,6 @@ class MBTCPServer
replyVal = val;
}
inline void setReply( long val )
{
replyVal = val;
}
inline void setIgnoreAddrMode( bool state )
{
if( sslot )
......@@ -80,9 +75,6 @@ class MBTCPServer
ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
ModbusRTU::MEIMessageRetRDI& reply );
ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
ModbusRTU::MEIMessageRetRDI& reply );
/*! обработка запросов на чтение ошибок */
ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query,
ModbusRTU::JournalCommandRetMessage& reply );
......
Utilities/codegen/ctl-cpp-common.xsl
View file @ 07d7b048
......@@ -611,6 +611,7 @@ end_private(false)
<xsl:if test="normalize-space(@no_check_id)!='1'">
if( <xsl:value-of select="normalize-space(@name)"/> == UniSetTypes::DefaultObjectId )
throw Exception( myname + ": Not found ID for (<xsl:value-of select="@name"/>) " + conf->getProp(cnode,"<xsl:value-of select="@name"/>") );
</xsl:if>
if( node_<xsl:value-of select="normalize-space(@name)"/> == UniSetTypes::DefaultObjectId )
......
Utilities/codegen/tests/TestGen.cc
View file @ 07d7b048
#include <iomanip>
#include "Exceptions.h"
#include "TestProc.h"
#include "TestGen.h"
// -----------------------------------------------------------------------------
using namespace std;
using namespace UniSetTypes;
// -----------------------------------------------------------------------------
TestProc::TestProc( UniSetTypes::ObjectId id, xmlNode* confnode ):
TestProc_SK( id, confnode ),
state(false)
TestGen::TestGen( UniSetTypes::ObjectId id, xmlNode* confnode ):
TestGen_SK( id, confnode )
{
loglevels.push_back(Debug::INFO);
loglevels.push_back(Debug::WARN);
loglevels.push_back(Debug::CRIT);
loglevels.push_back(Debug::LEVEL1);
loglevels.push_back(Debug::LEVEL2);
loglevels.push_back( Debug::type(Debug::LEVEL2 | Debug::INFO) );
loglevels.push_back( Debug::type(Debug::LEVEL2 | Debug::INFO | Debug::WARN | Debug::CRIT) );
lit = loglevels.begin();
out_log_c = (*lit);
}
// -----------------------------------------------------------------------------
TestProc::~TestProc()
TestGen::~TestGen()
{
}
// -----------------------------------------------------------------------------
TestProc::TestProc():
state(false)
TestGen::TestGen()
{
cerr << ": init failed!!!!!!!!!!!!!!!"<< endl;
throw Exception();
}
// -----------------------------------------------------------------------------
void TestProc::step()
void TestGen::step()
{
cout << "input2 state=" << in_input2_s << endl;
}
// -----------------------------------------------------------------------------
void TestProc::sysCommand( UniSetTypes::SystemMessage* sm )
void TestGen::sensorInfo( SensorMessage *sm )
{
TestProc_SK::sysCommand(sm);
if( sm->command == SystemMessage::StartUp || sm->command == SystemMessage::WatchDog )
{
askTimer(tmCheck,checkTime);
askTimer(tmCheckWorking,checkWorkingTime);
askTimer(tmLogControl,checkLogTime);
// В начальный момент времени блокирующий датчик =0, поэтому d2_check_s должен быть равен depend_off_value (-50).
cerr << myname << "(startup): check init depend: " << ( getValue(d2_check_s) == -50 ? "OK" : "FAIL" ) << endl;
}
if( sm->id == input1_s )
out_output1_c = in_input1_s; // sm->state
}
// -----------------------------------------------------------------------------
void TestProc::sensorInfo( SensorMessage *sm )
void TestGen::timerInfo( TimerMessage *tm )
{
/*
dlog.level2() << myname << "(sensorInfo): id=" << sm->id << " val=" << sm->value
<< " " << timeToString(sm->sm_tv_sec,":")
<< "(" << setw(6) << sm->sm_tv_usec << "): "
<< endl;
*/
if( sm->id == on_s )
{
if( sm->value )
{
cerr << myname << "(sensorInfo): START WORKING.." << endl;
askTimer(tmChange,changeTime);
}
else
{
askTimer(tmChange,0);
cerr << myname << "(sensorInfo): STOP WORKING.." << endl;
}
}
else if( sm->id == check_undef_s )
{
cerr << myname << "(sensorInfo): CHECK UNDEFINED STATE ==> " << (sm->undefined==undef ? "OK" : "FAIL") << endl;
}
}
// -----------------------------------------------------------------------------
void TestProc::timerInfo( TimerMessage *tm )
void TestGen::sigterm( int signo )
{
if( tm->id == tmChange )
{
state^=true;
out_lamp_c = ( state ? lmpBLINK : lmpOFF );
dlog.level2() << myname << ": state=" << state << " lmp=" << out_lamp_c << endl;
askTimer(tmCheckWorking,checkTime); // reset timer
}
else if( tm->id == tmCheckWorking )
cerr << myname << ": WORKING FAIL!" << endl;
else if( tm->id == tmCheck )
{
cerr << endl << endl << "--------" << endl;
test_depend();
test_undefined_state();
test_thresholds();
test_loglevel();
}
else if( tm->id == tmLogControl )
{
cerr << endl;
cerr << "======= TEST LOG PRINT ======" << endl;
cerr << "LOGLEVEL: [" << (int)(*lit) << "] " << (*lit) << endl;
for( std::vector<Debug::type>::iterator it=loglevels.begin(); it!=loglevels.end(); ++it )
dlog[*it] << myname << ": test log print..." << endl;
cerr << "======= END LOG PRINT ======" << endl;
}
}
// -----------------------------------------------------------------------------
void TestProc::test_depend()
{
cerr << myname << ": Check depend..." << endl;
long test_val = 100;
// set depend 0...
setValue(depend_c,0);
setValue(set_d1_check_s,test_val);
setValue(set_d2_check_s,test_val);
cerr << myname << ": check depend OFF: d1: " << ( getValue(d1_check_s) == 0 ? "OK" : "FAIL" ) << endl;
cerr << myname << ": check depend OFF: d2: " << ( getValue(d2_check_s) == -50 ? "OK" : "FAIL" ) << endl;
// set depend 1
setValue(depend_c,1);
cerr << myname << ": check depend ON: d1: " << ( getValue(d1_check_s) == test_val ? "OK" : "FAIL" ) << endl;
cerr << myname << ": check depend ON: d2: " << ( getValue(d2_check_s) == test_val ? "OK" : "FAIL" ) << endl;
}
// -----------------------------------------------------------------------------
void TestProc::test_undefined_state()
{
// ---------------- Проверка выставления неопределённого состояния ---------------------
cerr << myname << ": Check undef state..." << endl;
undef ^= true;
si.id = undef_c;
si.node = conf->getLocalNode();
cerr << myname << ": set undefined=" << undef << endl;
ui.setUndefinedState( si, undef, getId() );
}
// -----------------------------------------------------------------------------
void TestProc::test_thresholds()
{
// ---------------- Проверка работы порогов ---------------------
cerr << myname << ": Check thresholds..." << endl;
setValue(t_set_c,0);
cerr << myname << ": check threshold OFF value: " << ( getValue(t_check_s) == 0 ? "OK" : "FAIL" ) << endl;
setValue(t_set_c,378);
cerr << myname << ": check threshold ON value: " << ( getValue(t_check_s) == 1 ? "OK" : "FAIL" ) << endl;
cerr << myname << ": ask threshold and check.. " << endl;
try
{
setValue(t_set_c, 0);
UniSetTypes::ThresholdId tid = 100;
ui.askThreshold( t_set_c, tid, UniversalIO::UIONotify, 10, 20 );
IONotifyController_i::ThresholdInfo ti = ui.getThresholdInfo(t_set_c,tid);
cerr << myname << ": ask OFF threshold: " << ( ti.state == IONotifyController_i::NormalThreshold ? "OK" : "FAIL" ) << endl;
setValue(t_set_c, 25);
ti = ui.getThresholdInfo(t_set_c,tid);
cerr << myname << ": ask ON threshold: " << ( ti.state == IONotifyController_i::HiThreshold ? "OK" : "FAIL" ) << endl;
}
catch( Exception& ex )
{
dlog.level2() << myname << ": CHECK 'ask and get threshold' FAILED: " << ex << endl;
}
}
// -----------------------------------------------------------------------------
void TestProc::test_loglevel()
{
lit++;
if( lit == loglevels.end() )
lit = loglevels.begin();
cerr << "SET LOGLEVEL: [" << (int)(*lit) << "] " << (*lit) << endl;
setValue(log_c, (*lit));
askTimer(tmLogControl,checkLogTime);
TestGen_SK::sigterm(signo);
}
// -----------------------------------------------------------------------------
Utilities/codegen/tests/TestGen.h
View file @ 07d7b048
// -----------------------------------------------------------------------------
#ifndef TestProc_H_
#define TestProc_H_
#ifndef TestGen_H_
#define TestGen_H_
// -----------------------------------------------------------------------------
#include <vector>
#include "Debug.h"
#include "TestProc_SK.h"
#include "TestGen_SK.h"
// -----------------------------------------------------------------------------
class TestProc:
public TestProc_SK
class TestGen:
public TestGen_SK
{
public:
TestProc( UniSetTypes::ObjectId id, xmlNode* confnode = UniSetTypes::conf->getNode("TestProc") );
virtual ~TestProc();
TestGen( UniSetTypes::ObjectId id, xmlNode* confnode = UniSetTypes::conf->getNode("TestGen") );
virtual ~TestGen();
protected:
TestProc();
enum Timers
{
tmChange,
tmCheckWorking,
tmCheck,
tmLogControl
};
protected:
TestGen();
virtual void step();
virtual void sensorInfo( UniSetTypes::SensorMessage *sm );
virtual void timerInfo( UniSetTypes::TimerMessage *tm );
virtual void sysCommand( UniSetTypes::SystemMessage* sm );
void test_depend();
void test_undefined_state();
void test_thresholds();
void test_loglevel();
void sensorInfo( UniSetTypes::SensorMessage *sm );
void timerInfo( UniSetTypes::TimerMessage *tm );
virtual void sigterm( int signo );
private:
bool state;
bool undef;
std::vector<Debug::type> loglevels;
std::vector<Debug::type>::iterator lit;
};
// -----------------------------------------------------------------------------
#endif // TestProc_H_
#endif // TestGen_H_
// -----------------------------------------------------------------------------
conf/test.xml
View file @ 07d7b048
......@@ -148,7 +148,7 @@
</rrd>
</RRDServer1>
</settings>
<ObjectsMap idfromfile="0">
<ObjectsMap idfromfile="1">
<!--
Краткие пояснения к полям секции 'sensors'
==========================================
......@@ -273,7 +273,6 @@
</messages>
<!-- <xi:include href="testID.xml"/> -->
<!-- <xi:include href="testIDnon-exist.xml"/> -->
<Calibrations name="Calibrations">
<diagram name="testcal">
<point x="-200" y="-60"/>
......
extensions/DBServer-MySQL/DBInterface.cc
View file @ 07d7b048
......@@ -54,7 +54,6 @@ bool DBInterface::connect( const string& host, const string& user, const string&
connected = false;
return false;
}
connected = true;
return true;
}
......@@ -219,10 +218,9 @@ bool DBInterface::moveToRow(int ind)
// -----------------------------------------------------------------------------------------
bool DBInterface::ping()
{
if(!mysql)
return false;
if(!connected)
if( !mysql || !connected )
return false;
// внимание mysql_ping возвращает 0
// если всё хорошо.... (поэтому мы инвертируем)
return !mysql_ping(mysql);
......
extensions/IOControl/IOControl.h
View file @ 07d7b048
......@@ -84,6 +84,10 @@
<br>\b jardelay - защита от дребезга. Задержка на дребезг, мсек.
<br>\b ondelay - задержка на срабатывание, мсек.
<br>\b offdelay - задержка на отпускание, мсек.
<br>\b iofront - работа по фронту сигнала (для DI).
<br> "01" - срабатывание (и отпускание) по переходу "0 --> 1"
<br> "10" - срабатывание (и отпускание) по переходу "1 --> 0"
<br>\b safety - безопасное значение. Значение которое сохраняется в случае аварийного
завершения процесса.
......
extensions/LogicProcessor/TDelay.cc
View file @ 07d7b048
......@@ -30,10 +30,8 @@ void TDelay::setIn( int num, bool state )
{
pt.setTiming(0); // reset timer
myout = false;
if( dlog.is_info() )
dlog.info() << this << ": set " << myout << endl;
if( prev != myout )
Element::setChildOut();
return;
......@@ -46,10 +44,8 @@ void TDelay::setIn( int num, bool state )
{
pt.setTiming(0); // reset timer
myout = true;
if( dlog.is_info() )
dlog.info() << this << ": set " << myout << endl;
if( prev != myout )
Element::setChildOut();
return;
......@@ -60,7 +56,6 @@ void TDelay::setIn( int num, bool state )
{
if( dlog.is_info() )
dlog.info() << this << ": set timer " << delay << " [msec]" << endl;
pt.setTiming(delay);
}
}
......
extensions/LogicProcessor/TOR.cc
View file @ 07d7b048
......@@ -62,7 +62,6 @@ void TOR::setIn( int num, bool state )
if( dlog.is_info() )
dlog.info() << this << ": myout " << myout << endl;
if( prev != myout )
Element::setChildOut();
}
......
extensions/ModbusMaster/MBExchange.cc
View file @ 07d7b048
......@@ -2411,7 +2411,11 @@ std::ostream& operator<<( std::ostream& os, const MBExchange::RSProperty& p )
// -----------------------------------------------------------------------------
void MBExchange::initDeviceList()
{
xmlNode* respNode = conf->findNode(cnode,"DeviceList");
xmlNode* respNode = 0;
UniXML* xml = conf->getConfXML();
if( xml )
respNode = xml->extFindNode(cnode,1,1,"DeviceList");
if( respNode )
{
UniXML_iterator it1(respNode);
......@@ -2480,7 +2484,6 @@ bool MBExchange::initDeviceInfo( RTUDeviceMap& m, ModbusRTU::ModbusAddr a, UniXM
if( dlog.is_info() )
dlog.info() << myname << "(initDeviceInfo): add addr=" << ModbusRTU::addr2str(a) << endl;
int tout = it.getPIntProp("timeout",5000);
d->second->resp_ptTimeout.setTiming(tout);
d->second->resp_invert = it.getIntProp("invert");
......
extensions/ModbusMaster/MBExchange.h
View file @ 07d7b048
......@@ -325,16 +325,6 @@ class MBExchange:
PassiveTimer ptReopen; /*!< таймер для переоткрытия соединения */
Trigger trReopen;
// т.к. пороговые датчики не связаны напрямую с обменом, создаём для них отдельный список
// и отдельно его проверяем потом
typedef std::list<IOBase> ThresholdList;
ThresholdList thrlist;
int aftersend_pause;
PassiveTimer ptReopen; /*!< таймер для переоткрытия соединения */
Trigger trReopen;
private:
MBExchange();
......
extensions/ModbusMaster/mtr-setup.cc
View file @ 07d7b048
......@@ -363,6 +363,7 @@ int main( int argc, char **argv )
return 1;
}
return 0;
}
catch( ModbusRTU::mbException& ex )
{
......@@ -381,7 +382,7 @@ int main( int argc, char **argv )
cerr << "(mtr-setup): catch(...)" << endl;
}
return 0;
return 1;
}
// --------------------------------------------------------------------------
char* checkArg( int i, int argc, char* argv[] )
......
extensions/ModbusMaster/start_fg_mbtcp.sh
View file @ 07d7b048
......@@ -5,10 +5,18 @@
--mbtcp-name MBMaster1 \
--smemory-id SharedMemory \
--dlog-add-levels info,crit,warn,level4,level3 \
--mbtcp-filter-field mbtcp \
--mbtcp-filter-value 1 \
--mbtcp-set-prop-prefix \
--mbtcp-filter-field rs \
--mbtcp-filter-value 5 \
--mbtcp-gateway-iaddr 127.0.0.1 \
--mbtcp-gateway-port 2048 \
--mbtcp-recv-timeout 5000 \
--mbtcp-force-disconnect 1
--mbtcp-force-disconnect 1 \
--mbtcp-polltime 3000 \
--mbtcp-force-out 1 \
$*
#--mbtcp-exchange-mode-id MB1_Mode_AS \
#--mbtcp-filter-field mbtcp --mbtcp-filter-value 1
#--mbtcp-set-prop-prefix rs_ \
extensions/ModbusMaster/vtconv.cc
View file @ 07d7b048
......@@ -14,7 +14,7 @@ static void print_help()
// --------------------------------------------------------------------------
int main( int argc, const char **argv )
{
/*
VTypes::F2 f2;
f2.raw.val = 2.345;
......@@ -58,8 +58,7 @@ int main( int argc, const char **argv )
cout << "-------------" << endl << endl;
// return 0;
*/
unsigned short v[4];
memset(v,0,sizeof(v));
......
extensions/ModbusSlave/MBSlave.cc
View file @ 07d7b048
......@@ -1490,7 +1490,6 @@ ModbusRTU::mbErrCode MBSlave::readInputStatus( ReadInputStatusMessage& query,
{
if( dlog.is_warn() )
dlog.warn() << myname << "(readInputStatus): " << ex << endl;
return ModbusRTU::erBadDataAddress;
}
catch( Exception& ex )
......
extensions/SharedMemory/SharedMemory.cc
View file @ 07d7b048
......@@ -4,6 +4,7 @@
#include "NCRestorer.h"
#include "SharedMemory.h"
#include "Extensions.h"
#include "ORepHelpers.h"
// -----------------------------------------------------------------------------
using namespace std;
using namespace UniSetTypes;
......@@ -55,11 +56,9 @@ SharedMemory::SharedMemory( ObjectId id, string datafile, std::string confname )
// ----------------------
buildHistoryList(cnode);
signal_change_value().connect(sigc::mem_fun(*this, &SharedMemory::updateHistory));
for( History::iterator i=hist.begin(); i!=hist.end(); ++i )
histmap[i->fuse_id].push_back(i);
// ----------------------
restorer = NULL;
NCRestorer_XML* rxml = new NCRestorer_XML(datafile);
......@@ -814,8 +813,7 @@ void SharedMemory::updateHistory( IOStateList::iterator& s_it, IOController* )
else if( s_it->second.type == UniversalIO::AI ||
s_it->second.type == UniversalIO::AO )
{
if( sm->sensor_type == UniversalIO::DigitalInput ||
sm->sensor_type == UniversalIO::DigitalOutput )
if( !it->fuse_use_val )
{
bool st = (bool)value;
......@@ -832,8 +830,7 @@ void SharedMemory::updateHistory( IOStateList::iterator& s_it, IOController* )
m_historySignal.emit( &(*it) );
}
}
else if( sm->sensor_type == UniversalIO::AnalogInput ||
sm->sensor_type == UniversalIO::AnalogOutput )
else
{
if( value == it->fuse_val )
{
......
extensions/SharedMemory/SharedMemory.h
View file @ 07d7b048
......@@ -432,8 +432,6 @@ class SharedMemory:
IOController_i::SensorInfo siPulsar;
int msecPulsar;
UniSetTypes::uniset_mutex act_mutex;
UniSetTypes::uniset_rwmutex mutex_act;
private:
......
extensions/UNetUDP/UNetExchange.cc
View file @ 07d7b048
......@@ -123,7 +123,6 @@ sender2(0)
if( dlog.is_info() )
dlog.info() << myname << "(init): init sender.. my node " << n_it.getProp("name") << endl;
sender = new UNetSender(h,p,shm,s_field,s_fvalue,ic);
sender->setSendPause(sendpause);
......@@ -254,7 +253,6 @@ sender2(0)
if( dlog.is_info() )
dlog.info() << myname << "(init): (node='" << n << "') add receiver "
<< h2 << ":" << p2 << endl;
UNetReceiver* r = new UNetReceiver(h,p,shm);
// на всякий принудительно разблокируем,
......@@ -627,7 +625,6 @@ void UNetExchange::askSensors( UniversalIO::UIOCommand cmd )
if( dlog.is_crit() )
dlog.crit() << err.str() << endl;
kill(SIGTERM,getpid()); // прерываем (перезапускаем) процесс...
throw SystemError(err.str());
}
......
extensions/include/Extensions.h
View file @ 07d7b048
......@@ -13,6 +13,9 @@ namespace UniSetExtensions
/*! Получение идентификатора объекта(процесса) разделяемой памяти */
UniSetTypes::ObjectId getSharedMemoryID();
/*! Получение времени для подтверждения "живости" */
int getHeartBeatTime();
xmlNode* findNode( xmlNode* node, const std::string& snode, const std::string& field );
xmlNode* getCalibrationsSection();
......
extensions/include/IOBase.h
View file @ 07d7b048
// $Id: IOBase.h,v 1.3 2009/01/23 23:56:54 vpashka Exp $
// -----------------------------------------------------------------------------
#ifndef IOBase_H_
#define IOBase_H_
......
extensions/include/MTR.h
View file @ 07d7b048
// --------------------------------------------------------------------------
//! \version $Id: MTR.h,v 1.1 2008/12/14 21:57:50 vpashka Exp $
// --------------------------------------------------------------------------
#ifndef _MTR_H_
#define _MTR_H_
......@@ -665,12 +664,13 @@ namespace MTR
T_Str16():sval(""){}
T_Str16( const ModbusRTU::ReadInputRetMessage& ret )
{
char c[16];
char c[17];
ModbusRTU::ModbusData data[8];
for( int i=0; i<8; i++ )
data[i] = ModbusRTU::SWAPSHORT(ret.data[i]);
memcpy(c,&data,sizeof(c));
memcpy(c,&data,16);
c[16] = '\0';
sval = std::string(c);
}
......@@ -694,11 +694,12 @@ namespace MTR
T_Str8():sval(""){}
T_Str8( const ModbusRTU::ReadInputRetMessage& ret )
{
char c[8];
char c[9];
ModbusRTU::ModbusData data[4];
for( int i=0; i<4; i++ )
data[i] = ModbusRTU::SWAPSHORT(ret.data[i]);
memcpy(c,&data,sizeof(c));
memcpy(c,&data,8);
c[8] = '\0';
sval = std::string(c);
}
......
extensions/include/SMInterface.h
View file @ 07d7b048
......@@ -58,7 +58,7 @@ class SMInterface
CORBA::Object_var oref;
UniSetTypes::ObjectId shmID;
UniSetTypes::ObjectId myid;
UniSetTypes::uniset_mutex shmMutex;
UniSetTypes::uniset_rwmutex shmMutex;
};
//--------------------------------------------------------------------------
......
extensions/include/UObject_SK.h
View file @ 07d7b048
// --------------------------------------------------------------------------
/*
DO NOT EDIT THIS FILE. IT IS AUTOGENERATED FILE.
......@@ -12,19 +13,19 @@
#ifndef UObject_SK_H_
#define UObject_SK_H_
// -----------------------------------------------------------------------------
#include <string>
#include "UniSetObject.h"
#include "LT_Object.h"
#include "UniXML.h"
#include "Trigger.h"
#include "SMInterface.h"
#include "DebugStream.h"
// -----------------------------------------------------------------------------
class UObject_SK:
public UniSetObject,
public LT_Object
{
public:
UObject_SK( UniSetTypes::ObjectId id, xmlNode* node=UniSetTypes::conf->getNode("UObject"),
UniSetTypes::ObjectId shmID = UniSetTypes::DefaultObjectId );
UObject_SK( UniSetTypes::ObjectId id, xmlNode* node=UniSetTypes::conf->getNode("UObject"), const std::string& argprefix="" );
UObject_SK();
virtual ~UObject_SK();
......@@ -39,27 +40,45 @@ class UObject_SK:
DebugStream dlog;
void init_dlog(DebugStream& dlog);
void updateValues();
void setInfo( UniSetTypes::ObjectId code, bool state );
// Используемые идентификаторы
// Используемые идентификаторы сообщений
// Текущее значение и предыдущее значение
// --- public variables ---
// --- end of public variables ---
protected:
// --- protected variables ---
// ---- end of protected variables ----
virtual void callback();
virtual void processingMessage( UniSetTypes::VoidMessage* msg );
virtual void sysCommand( UniSetTypes::SystemMessage* sm );
virtual void askSensors( UniversalIO::UIOCommand cmd );
virtual void sensorInfo( UniSetTypes::SensorMessage* sm ){};
virtual void timerInfo( UniSetTypes::TimerMessage* tm ){};
virtual void askSensors( UniversalIO::UIOCommand cmd ){}
virtual void sensorInfo( UniSetTypes::SensorMessage* sm ){}
virtual void timerInfo( UniSetTypes::TimerMessage* tm ){}
virtual void sigterm( int signo );
virtual bool activateObject();
virtual void testMode( bool state );
void updatePreviousValues();
void checkSensors();
void updateOutputs( bool force );
bool checkTestMode();
void preAskSensors( UniversalIO::UIOCommand cmd );
void preSensorInfo( UniSetTypes::SensorMessage* sm );
void preTimerInfo( UniSetTypes::TimerMessage* tm );
void waitSM( int wait_msec );
void waitSM( int wait_msec, UniSetTypes::ObjectId testID = UniSetTypes::DefaultObjectId );
void resetMsg();
Trigger trResetMsg;
......@@ -71,24 +90,37 @@ class UObject_SK:
int sleep_msec; /*!< пауза между итерациями */
bool active;
bool isTestMode;
Trigger trTestMode;
UniSetTypes::ObjectId idTestMode_S; /*!< идентификатор для флага тестовго режима (для всех) */
UniSetTypes::ObjectId idLocalTestMode_S; /*!< идентификатор для флага тестовго режима (для данного узла) */
bool in_TestMode_S;
bool in_LocalTestMode_S;
UniSetTypes::ObjectId smTestID; /*!< идентификатор датчика для тестирования готовности SM */
// управление датчиком "сердцебиения"
PassiveTimer ptHeartBeat; /*! < период "сердцебиения" */
UniSetTypes::ObjectId idHeartBeat; /*! < идентификатор датчика (AI) "сердцебиения" */
int maxHeartBeat; /*! < сохраняемое значение */
xmlNode* confnode;
SMInterface shm;
/*! получить числовое свойство из конф. файла по привязанной confnode */
int getIntProp(const std::string& name) { return UniSetTypes::conf->getIntProp(confnode, name); }
/*! получить текстовое свойство из конф. файла по привязанной confnode */
inline const std::string getProp(const std::string& name) { return UniSetTypes::conf->getProp(confnode, name); }
int smReadyTimeout; /*!< время ожидания готовности SM */
bool activated;
int activateTimeout; /*!< время ожидания готовности UniSetObject к работе */
PassiveTimer ptStartUpTimeout; /*!< время на блокировку обработки WatchDog, если недавно был StartUp */
int askPause; /*!< пауза между неудачными попытками заказать датчики */
IOController_i::SensorInfo si;
private:
IOController_i::SensorInfo si;
// --- private variables ---
// --- end of private variables ---
bool end_private; // вспомогательное поле (для внутреннего использования при генерировании кода)
};
// -----------------------------------------------------------------------------
......
extensions/include/VTypes.h
View file @ 07d7b048
......@@ -16,15 +16,12 @@ namespace VTypes
{
vtUnknown,
vtF2, /*!< двойное слово float(4 байта). В виде строки задаётся как \b "F2". */
vtF2r, /*!< двойное слово float(4 байта). С перевёрнутой (reverse) последовательностью слов. \b "F2r". */
vtF4, /*!< 8-х байтовое слово (double). В виде строки задаётся как \b "F4". */
vtByte, /*!< байт. В виде строки задаётся как \b "byte". */
vtUnsigned, /*!< беззнаковое целое (2 байта). В виде строки задаётся как \b "unsigned". */
vtSigned, /*!< знаковое целое (2 байта). В виде строки задаётся как \b "signed". */
vtI2, /*!< целое (4 байта). В виде строки задаётся как \b "I2".*/
vtI2r, /*!< целое (4 байта). С перевёрнутой (reverse) последовательностью слов. В виде строки задаётся как \b "I2r".*/
vtU2, /*!< беззнаковое целое (4 байта). В виде строки задаётся как \b "U2".*/
vtU2r /*!< беззнаковое целое (4 байта). С перевёрнутой (reverse) последовательностью слов. В виде строки задаётся как \b "U2r".*/
vtU2 /*!< беззнаковое целое (4 байта). В виде строки задаётся как \b "U2".*/
};
std::ostream& operator<<( std::ostream& os, const VType& vt );
......@@ -70,24 +67,6 @@ namespace VTypes
F2mem raw;
};
// --------------------------------------------------------------------------
class F2r:
public F2
{
public:
// ------------------------------------------
// конструкторы на разные случаи...
F2r(){}
F2r( float f ):F2(f){}
F2r( const ModbusRTU::ModbusData* data, int size ):F2(data,size)
{
std::swap(raw.v[0],raw.v[1]);
}
~F2r(){}
};
// --------------------------------------------------------------------------
class F4
{
public:
......@@ -260,21 +239,6 @@ namespace VTypes
I2mem raw;
};
// --------------------------------------------------------------------------
class I2r:
public I2
{
public:
I2r(){}
I2r( int v ):I2(v){}
I2r( const ModbusRTU::ModbusData* data, int size ):I2(data,size)
{
std::swap(raw.v[0],raw.v[1]);
}
~I2r(){}
};
// --------------------------------------------------------------------------
class U2
{
public:
......@@ -310,21 +274,6 @@ namespace VTypes
U2mem raw;
};
// --------------------------------------------------------------------------
class U2r:
public U2
{
public:
U2r(){}
U2r( int v ):U2(v){}
U2r( const ModbusRTU::ModbusData* data, int size ):U2(data,size)
{
std::swap(raw.v[0],raw.v[1]);
}
~U2r(){}
};
// --------------------------------------------------------------------------
} // end of namespace VTypes
// --------------------------------------------------------------------------
......
extensions/lib/MTR.cc
View file @ 07d7b048
......@@ -432,25 +432,11 @@ bool send_param( ModbusRTUMaster* mb, DataMap& dmap, ModbusRTU::ModbusAddr addr,
// return false;
}
try
{
ModbusRTU::ModbusData dat = 1;
ModbusRTU::WriteSingleOutputRetMessage ret = mb->write06( addr, regUpdateConfiguration, dat);
if( ret.start == regUpdateConfiguration && ret.data == dat )
{
ModbusRTU::WriteSingleOutputRetMessage ret = mb->write06(addr,regUpdateConfiguration,1);
if( verb )
cout << "(mtr-setup): save parameters " << endl;
return true;
}
}
catch( ModbusRTU::mbException& ex )
{
}
if( verb )
cout << "(mtr-setup): not save parameters " << endl;
return false;
return true;
}
// ------------------------------------------------------------------------------------------
MTR::MTRError update_configuration( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr slaveaddr,
......@@ -568,76 +554,5 @@ std::ostream& operator<<(std::ostream& os, MTR::T_Str16& t )
return os << t.sval;
}
// ------------------------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& os, MTR::T1& t )
{
return os << t.val;
}
std::ostream& operator<<(std::ostream& os, MTR::T2& t )
{
return os << t.val;
}
std::ostream& operator<<(std::ostream& os, MTR::T3& t )
{
return os << (long)(t);
}
std::ostream& operator<<(std::ostream& os, MTR::T4& t )
{
return os << t.sval;
}
std::ostream& operator<<(std::ostream& os, MTR::T5& t )
{
return os << t.raw.u2.val << " * 10^" << (int)t.raw.u2.exp
<< " [" << t.val << "]";
}
std::ostream& operator<<(std::ostream& os, MTR::T6& t )
{
return os << t.raw.u2.val << " * 10^" << (int)t.raw.u2.exp
<< " [" << t.val << "]";
}
std::ostream& operator<<(std::ostream& os, MTR::T7& t )
{
return os << t.val
<< " [" << ( t.raw.u2.ic == 0xFF ? "CAP" : "IND" ) << "|"
<< ( t.raw.u2.ie == 0xFF ? "EXP" : "IMP" ) << "]";
}
std::ostream& operator<<(std::ostream& os, MTR::T8& t )
{
return os << setfill('0') << hex
<< setw(2) << t.hour() << ":" << setw(2) << t.min()
<< " " << setw(2) << t.day() << "/" << setw(2) << t.mon();
}
std::ostream& operator<<(std::ostream& os, MTR::T9& t )
{
return os << setfill('0') << hex
<< setw(2) << t.hour() << ":" << setw(2) << t.min()
<< ":" << setw(2) << t.sec() << "." << setw(2) << t.ssec();
}
std::ostream& operator<<(std::ostream& os, MTR::T10& t )
{
return os << setfill('0') << dec
<< setw(4) << t.year() << "/" << setw(2) << t.mon()
<< "/" << setw(2) << t.day();
}
std::ostream& operator<<(std::ostream& os, MTR::T16& t )
{
return os << t.fval;
}
std::ostream& operator<<(std::ostream& os, MTR::T17& t )
{
return os << t.fval;
}
std::ostream& operator<<(std::ostream& os, MTR::F1& t )
{
return os << t.raw.val;
}
std::ostream& operator<<(std::ostream& os, MTR::T_Str8& t )
{
return os << t.sval;
}
std::ostream& operator<<(std::ostream& os, MTR::T_Str16& t )
{
return os << t.sval;
}
// ------------------------------------------------------------------------------------------
} // end of namespace MTR
// -----------------------------------------------------------------------------
extensions/lib/UObject_SK.cc
View file @ 07d7b048
......@@ -188,9 +188,10 @@ bool UObject_SK::alarm( UniSetTypes::ObjectId _code, bool _state )
ulog.level1(false) << endl;
}
if( ulog.is_level1() )
ulog.level1() << " not found MessgeOID?!!" << endl;
return false;
}
// -----------------------------------------------------------------------------
......
extensions/lib/VTypes.cc
View file @ 07d7b048
......@@ -18,8 +18,6 @@ VType str2type( const std::string& s )
return vtByte;
if( s == "F2" || s == "f2" )
return vtF2;
if( s == "F2r" || s == "f2r" )
return vtF2r;
if( s == "F4" || s == "f4" )
return vtF4;
if( s == "Unsigned" || s == "unsigned" )
......@@ -28,12 +26,8 @@ VType str2type( const std::string& s )
return vtSigned;
if( s == "I2" || s == "i2" )
return vtI2;
if( s == "I2r" || s == "i2r" )
return vtI2r;
if( s == "U2" || s == "u2" )
return vtU2;
if( s == "U2r" || s == "u2r" )
return vtU2r;
return vtUnknown;
}
......@@ -44,8 +38,6 @@ string type2str( VType t )
return "Byte";
if( t == vtF2 )
return "F2";
if( t == vtF2r )
return "F2r";
if( t == vtF4 )
return "F4";
if( t == vtUnsigned )
......@@ -54,12 +46,8 @@ string type2str( VType t )
return "Signed";
if( t == vtI2 )
return "I2";
if( t == vtI2r )
return "I2r";
if( t == vtU2 )
return "U2";
if( t == vtU2r )
return "U2r";
return "vtUnknown";
}
......@@ -68,7 +56,7 @@ int wsize( VType t )
{
if( t == vtByte )
return Byte::wsize();
if( t == vtF2 || t == vtF2r )
if( t == vtF2 )
return F2::wsize();
if( t == vtF4 )
return F4::wsize();
......@@ -76,9 +64,9 @@ int wsize( VType t )
return Unsigned::wsize();
if( t == vtSigned )
return Signed::wsize();
if( t == vtI2 || t == vtI2r )
if( t == vtI2 )
return I2::wsize();
if( t == vtU2 || t == vtU2r )
if( t == vtU2 )
return U2::wsize();
return 1;
......
extensions/tests/SMemoryTest/TestProc.cc 0 → 100644
View file @ 07d7b048
#include <iomanip>
#include "Exceptions.h"
#include "TestProc.h"
// -----------------------------------------------------------------------------
using namespace std;
using namespace UniSetTypes;
// -----------------------------------------------------------------------------
TestProc::TestProc( UniSetTypes::ObjectId id, xmlNode* confnode ):
TestProc_SK( id, confnode ),
state(false)
{
loglevels.push_back(Debug::INFO);
loglevels.push_back(Debug::WARN);
loglevels.push_back(Debug::CRIT);
loglevels.push_back(Debug::LEVEL1);
loglevels.push_back(Debug::LEVEL2);
loglevels.push_back( Debug::type(Debug::LEVEL2 | Debug::INFO) );
loglevels.push_back( Debug::type(Debug::LEVEL2 | Debug::INFO | Debug::WARN | Debug::CRIT) );
lit = loglevels.begin();
out_log_c = (*lit);
}
// -----------------------------------------------------------------------------
TestProc::~TestProc()
{
}
// -----------------------------------------------------------------------------
TestProc::TestProc():
state(false)
{
cerr << ": init failed!!!!!!!!!!!!!!!"<< endl;
throw Exception();
}
// -----------------------------------------------------------------------------
void TestProc::step()
{
}
// -----------------------------------------------------------------------------
void TestProc::sysCommand( UniSetTypes::SystemMessage* sm )
{
TestProc_SK::sysCommand(sm);
if( sm->command == SystemMessage::StartUp || sm->command == SystemMessage::WatchDog )
{
askTimer(tmCheck,checkTime);
askTimer(tmCheckWorking,checkWorkingTime);
askTimer(tmLogControl,checkLogTime);
// В начальный момент времени блокирующий датчик =0, поэтому d2_check_s должен быть равен depend_off_value (-50).
cerr << myname << "(startup): check init depend: " << ( getValue(d2_check_s) == -50 ? "OK" : "FAIL" ) << endl;
}
}
// -----------------------------------------------------------------------------
void TestProc::sensorInfo( SensorMessage *sm )
{
/*
dlog.level2() << myname << "(sensorInfo): id=" << sm->id << " val=" << sm->value
<< " " << timeToString(sm->sm_tv_sec,":")
<< "(" << setw(6) << sm->sm_tv_usec << "): "
<< endl;
*/
if( sm->id == on_s )
{
if( sm->value )
{
cerr << myname << "(sensorInfo): START WORKING.." << endl;
askTimer(tmChange,changeTime);
}
else
{
askTimer(tmChange,0);
cerr << myname << "(sensorInfo): STOP WORKING.." << endl;
}
}
else if( sm->id == check_undef_s )
{
cerr << myname << "(sensorInfo): CHECK UNDEFINED STATE ==> " << (sm->undefined==undef ? "OK" : "FAIL") << endl;
}
}
// -----------------------------------------------------------------------------
void TestProc::timerInfo( TimerMessage *tm )
{
if( tm->id == tmChange )
{
state^=true;
out_lamp_c = ( state ? lmpBLINK : lmpOFF );
dlog.level2() << myname << ": state=" << state << " lmp=" << out_lamp_c << endl;
askTimer(tmCheckWorking,checkTime); // reset timer
}
else if( tm->id == tmCheckWorking )
cerr << myname << ": WORKING FAIL!" << endl;
else if( tm->id == tmCheck )
{
cerr << endl << endl << "--------" << endl;
test_depend();
test_undefined_state();
test_thresholds();
test_loglevel();
}
else if( tm->id == tmLogControl )
{
cerr << endl;
cerr << "======= TEST LOG PRINT ======" << endl;
cerr << "LOGLEVEL: [" << (int)(*lit) << "] " << (*lit) << endl;
for( std::vector<Debug::type>::iterator it=loglevels.begin(); it!=loglevels.end(); ++it )
dlog[*it] << myname << ": test log print..." << endl;
cerr << "======= END LOG PRINT ======" << endl;
}
}
// -----------------------------------------------------------------------------
void TestProc::test_depend()
{
cerr << myname << ": Check depend..." << endl;
long test_val = 100;
// set depend 0...
setValue(depend_c,0);
setValue(set_d1_check_s,test_val);
setValue(set_d2_check_s,test_val);
cerr << myname << ": check depend OFF: d1: " << ( getValue(d1_check_s) == 0 ? "OK" : "FAIL" ) << endl;
cerr << myname << ": check depend OFF: d2: " << ( getValue(d2_check_s) == -50 ? "OK" : "FAIL" ) << endl;
// set depend 1
setValue(depend_c,1);
cerr << myname << ": check depend ON: d1: " << ( getValue(d1_check_s) == test_val ? "OK" : "FAIL" ) << endl;
cerr << myname << ": check depend ON: d2: " << ( getValue(d2_check_s) == test_val ? "OK" : "FAIL" ) << endl;
}
// -----------------------------------------------------------------------------
void TestProc::test_undefined_state()
{
// ---------------- Проверка выставления неопределённого состояния ---------------------
cerr << myname << ": Check undef state..." << endl;
undef ^= true;
si.id = undef_c;
si.node = conf->getLocalNode();
cerr << myname << ": set undefined=" << undef << endl;
ui.setUndefinedState( si, undef, getId() );
}
// -----------------------------------------------------------------------------
void TestProc::test_thresholds()
{
// ---------------- Проверка работы порогов ---------------------
cerr << myname << ": Check thresholds..." << endl;
setValue(t_set_c,0);
cerr << myname << ": check threshold OFF value: " << ( getValue(t_check_s) == 0 ? "OK" : "FAIL" ) << endl;
setValue(t_set_c,378);
cerr << myname << ": check threshold ON value: " << ( getValue(t_check_s) == 1 ? "OK" : "FAIL" ) << endl;
cerr << myname << ": ask threshold and check.. " << endl;
try
{
setValue(t_set_c, 0);
UniSetTypes::ThresholdId tid = 100;
ui.askThreshold( t_set_c, tid, UniversalIO::UIONotify, 10, 20 );
IONotifyController_i::ThresholdInfo ti = ui.getThresholdInfo(t_set_c,tid);
cerr << myname << ": ask OFF threshold: " << ( ti.state == IONotifyController_i::NormalThreshold ? "OK" : "FAIL" ) << endl;
setValue(t_set_c, 25);
ti = ui.getThresholdInfo(t_set_c,tid);
cerr << myname << ": ask ON threshold: " << ( ti.state == IONotifyController_i::HiThreshold ? "OK" : "FAIL" ) << endl;
}
catch( Exception& ex )
{
dlog.level2() << myname << ": CHECK 'ask and get threshold' FAILED: " << ex << endl;
}
}
// -----------------------------------------------------------------------------
void TestProc::test_loglevel()
{
lit++;
if( lit == loglevels.end() )
lit = loglevels.begin();
cerr << "SET LOGLEVEL: [" << (int)(*lit) << "] " << (*lit) << endl;
setValue(log_c, (*lit));
askTimer(tmLogControl,checkLogTime);
}
// -----------------------------------------------------------------------------
extensions/tests/SMemoryTest/TestProc.h 0 → 100644
View file @ 07d7b048
// -----------------------------------------------------------------------------
#ifndef TestProc_H_
#define TestProc_H_
// -----------------------------------------------------------------------------
#include <vector>
#include "Debug.h"
#include "TestProc_SK.h"
// -----------------------------------------------------------------------------
class TestProc:
public TestProc_SK
{
public:
TestProc( UniSetTypes::ObjectId id, xmlNode* confnode = UniSetTypes::conf->getNode("TestProc") );
virtual ~TestProc();
protected:
TestProc();
enum Timers
{
tmChange,
tmCheckWorking,
tmCheck,
tmLogControl
};
virtual void step();
virtual void sensorInfo( UniSetTypes::SensorMessage *sm );
virtual void timerInfo( UniSetTypes::TimerMessage *tm );
virtual void sysCommand( UniSetTypes::SystemMessage* sm );
void test_depend();
void test_undefined_state();
void test_thresholds();
void test_loglevel();
private:
bool state;
bool undef;
std::vector<Debug::type> loglevels;
std::vector<Debug::type>::iterator lit;
};
// -----------------------------------------------------------------------------
#endif // TestProc_H_
// -----------------------------------------------------------------------------
extensions/tests/SMemoryTest/stop.sh 0 → 120000
View file @ 07d7b048
../../../Utilities/scripts/uniset-stop.sh
\ No newline at end of file
extensions/tests/SMemoryTest/uniset-functions.sh 0 → 120000
View file @ 07d7b048
../../../Utilities/scripts/uniset-functions.sh
\ No newline at end of file
extensions/tests/SMemoryTest/uniset-start.sh 0 → 120000
View file @ 07d7b048
../../../Utilities/scripts/uniset-start.sh
\ No newline at end of file
include/ComPort.h
View file @ 07d7b048
......@@ -82,9 +82,9 @@ public:
void setCharacterSize(CharacterSize);
void setStopBits(StopBits sBit);
virtual void setTimeout( int msec );
inline int getTimeout(){ return uTimeout/1000; } // msec
void setWaiting( bool waiting );
virtual void setTimeout(int timeout);
void setWaiting(bool waiting);
inline int getTimeout(){ return uTimeout*1000; } // msec
virtual unsigned char receiveByte();
virtual void sendByte(unsigned char x);
......@@ -97,8 +97,6 @@ public:
virtual void cleanupChannel();
virtual void reopen();
virtual void reopen();
protected:
void openPort();
......
include/DelayTimer.h
View file @ 07d7b048
......@@ -34,7 +34,6 @@ class DelayTimer
onDelay(0),offDelay(0),waiting_on(false),waiting_off(false){}
DelayTimer( timeout_t on_msec, timeout_t off_msec ):prevState(false),state(false),
onDelay(on_msec),offDelay(off_msec),waiting_on(false),waiting_off(false)
{
}
......@@ -45,33 +44,25 @@ class DelayTimer
{
onDelay = on_msec;
offDelay = off_msec;
waiting_on = false;
waiting_off = false;
state = false;
}
// запустить часы (заново)
inline void reset()
{
pt.reset();
waiting_on = false;
waiting_off = false;
state = false;
}
inline bool check( bool st )
{
if( waiting_off )
{
if( pt.checkTime() )
if( !st && pt.checkTime() )
{
waiting_off = false;
if( !st )
state = false;
return state;
}
else if( st != prevState && !st )
else if( st != prevState )
pt.reset();
prevState = st;
......@@ -80,16 +71,13 @@ class DelayTimer
if( waiting_on )
{
if( pt.checkTime() )
if( st && pt.checkTime() )
{
waiting_on = false;
if( st )
state = true;
else
return state;
}
else if( st != prevState && st )
else if( st != prevState )
pt.reset();
prevState = st;
......
include/MessageType.h
View file @ 07d7b048
......@@ -81,6 +81,10 @@ namespace UniSetTypes
class VoidMessage : public Message
{
public:
// для оптимизации, делаем конструктор который не будет инициализировать свойства класса
// это необходимо для VoidMessage, который конструируется при помощи memcpy
VoidMessage( int dummy ):Message(dummy){}
VoidMessage( const TransportMessage& tm );
VoidMessage();
inline bool operator < ( const VoidMessage& msg ) const
......
include/NCRestorer.h
View file @ 07d7b048
......@@ -175,7 +175,7 @@ class NCRestorer_XML:
std::string t_filterValue;
std::string fname;
UniXML uxml;
UniXML* uxml;
ReaderSlot rtslot;
NCReaderSlot ncrslot;
......
include/PassiveTimer.h
View file @ 07d7b048
......@@ -84,6 +84,7 @@ class PassiveTimer:
public:
PassiveTimer();
PassiveTimer( timeout_t timeMS ); /*!< установить таймер */
~PassiveTimer();
virtual bool checkTime(); /*!< проверка наступления заданного времени */
......
include/RepositoryAgent.h
View file @ 07d7b048
......@@ -18,44 +18,47 @@
*/
// --------------------------------------------------------------------------
/*! \file
* \brief Реализация RepositoryAgent
* \author Pavel Vainerman
*/
// --------------------------------------------------------------------------
#ifndef RepositoryAgent_H_
#define RepositoryAgent_H_
#ifndef ProxyManager_H_
#define ProxyManager_H_
//---------------------------------------------------------------------------
#include "RepositoryAgent_i.hh"
#include "BaseProcess_i.hh"
#include "BaseProcess.h"
#include "UniSetTypes.h"
#include "ObjectIndex.h"
//----------------------------------------------------------------------------------------
/*! \class RepositoryAgent
*/
class RepositoryAgent:
public POA_RepositoryAgent_i,
public BaseProcess
{
public:
#include <map>
#include "UniSetObject.h"
RepositoryAgent( ObjectId id, const UniSetTypes::ObjectInfo *pObjectsMap );
~RepositoryAgent();
//----------------------------------------------------------------------------
class PassiveObject;
//----------------------------------------------------------------------------
/*! \class ProxyManager
* Менеджер пассивных объектов, который выступает вместо них во всех внешних связях....
*/
class ProxyManager:
public UniSetObject
{
// virtual void registration(const char* name, ::CORBA::Object_ptr ref);
// virtual void unregistration(const char* name, ::CORBA::Object_ptr ref);
public:
ProxyManager( UniSetTypes::ObjectId id );
~ProxyManager();
virtual CORBA::Object_ptr resolve(const char* name);
virtual CORBA::Object_ptr resolveid( UniSetTypes::ObjectId id);
void attachObject( PassiveObject* po, UniSetTypes::ObjectId id );
void detachObject( UniSetTypes::ObjectId id );
virtual void execute();
UInterface* uin;
protected:
RepositoryAgent();
ObjectIndex oind;
ProxyManager();
virtual void processingMessage( UniSetTypes::VoidMessage* msg );
virtual void allMessage( UniSetTypes::VoidMessage* msg );
virtual bool activateObject();
virtual bool disactivateObject();
private:
typedef std::map<UniSetTypes::ObjectId, PassiveObject*> PObjectMap;
PObjectMap omap;
};
#endif
//----------------------------------------------------------------------------------------
#endif // ProxyManager
//----------------------------------------------------------------------------------------
include/ThreadCreator.h
View file @ 07d7b048
......@@ -25,7 +25,8 @@
#ifndef ThreadCreator_h_
#define ThreadCreator_h_
//----------------------------------------------------------------------------------------
#include "PosixThread.h"
#include <cc++/thread.h>
#include <sys/resource.h>
//----------------------------------------------------------------------------------------
/*! \class ThreadCreator
* Шаблон для создания потоков с указанием функции вызова.
......@@ -83,78 +84,119 @@
//----------------------------------------------------------------------------------------
template<class ThreadMaster>
class ThreadCreator:
protected PosixThread
public ost::PosixThread
{
public:
/*! прототип функции вызова */
typedef void(ThreadMaster::* Action)(void);
pthread_t start();
pthread_t getTID(){ return PosixThread::getTID(); }
ThreadCreator( ThreadMaster* m, Action a );
~ThreadCreator();
inline pid_t getTID(){ return pid; }
/*! \return 0 - sucess */
int setPriority( int prior );
inline void stop()
/*! \return < 0 - fail */
int getPriority();
void stop();
inline void setName( const std::string& name )
{
PosixThread::stop();
ost::PosixThread::setName( name.c_str() );
}
inline void kill( int signo ) /*!< послать сигнал signo */
inline void setName( const char* name )
{
PosixThread::thrkill(signo);
ost::PosixThread::setName( name );
}
inline void setPriority( int priority )
inline void setCancel( ost::Thread::Cancel mode )
{
PosixThread::setPriority(priority);
ost::PosixThread::setCancel(mode);
}
inline void setPriority( int priority )
inline void setFinalAction( ThreadMaster* m, Action a )
{
PosixThread::setPriority(priority);
finm = m;
finact = a;
}
ThreadCreator( ThreadMaster* m, Action a );
~ThreadCreator();
inline void setInitialAction( ThreadMaster* m, Action a )
{
initm = m;
initact = a;
}
protected:
virtual void work(); /*!< Функция выполняемая в потоке */
virtual void run();
virtual void final()
{
if( finm )
(finm->*finact)();
}
virtual void initial()
{
if( initm )
(initm->*initact)();
}
private:
ThreadCreator();
pid_t pid;
ThreadMaster* m;
Action act;
ThreadMaster* finm;
Action finact;
ThreadMaster* initm;
Action initact;
};
//----------------------------------------------------------------------------------------
template <class ThreadMaster>
ThreadCreator<ThreadMaster>::ThreadCreator( ThreadMaster* m, Action a ):
pid(-1),
m(m),
act(a)
act(a),
finm(0),
finact(0),
initm(0),
initact(0)
{
}
//----------------------------------------------------------------------------------------
template <class ThreadMaster>
void ThreadCreator<ThreadMaster>::work()
void ThreadCreator<ThreadMaster>::run()
{
pid = getpid();
if(m)
(m->*act)();
// PosixThread::stop()
}
//----------------------------------------------------------------------------------------
template <class ThreadMaster>
pthread_t ThreadCreator<ThreadMaster>::start()
void ThreadCreator<ThreadMaster>::stop()
{
PosixThread::start( static_cast<PosixThread*>(this) );
return getTID();
terminate();
}
//----------------------------------------------------------------------------------------
template <class ThreadMaster>
ThreadCreator<ThreadMaster>::ThreadCreator():
pid(-1),
m(0),
act(0)
act(0),
finm(0),
finact(0),
initm(0),
initact(0)
{
}
//----------------------------------------------------------------------------------------
......@@ -163,4 +205,16 @@ ThreadCreator<ThreadMaster>::~ThreadCreator()
{
}
//----------------------------------------------------------------------------------------
template <class ThreadMaster>
int ThreadCreator<ThreadMaster>::setPriority( int prior )
{
return setpriority(PRIO_PROCESS, pid, prior );
}
//----------------------------------------------------------------------------------------
template <class ThreadMaster>
int ThreadCreator<ThreadMaster>::getPriority()
{
return getpriority(PRIO_PROCESS, pid);
}
//----------------------------------------------------------------------------------------
#endif // ThreadCreator_h_
include/modbus/ModbusClient.h
View file @ 07d7b048
......@@ -201,8 +201,6 @@ class ModbusClient
private:
};
// -------------------------------------------------------------------------
......
include/modbus/ModbusRTUSlaveSlot.h
View file @ 07d7b048
......@@ -57,12 +57,6 @@ class ModbusRTUSlaveSlot:
virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
ModbusRTU::MEIMessageRetRDI& reply );
virtual ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query,
ModbusRTU::DiagnosticRetMessage& reply );
virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
ModbusRTU::MEIMessageRetRDI& reply );
virtual ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query,
ModbusRTU::JournalCommandRetMessage& reply );
......
include/modbus/ModbusServer.h
View file @ 07d7b048
......@@ -159,23 +159,6 @@ class ModbusServer
ModbusRTU::MEIMessageRetRDI& reply )=0;
/*! Обработка запроса на запись данных (0x08).
\param query - запрос
\param reply - ответ. Заполняется в обработчике.
\return Результат обработки
*/
virtual ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query,
ModbusRTU::DiagnosticRetMessage& reply )=0;
/*! Обработка запроса 43(0x2B).
\param query - запрос
\param reply - ответ. Заполняется в обработчике.
\return Результат обработки
*/
virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
ModbusRTU::MEIMessageRetRDI& reply )=0;
/*! Обработка запроса по журналу (0x65)
\param query - запрос
\param reply - ответ. Заполняется в обработчике.
......
include/modbus/ModbusTCPMaster.h
View file @ 07d7b048
......@@ -6,7 +6,6 @@
#include <cc++/socket.h>
#include "ModbusTypes.h"
#include "ModbusClient.h"
#include "UTCPStream.h"
// -------------------------------------------------------------------------
/*! Modbus TCP master interface */
class ModbusTCPMaster:
......@@ -43,12 +42,11 @@ class ModbusTCPMaster:
ModbusRTU::ModbusMessage& reply, timeout_t timeout );
private:
UTCPStream* tcp;
ost::TCPStream* tcp;
ModbusRTU::ModbusData nTransaction;
std::queue<unsigned char> qrecv;
PassiveTimer ptTimeout;
std::string iaddr;
int port;
bool force_disconnect;
};
// -------------------------------------------------------------------------
......
include/modbus/TCPCheck.h 0 → 100644
View file @ 07d7b048
#ifndef _TCPCheck_H_
#define _TCPCheck_H_
// -----------------------------------------------------------------------------
#include <cc++/socket.h>
#include "Mutex.h"
#include "ThreadCreator.h"
// -----------------------------------------------------------------------------
/*! Вспомогательный класс для проверки связи, реализованный через создание потока,
чтобы при проверке не было "зависания" при недоступности адреса.
Смысл: создаётся поток, в нём происходит проверка, а в вызвавший поток приостанавливается
на время timeout, по истечении которого созданный поток "принудительно"(в любом случае)
уничтожается..
*/
class TCPCheck
{
public:
TCPCheck();
~TCPCheck();
bool check( const std::string& _ip, int _port, timeout_t tout, timeout_t sleep_msec );
/*! \param iaddr - 'ip:port' */
bool check( const std::string& iaddr, timeout_t tout, timeout_t sleep_msec );
protected:
void check_thread();
inline void setResult( bool res )
{
UniSetTypes::uniset_rwmutex_wrlock l(m);
result = res;
}
inline bool getResult()
{
bool res = false;
{
UniSetTypes::uniset_rwmutex_rlock l(m);
res = result;
}
return res;
}
bool result;
std::string iaddr;
int tout_msec;
UniSetTypes::uniset_rwmutex m;
};
// -----------------------------------------------------------------------------
#endif // _TCPCheck_H_
// -----------------------------------------------------------------------------
python/lib/pyUniSet/UModbus.h
View file @ 07d7b048
......@@ -32,9 +32,10 @@ class UModbus
inline void setTimeout( int msec ){ tout_msec = msec; }
/* Если не указывать ip и порт, будут использованы, те
* чтобы были заданы в connect(). Если заданы другие ip и port,
* будет сделана переподключение..
/*! Универсальная функция для чтения регистров.
* Если не указывать ip и порт, будут использованы, те
* чтобы были заданы в UModbus::connect(). Если заданы другие ip и port,
* будет сделано переподключение..
*/
long mbread( int addr, int mbreg, int mbfunc,
const char* vtype, int nbit=-1,
......@@ -44,6 +45,11 @@ class UModbus
long getByte( int addr, int mbreg, int mbfunc=0x4 )throw(UException);
bool getBit( int addr, int mbreg, int mbfunc=0x2 )throw(UException);
/*! Функция записи регистров 0x06 или 0x10 задаётся параметром \a mbfunc.
* Если не указывать ip и порт, будут использованы, те
* чтобы были заданы в UModbus::connect(). Если заданы другие ip и port,
* будет сделана переподключение..
*/
void mbwrite( int addr, int mbreg, int val, int mbfunc, const char* ip=0, int port=-1 )throw(UException);
protected:
......
src/Communications/ComPort.cc
View file @ 07d7b048
......@@ -257,9 +257,9 @@ void ComPort::sendByte(unsigned char x)
}
// --------------------------------------------------------------------------------
// Lav: убрать, переделать в receiveBlock
void ComPort::setTimeout( int msec )
void ComPort::setTimeout(int timeout)
{
uTimeout = msec * 1000;
uTimeout=timeout;
}
// --------------------------------------------------------------------------------
// Lav: ситуация, когда отправлено меньше запрошенного, не типична и должна
......
src/Communications/ComPort485F.cc
View file @ 07d7b048
......@@ -73,10 +73,10 @@ ComPort485F::ComPort485F( string dev, int gpio_num, bool tmit_ctrl ):
}
}
// --------------------------------------------------------------------------------
void ComPort485F::setTimeout( int msec )
void ComPort485F::setTimeout(int timeout)
{
tout_msec = msec;
ComPort::setTimeout(msec);
tout_msec = timeout / 1000;
ComPort::setTimeout(timeout);
}
// --------------------------------------------------------------------------------
unsigned char ComPort485F::m_receiveByte( bool wait )
......
src/Communications/Modbus/ModbusRTUMaster.cc
View file @ 07d7b048
......@@ -35,7 +35,7 @@ ModbusRTUMaster::ModbusRTUMaster( const string dev, bool use485, bool tr_ctl ):
port->setCharacterSize(ComPort::CSize8);
port->setStopBits(ComPort::OneBit);
port->setWaiting(true);
port->setTimeout(replyTimeOut_ms);
port->setTimeout(replyTimeOut_ms*1000);
// port->setBlocking(false);
}
// -------------------------------------------------------------------------
......@@ -51,7 +51,7 @@ ModbusRTUMaster::ModbusRTUMaster( ComPort* com ):
port->setCharacterSize(ComPort::CSize8);
port->setStopBits(ComPort::OneBit);
port->setWaiting(true);
port->setTimeout(replyTimeOut_ms);
port->setTimeout(replyTimeOut_ms*1000);
// port->setBlocking(false);
}
// -------------------------------------------------------------------------
......@@ -116,7 +116,7 @@ int ModbusRTUMaster::getNextData( unsigned char* buf, int len )
void ModbusRTUMaster::setChannelTimeout( timeout_t msec )
{
if( port )
port->setTimeout(msec);
port->setTimeout(msec*1000);
}
// --------------------------------------------------------------------------------
mbErrCode ModbusRTUMaster::sendData( unsigned char* buf, int len )
......
src/Communications/Modbus/TCPCheck.cc 0 → 100644
View file @ 07d7b048
// -----------------------------------------------------------------------------
#include <sstream>
#include "UniSetTypes.h"
#include "PassiveTimer.h"
#include "modbus/TCPCheck.h"
// -----------------------------------------------------------------------------
using namespace std;
// -----------------------------------------------------------------------------
TCPCheck::TCPCheck():
iaddr(""),tout_msec(0)
{
}
// -----------------------------------------------------------------------------
TCPCheck::~TCPCheck()
{
}
// -----------------------------------------------------------------------------
bool TCPCheck::check( const std::string& ip, int port, timeout_t tout, timeout_t sleep_msec )
{
ostringstream s;
s << ip << ":" << port;
return check(s.str(), tout, sleep_msec);
}
// -----------------------------------------------------------------------------
bool TCPCheck::check( const std::string& _iaddr, timeout_t tout, timeout_t sleep_msec )
{
iaddr = iaddr;
tout_msec = tout;
setResult(false);
ThreadCreator<TCPCheck> t(this, &TCPCheck::check_thread);
t.setCancel(ost::Thread::cancelDeferred);
t.start();
PassiveTimer pt(tout);
while( !pt.checkTime() && t.isRunning() )
msleep(sleep_msec);
if( t.isRunning() ) // !getResult() )
t.stop();
return getResult();
}
// -----------------------------------------------------------------------------
void TCPCheck::check_thread()
{
setResult(false);
try
{
ost::Thread::setException(ost::Thread::throwException);
ost::TCPStream t(iaddr.c_str(),ost::Socket::IPV4,536,true,tout_msec);
setResult(true);
t.disconnect();
}
catch(...){}
}
// -----------------------------------------------------------------------------
src/Processes/IONotifyController.cc
View file @ 07d7b048
......@@ -333,7 +333,6 @@ void IONotifyController::localSetValue( IOController::IOStateList::iterator& li,
if( ulog.is_info() )
ulog.info() << err.str() << endl;
throw IOController_i::NameNotFound(err.str().c_str());
}
......@@ -382,7 +381,6 @@ void IONotifyController::localSetValue( IOController::IOStateList::iterator& li,
checkThreshold(li,si,true);
}
catch(...){}
>>>>>>> (2.0): Поменял механизм "зависимостей". Реализовал на освное сигналов(sigc), сменил формат. Теперь задаётся свойством depend='', depend_value='', depend_off_value=''
}
// ------------------------------------------------------------------------------------------
/*!
......
src/Processes/NCRestorer_XML.cc
View file @ 07d7b048
......@@ -53,21 +53,27 @@ c_filterField(""),
c_filterValue(""),
t_filterField(""),
t_filterValue(""),
fname(fname)
fname(fname),
uxml(0)
{
init(fname);
setItemFilter(f_field,f_value);
}
NCRestorer_XML::NCRestorer_XML():
fname("")
fname(""),
uxml(0)
{
}
// ------------------------------------------------------------------------------------------
NCRestorer_XML::~NCRestorer_XML()
{
uxml.close();
if( uxml)
{
uxml->close();
delete uxml;
}
}
// ------------------------------------------------------------------------------------------
void NCRestorer_XML::init( const std::string& fname )
......@@ -78,7 +84,10 @@ void NCRestorer_XML::init( const std::string& fname )
*/
try
{
uxml.open(fname);
if( fname == conf->getConfFileName() )
uxml = conf->getConfXML();
else
uxml = new UniXML(fname);
}
catch(UniSetTypes::NameNotFound& ex)
{
......@@ -175,11 +184,13 @@ void NCRestorer_XML::read( IONotifyController* ic, const string& fn )
// оптимизация (не загружаем второй раз xml-файл)
if( fname == conf->getConfFileName() && confxml )
read( ic, *confxml );
else if( uxml && uxml->isOpen() && uxml->filename == fn )
read(ic,*uxml);
else
{
uxml.close();
uxml.open(fname);
read(ic,uxml);
uxml->close();
uxml->open(fname);
read(ic,*uxml);
}
}
}
......
src/Various/MessageType.cc
View file @ 07d7b048
......@@ -58,7 +58,7 @@ TransportMessage Message::transport(const In &msg)
//--------------------------------------------------------------------------------------------
VoidMessage::VoidMessage( const TransportMessage& tm ):
Message(1) // вызываем dummy-конструктор
Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
{
assert(sizeof(VoidMessage)>=sizeof(UniSetTypes::RawDataOfTransportMessage));
memcpy(this,&tm.data,sizeof(tm.data));
......@@ -107,7 +107,8 @@ tid(UniSetTypes::DefaultThresholdId)
sm_tv_usec = tm.tv_usec;
}
SensorMessage::SensorMessage(const VoidMessage *msg)
SensorMessage::SensorMessage(const VoidMessage *msg):
Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
{
memcpy(this,msg,sizeof(*this));
assert(this->type == Message::SensorInfo);
......@@ -127,14 +128,15 @@ SystemMessage::SystemMessage(Command command, Priority priority, ObjectId consum
this->consumer = consumer;
}
SystemMessage::SystemMessage(const VoidMessage *msg)
SystemMessage::SystemMessage(const VoidMessage *msg):
Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
{
memcpy(this,msg,sizeof(*this));
assert(this->type == Message::SysCommand);
}
//--------------------------------------------------------------------------------------------
TimerMessage::TimerMessage():
id(UniSetTypes::DefaultTimerId)
id(UniSetTypes::DefaultTimerId)
{
type = Message::Timer;
}
......@@ -146,13 +148,15 @@ id(id)
this->consumer = cons;
}
TimerMessage::TimerMessage(const VoidMessage *msg)
TimerMessage::TimerMessage(const VoidMessage *msg):
Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
{
memcpy(this,msg,sizeof(*this));
assert(this->type == Message::Timer);
}
//--------------------------------------------------------------------------------------------
ConfirmMessage::ConfirmMessage( const VoidMessage *msg )
ConfirmMessage::ConfirmMessage( const VoidMessage *msg ):
Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
{
memcpy(this,msg,sizeof(*this));
assert(this->type == Message::Confirm);
......
tests/conftest.cc
View file @ 07d7b048
......@@ -51,6 +51,7 @@ int main(int argc, const char **argv)
UniversalIO::IOType t3=conf->getIOType("Input1_S");
cout << "**** check getIOType(name): for short name 'Input1_S': (" << t3 << ") " << ( t3 == UniversalIO::UnknownIOType ? "FAILED" : "OK" ) << endl;
int i1 = uni_atoi("-100");
cout << "**** check uni_atoi: '-100' " << ( ( i1 != -100 ) ? "FAILED" : "OK" ) << endl;
......
tests/ui.cc
View file @ 07d7b048
......@@ -49,11 +49,10 @@ int main( int argc, const char **argv )
<< " value=" << inf.value
<< " last changed: " << string(t_str) << endl;
cout << "check getValue: " << ui.getValue(id1) << endl;
cout << "check setValue: id='" << id1 << "' val=2" << endl;
ui.setValue(id1,2,DefaultObjectId);
cout << "OK" << endl;
cout << "check setValue: id='" << id1 << "' val=2 ...";
ui.setValue(id1,2);
cout << ( ui.getValue(id1) == 2 ? "OK" : "FAIL" ) << endl;
}
catch( Exception& ex )
{
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment