Skip to content

U
uniset2
Commit 1b6f351e authored by Pavel Vainerman's avatar Pavel Vainerman
Browse files
Options

Merge commit 'origin/newRTUExchange' into eterbook

Conflicts: extentions/SharedMemory/SharedMemory.cc
parents f7b192be 9263e5a0
Show whitespace changes
Inline Side-by-side
Showing with 1553 additions and 671 deletions
IDL/UniSetTypes/UniSetTypes_i.idl
View file @ 1b6f351e
......@@ -98,6 +98,7 @@
*/
enum IOTypes
{
UnknownIOType,
DigitalInput,
DigitalOutput,
AnalogInput,
......
conf/test.xml
View file @ 1b6f351e
......@@ -18,6 +18,11 @@
<DumpStateTime name="10"/><!-- [] -->
<SleepTickMS name="500"/><!-- [] -->
<ServicesSection name="Services"/>
<NameService host="localhost" port="2809"/>
<SizeOfMessageQueue name="2000"/>
<LocalIOR name="0"/>
<!-- Debug, logs -->
<UniSetDebug name="unideb" levels="crit,warn" file=""/>
......@@ -83,6 +88,8 @@
<HeartBeatTime time_msec="5000"/>
<IOControl name="IOControl" />
<ObjectsMap idfromfile="0">
<!--
'sensors'
......@@ -100,11 +107,38 @@
<!-- ************************ ********************** -->
<sensors name="Sensors">
<item name="Input1_S" textname=" 1" node="" iotype="DI" priority="Medium" default="1" />
<item name="Input2_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x04" mbreg="0x02" rs="2" />
<item name="Input2_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x04" mbreg="0x02" rs="1" />
<item name="Input3_S" textname=" 3" node="" iotype="DI" priority="Medium" mbtcp="1" mbaddr="0x02" mbfunc="0x04" mbreg="0x02"/>
<item name="Input4_S" textname=" 4" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x02" mbfunc="0x04" mbreg="0x02" rs="2" />
<item name="Input5_S" textname=" 5" node="" iotype="DI" priority="Medium" udp="2"/>
<item name="Input6_S" textname=" 6" node="" iotype="DI" priority="Medium" udp="2">
<item name="Input4_S" textname=" 4" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x02" mbfunc="0x04" mbreg="0x05" rs="1" />
<item name="RS_Test1_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0x02" nbit="1" rs="1" />
<item name="RS_Test2_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0x02" nbit="2" rs="1" />
<item name="RS_Test3_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0x02" nbit="3" rs="1" />
<item name="RS_Test4_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0x02" nbit="4" rs="1" />
<item name="RS_Test5_S" textname=" 5" node="" iotype="DI" priority="Medium" mbtype="rtu188" mbaddr="0x03" jack="J1" channel="23" rs="1" />
<item name="RS_Test6_S" textname=" 5" node="" iotype="DI" priority="Medium" mbtype="rtu188" mbaddr="0x03" jack="J1" channel="23" rs="1" />
<item name="RS_Test7_S" textname=" 5" node="" iotype="DI" priority="Medium" mbtype="rtu188" mbaddr="0x04" jack="J1" channel="23" rs="1" />
<item name="RS_Test8_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0x05" rs="1" />
<item name="RS_Test9_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0x06" rs="1" />
<item name="RS_Test10_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0x07" rs="1" />
<item name="RS_Test11_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" vtype="F2" mbaddr="0x01" mbfunc="0x03" mbreg="0x08" rs="1" />
<item name="RS_Test12_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0xA" rs="1" />
<item name="RS_Test13_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0xB" rs="1" />
<item name="RS_Test14_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0xC" rs="1" />
<item name="RS_Test15_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0xD" rs="1" />
<item name="RS_Test16_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="mtr" mtrtype="F1" mbaddr="0x05" mbfunc="0x03" mbreg="0x10" rs="1" />
<item name="RS_Test17_S" textname=" 2" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x01" mbfunc="0x03" mbreg="0x10" rs="1" />
<item name="IO_Test1_S" textname="io test" node="" iotype="DO" priority="Medium" io="1"/>
<item name="IO_Test2_S" textname="io test" node="" iotype="DI" priority="Medium" io="1"/>
<item name="IO_Test3_S" textname="io test" node="" iotype="AO" priority="Medium" io="1"/>
<item name="IO_Test4_S" textname="io test" node="" iotype="AI" priority="Medium" io="1"/>
<item name="W_Test2_S" textname="io test" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x02" mbfunc="0x03" mbreg="0x3001" rs="wago" />
<item name="W_Test3_S" textname="io test" node="" iotype="DI" priority="Medium" mbtype="rtu" mbaddr="0x02" mbfunc="0x03" mbreg="0x3002" rs="wago" />
<item name="W_Test4_S" textname="io test" node="" iotype="AI" priority="Medium" mbtype="rtu" mbaddr="0x02" mbfunc="0x06" mbreg="0x3008" rs="wago" default="4"/>
<item name="Input6_S" textname=" 6" node="" iotype="DI" priority="Medium">
<depends>
<depend name="Input4_S"/>
</depends>
......
conf/uniset.spec
View file @ 1b6f351e
......@@ -2,7 +2,11 @@
Name: uniset
Version: 0.96
<<<<<<< HEAD:conf/uniset.spec
Release: eter6
=======
Release: eter9
>>>>>>> 6eb79ccca4b348cddaa393aae9cb34b9fcf2a001:conf/uniset.spec
Summary: UniSet
License: GPL
Group: Development/C++
......@@ -180,10 +184,14 @@ Libraries needed to develop for uniset extentions
%_bindir/%name-smviewer
%changelog
<<<<<<< HEAD:conf/uniset.spec
* Wed May 20 2009 Pavel Vainerman <pv@altlinux.ru> 0.96-eter5
=======
* Tue Apr 21 2009 Pavel Vainerman <pv@etersoft.ru> 0.96-eter6
- new build
* Tue Apr 21 2009 Pavel Vainerman <pv@etersoft.ru> 0.96-eter5
>>>>>>> 6eb79ccca4b348cddaa393aae9cb34b9fcf2a001:conf/uniset.spec
- new build
* Mon Apr 06 2009 Pavel Vainerman <pv@altlinux.ru> 0.96-eter4
......
extentions/IOControl/IOControl.cc
View file @ 1b6f351e
......@@ -56,7 +56,7 @@ IOControl::IOControl( UniSetTypes::ObjectId id, UniSetTypes::ObjectId icID,
UniXML_iterator it(cnode);
noCards = true;
for( unsigned int i=0; i<cards.size(); i++ )
for( unsigned int i=0; i=<cards.size(); i++ )
{
stringstream s1;
s1 << "--iodev" << i;
......
extentions/IOControl/IOControl.h
View file @ 1b6f351e
......@@ -68,9 +68,9 @@ class IOControl:
{}
short subdev; /*!< (UNIO) (. comedi_test /) */
short channel; /*!< (UNIO) [0...23] */
short ncard; /*!< [1|2]. 0 - */
int subdev; /*!< (UNIO) (. comedi_test /) */
int channel; /*!< (UNIO) [0...23] */
int ncard; /*!< [1|2]. 0 - */
/*!
0 - analog ref = analog ground
......
extentions/IOControl/create_links.sh 0 → 100755
View file @ 1b6f351e
#!/bin/sh
ln -s -f /usr/bin/uniset-stop.sh stop.sh
ln -s -f ../../conf/test.xml test.xml
extentions/IOControl/start_fg.sh 0 → 100755
View file @ 1b6f351e
#!/bin/sh
#ulimit -Sc 1000000000000
uniset-start.sh -f ./uniset-iocontrol --smemory-id SharedMemory \
--confile test.xml \
--io-name IOControl \
--io-polltime 100 \
--io-s-filter-field io \
--io-s-filter-value 1 \
--iodev1 /dev/null \
--iodev2 /dev/null \
--io-test-lamp RS_Test9_S \
--io-heartbeat-id AI_AS \
--io-sm-ready-test-sid RS_Test9_S \
--unideb-add-levels info,crit,warn,level9,system \
extentions/RTUExchange/RTUExchange.cc
View file @ 1b6f351e
// $Id: RTUExchange.cc,v 1.4 2009/01/23 23:56:54 vpashka Exp $
// -----------------------------------------------------------------------------
#include <cmath>
#include <sstream>
......@@ -12,8 +11,6 @@ using namespace UniSetExtentions;
// -----------------------------------------------------------------------------
RTUExchange::RTUExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, SharedMemory* ic ):
UniSetObject_LT(objId),
rsmap(100),
maxItem(0),
mb(0),
shm(0),
initPause(0),
......@@ -44,31 +41,19 @@ activated(false)
// ---------- init RS ----------
// UniXML_iterator it(cnode);
string dev = conf->getArgParam("--rs-dev",it.getProp("device"));
if( dev.empty() )
devname = conf->getArgParam("--rs-dev",it.getProp("device"));
if( devname.empty() )
throw UniSetTypes::SystemError(myname+"(RTUExchange): Unknown device..." );
string speed = conf->getArgParam("--rs-speed",it.getProp("speed"));
speed = conf->getArgParam("--rs-speed",it.getProp("speed"));
if( speed.empty() )
speed = "38400";
int recv_timeout = atoi(conf->getArgParam("--rs-recv-timeout",it.getProp("recv_timeout")).c_str());
recv_timeout = atoi(conf->getArgParam("--rs-recv-timeout",it.getProp("recv_timeout")).c_str());
mbregFromID = atoi(conf->getArgParam("--mbs-reg-from-id",it.getProp("reg_from_id")).c_str());
dlog[Debug::INFO] << myname << "(init): mbregFromID=" << mbregFromID << endl;
mb = new ModbusRTUMaster(dev);
if( !speed.empty() )
mb->setSpeed(speed);
mb->setLog(dlog);
if( recv_timeout > 0 )
mb->setTimeout(recv_timeout);
dlog[Debug::INFO] << myname << "(init): dev=" << dev << " speed=" << speed << endl;
// -------------------------------
polltime = atoi(conf->getArgParam("--rs-polltime",it.getProp("polltime")).c_str());
if( !polltime )
......@@ -83,8 +68,7 @@ activated(false)
if( shm->isLocalwork() )
{
readConfiguration();
rsmap.resize(maxItem);
dlog[Debug::INFO] << myname << "(init): rsmap size = " << rsmap.size() << endl;
rtuQueryOptimization(rmap);
}
else
ic->addReadItem( sigc::mem_fun(this,&RTUExchange::readItem) );
......@@ -97,7 +81,7 @@ activated(false)
if( sidHeartBeat == DefaultObjectId )
{
ostringstream err;
err << myname << ": 'HeartBeat' " << heart;
err << myname << ": ID not found ('HeartBeat') for " << heart;
dlog[Debug::CRIT] << myname << "(init): " << err.str() << endl;
throw SystemError(err.str());
}
......@@ -127,17 +111,11 @@ activated(false)
dlog[Debug::INFO] << myname << "(init): test_id=" << test_id << endl;
ai_polltime = atoi(conf->getArgParam("--aiPollTime").c_str());
if( ai_polltime > 0 )
aiTimer.setTiming(ai_polltime);
activateTimeout = atoi(conf->getArgParam("--activate-timeout").c_str());
if( activateTimeout<=0 )
activateTimeout = 20000;
int msec = atoi(conf->getArgParam("--rs-timeout",it.getProp("timeout")).c_str());
if( msec <=0 )
msec = 3000;
initMB();
xmlNode* respNode = conf->findNode(cnode,"RespondList");
if( respNode )
......@@ -147,157 +125,79 @@ activated(false)
{
for(;it1.getCurrent(); it1.goNext() )
{
RespondInfo ri;
ModbusRTU::ModbusAddr a = ModbusRTU::str2mbAddr(it1.getProp("addr"));
ri.id = conf->getSensorID(it1.getProp("respondSensor"));
if( ri.id == DefaultObjectId )
{
dlog[Debug::CRIT] << myname << ": not found ID for noRespondSensor=" << it1.getProp("respondSensor") << endl;
continue;
}
int tout = atoi(it1.getProp("timeout").c_str());
if( tout > 0 )
ri.ptTimeout.setTiming(tout);
else
ri.ptTimeout.setTiming(UniSetTimer::WaitUpTime);
ri.invert = atoi(it1.getProp("invert").c_str());
respMap[a] = ri;
initRespondInfo(rmap,a,it1);
}
}
}
printMap(rmap);
// abort();
}
// -----------------------------------------------------------------------------
RTUExchange::~RTUExchange()
{
// RTU...
for( RTUMap::iterator it=rtulist.begin(); it!=rtulist.end(); ++it )
for( RTUExchange::RTUDeviceMap::iterator it1=rmap.begin(); it1!=rmap.end(); ++it1 )
{
if( it->second )
if( it1->second->rtu )
{
delete it->second;
it->second = 0;
delete it1->second->rtu;
it1->second->rtu = 0;
}
RTUDevice* d(it1->second);
for( RTUExchange::RegMap::iterator it=d->regmap.begin(); it!=d->regmap.end(); ++it )
delete it->second;
delete it1->second;
}
delete mb;
delete shm;
}
// -----------------------------------------------------------------------------
void RTUExchange::waitSMReady()
{
// waiting for SM is ready...
int ready_timeout = atoi(conf->getArgParam("--rs-sm-ready-timeout","15000").c_str());
if( ready_timeout == 0 )
ready_timeout = 15000;
else if( ready_timeout < 0 )
ready_timeout = UniSetTimer::WaitUpTime;
if( !shm->waitSMready(ready_timeout,50) )
{
ostringstream err;
err << myname << "(waitSMReady): SharedMemory " << ready_timeout << " ";
dlog[Debug::CRIT] << err.str() << endl;
throw SystemError(err.str());
}
}
// -----------------------------------------------------------------------------
#if 0
void RTUExchange::execute()
void RTUExchange::initMB()
{
// waiting for SM is ready...
waitSMReady();
// shm->wait!!!
if( !shm->isLocalwork() )
readConfiguration();
rsmap.resize(maxItem);
dlog[Debug::INFO] << myname << "(init): rsmap size = " << rsmap.size() << endl;
PassiveTimer ptAct(activateTimeout);
while( !activated && !ptAct.checkTime() )
if( !file_exist(devname) )
{
cout << myname << "(execute): wait activate..." << endl;
msleep(300);
if( activated )
if( mb )
{
cout << myname << "(execute): activate OK.." << endl;
break;
}
delete mb;
mb=0;
}
if( !activated )
dlog[Debug::CRIT] << myname << "(execute): ************* don`t activate?! ************" << endl;
// ģ
// . activateObject() sysCommand()
{
// mutex
// mutex sysCommand activateObject
msleep(1500);
UniSetTypes::uniset_mutex_lock l(mutex_start, 15000);
return;
}
// ---------- init RS ----------
UniXML_iterator it(cnode);
string dev = conf->getArgParam("--rs-dev",it.getProp("device"));
if( dev.empty() )
throw UniSetTypes::SystemError(myname+"(RTUExchange): Unknown device..." );
string speed = conf->getArgParam("--rs-speed",it.getProp("speed"));
int recv_timeout = atoi(conf->getArgParam("--rs-recv-timeout",it.getProp("recv_timeout")).c_str());
string saddr = conf->getArgParam("--rs-my-addr",it.getProp("addr"));
ModbusRTU::ModbusAddr myaddr = ModbusRTU::str2mbAddr(saddr);
if( saddr.empty() )
myaddr = 0x01;
mb = new ModbusMaster(dev,myaddr);
mb = new ModbusRTUMaster(devname);
if( !speed.empty() )
mb->setSpeed(speed);
// mb->setLog(dlog);
if( recv_timeout > 0 )
mb->setTimeout(recv_timeout);
dlog[Debug::INFO] << myname << "(init): myaddr=" << ModbusRTU::addr2str(myaddr)
<< " dev=" << dev << " speed=" << speed << endl;
// -------------------------------
//
if( !force )
{
uniset_mutex_lock l(pollMutex,2000);
force = true;
poll();
force = false;
}
dlog[Debug::INFO] << myname << "(init): dev=" << devname << " speed=" << speed << endl;
}
// -----------------------------------------------------------------------------
void RTUExchange::waitSMReady()
{
// waiting for SM is ready...
int ready_timeout = atoi(conf->getArgParam("--rs-sm-ready-timeout","15000").c_str());
if( ready_timeout == 0 )
ready_timeout = 15000;
else if( ready_timeout < 0 )
ready_timeout = UniSetTimer::WaitUpTime;
while( activated )
{
try
{
step();
}
catch( UniSetTypes::Exception& ex)
{
cerr << myname << "(step): " << ex << std::endl;
}
catch(...)
if( !shm->waitSMready(ready_timeout,50) )
{
cerr << myname << "(step): catch ..." << std::endl;
}
msleep(polltime);
ostringstream err;
err << myname << "(waitSMReady): SharedMemory " << ready_timeout << " ";
dlog[Debug::CRIT] << err.str() << endl;
throw SystemError(err.str());
}
cerr << "************* execute FINISH **********" << endl;
}
#endif
// -----------------------------------------------------------------------------
void RTUExchange::timerInfo( TimerMessage *tm )
{
......@@ -328,338 +228,286 @@ void RTUExchange::step()
<< "(step): (hb) " << ex << std::endl;
}
}
for( RespondMap::iterator it=respMap.begin(); it!=respMap.end(); ++it )
{
try
{
bool set = it->second.invert ? !it->second.state : it->second.state;
shm->localSaveState(it->second.dit,it->second.id,set,getId());
}
catch(Exception& ex)
{
dlog[Debug::CRIT] << myname
<< "(step): (respond) " << ex << std::endl;
}
}
}
// -----------------------------------------------------------------------------
void RTUExchange::poll()
{
for( RTUMap::iterator it=rtulist.begin(); it!=rtulist.end(); ++it )
if( !mb )
{
if( !activated )
initMB();
return;
bool respOK = true;
try
{
cout << "poll RTU=(" << (int)it->second->getAddress()
<< ")" << ModbusRTU::addr2str(it->second->getAddress());
if( it->second )
{
mb->cleanupChannel();
it->second->poll(mb);
cout << " [OK] " << endl;
// cout << it->second << endl;
}
}
catch( ModbusRTU::mbException& ex )
for( RTUExchange::RTUDeviceMap::iterator it1=rmap.begin(); it1!=rmap.end(); ++it1 )
{
cout << " [ FAILED ] (" << ex << ")" << endl;
respOK = false;
}
RTUDevice* d(it1->second);
setRespond(it->second->getAddress(),respOK);
}
if( dlog.debugging(Debug::INFO) )
dlog[Debug::INFO] << myname << "(poll): ask addr=" << ModbusRTU::addr2str(d->mbaddr) << endl;
for( RSMap::iterator it=rsmap.begin(); it!=rsmap.end(); ++it )
if( d->dtype==RTUExchange::dtRTU188 )
{
if( !activated )
return;
if( it->mbaddr == 0 ) // || it->mbreg == 0 )
if( !d->rtu )
continue;
if( it->si.id == DefaultObjectId )
if( dlog.debugging(Debug::INFO) )
{
cerr << myname << "(poll): sid=DefaultObjectId?!" << endl;
continue;
dlog[Debug::INFO] << myname << "(pollRTU188): poll RTU188 "
<< " mbaddr=" << ModbusRTU::addr2str(d->mbaddr)
<< endl;
}
IOBase* ib = &(*it);
try
{
if( it->stype == UniversalIO::AnalogInput )
{
long val = 0;
if( it->devtype == dtRTU )
val = pollRTU(it);
else if( it->devtype == dtMTR )
{
val = pollMTR(it);
IOBase::processingAsAI( ib, val, shm, force );
#warning For Debug
// mb->cleanupChannel();
d->resp_real = true;
d->rtu->poll(mb);
}
else if( it->devtype == dtRTU188 )
catch( ModbusRTU::mbException& ex )
{
if( d->resp_real )
{
val = pollRTU188(it);
IOBase::processingAsAI( ib, val, shm, force );
dlog[Debug::CRIT] << myname << "(poll): FAILED ask addr=" << ModbusRTU::addr2str(d->mbaddr)
<< " -> " << ex << endl;
d->resp_real = false;
}
else
continue;
}
else if( it->stype == UniversalIO::DigitalInput )
{
bool set = false;
if( it->devtype == dtRTU )
set = pollRTU(it) ? true : false;
else if( it->devtype == dtMTR )
set = pollMTR(it) ? true : false;
else if( it->devtype == dtRTU188 )
set = pollRTU188(it) ? true : false;
else
continue;
IOBase::processingAsDI( ib, set, shm, force );
}
else if( it->stype == UniversalIO::AnalogOutput ||
it->stype == UniversalIO::DigitalOutput )
{
ModbusRTU::ModbusData d = 0;
if( it->stype == UniversalIO::AnalogOutput )
d = IOBase::processingAsAO( ib, shm, force_out );
else
d = IOBase::processingAsDO( ib, shm, force_out ) ? 1 : 0;
using namespace ModbusRTU;
switch(it->mbfunc)
{
case fnWriteOutputSingleRegister:
{
WriteSingleOutputRetMessage ret = mb->write06( it->mbaddr,it->mbreg,d);
}
break;
case fnWriteOutputRegisters:
{
WriteOutputMessage msg(it->mbaddr,it->mbreg);
msg.addData(d);
WriteOutputRetMessage ret = mb->write10(msg);
}
break;
default:
break;
}
}
if( it->devtype != dtRTU188 )
setRespond(it->mbaddr,true);
continue;
}
catch(ModbusRTU::mbException& ex )
for( RTUExchange::RegMap::iterator it=d->regmap.begin(); it!=d->regmap.end(); ++it )
{
dlog[Debug::LEVEL3] << myname << "(poll): " << ex << endl;
if( it->devtype != dtRTU188 )
setRespond(it->mbaddr,false);
}
catch(IOController_i::NameNotFound &ex)
d->resp_real = true;
try
{
dlog[Debug::LEVEL3] << myname << "(poll):(NameNotFound) " << ex.err << endl;
if( d->dtype==RTUExchange::dtRTU || d->dtype==RTUExchange::dtMTR )
pollRTU(d,it);
}
catch(IOController_i::IOBadParam& ex )
catch( ModbusRTU::mbException& ex )
{
dlog[Debug::LEVEL3] << myname << "(poll):(IOBadParam) " << ex.err << endl;
}
catch(IONotifyController_i::BadRange )
if( d->resp_real )
{
dlog[Debug::LEVEL3] << myname << "(poll): (BadRange)..." << endl;
dlog[Debug::CRIT] << myname << "(poll): FAILED ask addr=" << ModbusRTU::addr2str(d->mbaddr)
<< " -> " << ex << endl;
d->resp_real = false;
}
catch( Exception& ex )
{
dlog[Debug::LEVEL3] << myname << "(poll): " << ex << endl;
}
catch(CORBA::SystemException& ex)
{
dlog[Debug::LEVEL3] << myname << "(poll): ORBA::SystemException: "
<< ex.NP_minorString() << endl;
if( it==d->regmap.end() )
break;
}
catch(...)
{
dlog[Debug::LEVEL3] << myname << "(poll): catch ..." << endl;
}
}
// update SharedMemory...
updateSM();
// printMap(rmap);
}
// -----------------------------------------------------------------------------
long RTUExchange::pollRTU( RSMap::iterator& p )
void RTUExchange::pollRTU( RTUDevice* dev, RegMap::iterator& it )
{
RegInfo* p(it->second);
if( dlog.debugging(Debug::INFO) )
{
dlog[Debug::INFO] << myname << "(pollRTU): poll "
<< " mbaddr=" << ModbusRTU::addr2str(p->mbaddr)
<< " mbaddr=" << ModbusRTU::addr2str(dev->mbaddr)
<< " mbreg=" << ModbusRTU::dat2str(p->mbreg)
<< " mbfunc=" << p->mbfunc
<< " rnum=" << p->rnum
<< " vtype=" << p->vType
<< " rnum=" << p->rnum
<< " q_count=" << p->q_count
<< endl;
}
if( p->q_count == 0 )
{
if( dlog.debugging(Debug::INFO) )
dlog[Debug::INFO] << myname << "(pollRTU): q_count=0 for mbreg=" << ModbusRTU::dat2str(p->mbreg)
<< " IGNORE register..." << endl;
return ;
}
switch( p->mbfunc )
{
case ModbusRTU::fnReadInputRegisters:
{
ModbusRTU::ReadInputRetMessage ret = mb->read04(p->mbaddr,p->mbreg,p->rnum);
if( p->vType == VTypes::vtUnknown )
{
IOBase::processingAsAI( &(*p), ret.data[0], shm, force );
return ret.data[0];
}
if( p->vType == VTypes::vtF2 )
{
VTypes::F2 f(ret.data, sizeof(ret.data));
ModbusRTU::ReadInputRetMessage ret = mb->read04(dev->mbaddr,p->mbreg,p->q_count);
for( int i=0; i<p->q_count; i++,it++ )
it->second->mbval = ret.data[i];
cerr << "****** float v=" << (float)f << endl;
IOBase::processingFasAI( &(*p), f, shm, force );
return 0;
it--;
}
break;
if( p->vType == VTypes::vtF4 )
case ModbusRTU::fnReadOutputRegisters:
{
VTypes::F4 f(ret.data, sizeof(ret.data));
IOBase::processingFasAI( &(*p), f, shm, force );
return 0;
ModbusRTU::ReadOutputRetMessage ret = mb->read03(dev->mbaddr, p->mbreg,p->q_count);
for( int i=0; i<p->q_count; i++,it++ )
it->second->mbval = ret.data[i];
it--;
}
break;
case ModbusRTU::fnReadInputStatus:
{
ModbusRTU::ReadInputStatusRetMessage ret = mb->read02(dev->mbaddr, p->mbreg,p->q_count);
for( int i=0; i<p->q_count; i++,it++ )
it->second->mbval = ret.data[i];
it--;
}
break;
case ModbusRTU::fnReadOutputRegisters:
case ModbusRTU::fnReadCoilStatus:
{
ModbusRTU::ReadOutputRetMessage ret = mb->read03(p->mbaddr, p->mbreg, p->rnum);
return ret.data[0];
ModbusRTU::ReadCoilRetMessage ret = mb->read01(dev->mbaddr,p->mbreg,p->q_count);
for( int i=0; i<p->q_count; i++,it++ )
it->second->mbval = ret.data[i];
it--;
}
break;
case ModbusRTU::fnReadInputStatus:
case ModbusRTU::fnWriteOutputSingleRegister:
{
if( p->q_count != 1 )
{
ModbusRTU::ReadInputStatusRetMessage ret = mb->read02(p->mbaddr, p->mbreg,1);
ModbusRTU::DataBits b(ret.data[0]);
return b[p->nbit];
dlog[Debug::CRIT] << myname << "(pollRTU): mbreg=" << ModbusRTU::dat2str(p->mbreg)
<< " IGNORE WRITE SINGLE REGISTER q_count=" << p->q_count << " ..." << endl;
}
else
ModbusRTU::WriteSingleOutputRetMessage ret = mb->write06(dev->mbaddr,p->mbreg,p->mbval);
}
break;
case ModbusRTU::fnReadCoilStatus:
case ModbusRTU::fnWriteOutputRegisters:
{
ModbusRTU::ReadCoilRetMessage ret = mb->read01(p->mbaddr,p->mbreg,1);
ModbusRTU::DataBits b(ret.data[0]);
return b[p->nbit];
ModbusRTU::WriteOutputMessage msg(dev->mbaddr,p->mbreg);
for( int i=0; i<p->q_count; i++,it++ )
msg.addData(it->second->mbval);
it--;
ModbusRTU::WriteOutputRetMessage ret = mb->write10(msg);
}
break;
default:
{
if( dlog.debugging(Debug::INFO) )
dlog[Debug::INFO] << myname << "(pollRTU): mbreg=" << ModbusRTU::dat2str(p->mbreg)
<< " IGNORE mfunc=" << (int)p->mbfunc << " ..." << endl;
}
break;
}
return 0;
}
// -----------------------------------------------------------------------------
long RTUExchange::pollRTU188( RSMap::iterator& p )
bool RTUExchange::RTUDevice::checkRespond()
{
if( !p->rtu )
return 0;
bool prev = resp_state;
if( resp_trTimeout.change(resp_real) )
{
if( resp_real )
resp_state = true;
if( p->stype == UniversalIO::DigitalInput )
return p->rtu->getState(p->rtuJack,p->rtuChan,p->stype);
resp_ptTimeout.reset();
}
if( p->stype == UniversalIO::AnalogInput )
return p->rtu->getInt(p->rtuJack,p->rtuChan,p->stype);
if( resp_state && !resp_real && resp_ptTimeout.checkTime() )
resp_state = false;
return 0;
return ( prev != resp_state );
}
// -----------------------------------------------------------------------------
long RTUExchange::pollMTR( RSMap::iterator& p )
void RTUExchange::updateSM()
{
unsigned short v1=0, v2=0;
if( p->mbfunc == ModbusRTU::fnReadInputRegisters )
for( RTUExchange::RTUDeviceMap::iterator it1=rmap.begin(); it1!=rmap.end(); ++it1 )
{
ModbusRTU::ReadInputRetMessage ret = mb->read04(p->mbaddr, p->mbreg, MTR::wsize(p->mtrType));
v1 = ret.data[0];
v2 = ret.data[1];
}
else if( p->mbfunc == ModbusRTU::fnReadOutputRegisters )
RTUDevice* d(it1->second);
// update respond sensors......
if( d->checkRespond() && d->resp_id != DefaultObjectId )
{
ModbusRTU::ReadOutputRetMessage ret = mb->read03(p->mbaddr, p->mbreg, MTR::wsize(p->mtrType));
v1 = ret.data[0];
v2 = ret.data[1];
}
else
try
{
cerr << myname << "(readMTR): " << (int)p->mbfunc << endl;
return 0;
bool set = d->resp_invert ? !d->resp_state : d->resp_state;
shm->localSaveState(d->resp_dit,d->resp_id,set,getId());
}
if( p->mtrType == MTR::mtT1 )
catch(Exception& ex)
{
MTR::T1 t(v1);
return t.val;
dlog[Debug::CRIT] << myname
<< "(step): (respond) " << ex << std::endl;
}
}
if( p->mtrType == MTR::mtT2 )
// update values...
for( RTUExchange::RegMap::iterator it=d->regmap.begin(); it!=d->regmap.end(); ++it )
{
MTR::T2 t(v1);
return t.val;
try
{
if( d->dtype == dtRTU )
updateRTU(it);
else if( d->dtype == dtMTR )
updateMTR(it);
else if( d->dtype == dtRTU188 )
updateRTU188(it);
}
if( p->mtrType == MTR::mtT3 )
catch(IOController_i::NameNotFound &ex)
{
MTR::T3 t(v1,v2);
return (long)t;
dlog[Debug::LEVEL3] << myname << "(updateSM):(NameNotFound) " << ex.err << endl;
}
if( p->mtrType == MTR::mtT4 )
catch(IOController_i::IOBadParam& ex )
{
MTR::T4 t(v1);
return atoi(t.sval.c_str());
dlog[Debug::LEVEL3] << myname << "(updateSM):(IOBadParam) " << ex.err << endl;
}
if( p->mtrType == MTR::mtT5 )
catch(IONotifyController_i::BadRange )
{
MTR::T5 t(v1,v2);
return (long)t.val;
dlog[Debug::LEVEL3] << myname << "(updateSM): (BadRange)..." << endl;
}
if( p->mtrType == MTR::mtT6 )
catch( Exception& ex )
{
MTR::T6 t(v1,v2);
return (long)t.val;
dlog[Debug::LEVEL3] << myname << "(updateSM): " << ex << endl;
}
if( p->mtrType == MTR::mtT7 )
catch(CORBA::SystemException& ex)
{
MTR::T7 t(v1,v2);
return (long)t.val;
dlog[Debug::LEVEL3] << myname << "(updateSM): CORBA::SystemException: "
<< ex.NP_minorString() << endl;
}
if( p->mtrType == MTR::mtF1 )
catch(...)
{
MTR::F1 t(v1,v2);
return t;
dlog[Debug::LEVEL3] << myname << "(updateSM): catch ..." << endl;
}
return 0;
if( it==d->regmap.end() )
break;
}
}
}
/*
// -----------------------------------------------------------------------------
void RTUExchange::processingMessage(UniSetTypes::VoidMessage *msg)
long RTUExchange::pollRTU188( RSMap::iterator& p )
{
try
{
switch(msg->type)
{
case UniSetTypes::Message::SysCommand:
{
if( !p->rtu )
return 0;
if( p->stype == UniversalIO::DigitalInput )
return p->rtu->getState(p->rtuJack,p->rtuChan,p->stype);
if( p->stype == UniversalIO::AnalogInput )
return p->rtu->getInt(p->rtuJack,p->rtuChan,p->stype);
return 0;
}
*/
// -----------------------------------------------------------------------------
void RTUExchange::processingMessage(UniSetTypes::VoidMessage *msg)
{
try
{
switch(msg->type)
{
case UniSetTypes::Message::SysCommand:
{
UniSetTypes::SystemMessage sm( msg );
sysCommand( &sm );
}
......@@ -704,15 +552,16 @@ void RTUExchange::sysCommand( UniSetTypes::SystemMessage *sm )
{
case SystemMessage::StartUp:
{
if( rsmap.empty() )
if( rmap.empty() )
{
dlog[Debug::CRIT] << myname << "(sysCommand): rsmap EMPTY! terminated..." << endl;
dlog[Debug::CRIT] << myname << "(sysCommand): rmap EMPTY! terminated..." << endl;
raise(SIGTERM);
return;
}
if( dlog.debugging(Debug::INFO) )
dlog[Debug::INFO] << myname << "(sysCommand): rsmap size= "<< rsmap.size() << endl;
dlog[Debug::INFO] << myname << "(sysCommand): rmap size= " << rmap.size() << endl;
waitSMReady();
......@@ -823,6 +672,7 @@ void RTUExchange::askSensors( UniversalIO::UIOCommand cmd )
throw SystemError(err.str());
}
/*
RSMap::iterator it=rsmap.begin();
for( ; it!=rsmap.end(); ++it )
{
......@@ -842,10 +692,12 @@ void RTUExchange::askSensors( UniversalIO::UIOCommand cmd )
}
catch(...){}
}
*/
}
// ------------------------------------------------------------------------------------------
void RTUExchange::sensorInfo( UniSetTypes::SensorMessage* sm )
{
/*
RSMap::iterator it=rsmap.begin();
for( ; it!=rsmap.end(); ++it )
{
......@@ -868,6 +720,7 @@ void RTUExchange::sensorInfo( UniSetTypes::SensorMessage* sm )
break;
}
}
*/
}
// ------------------------------------------------------------------------------------------
bool RTUExchange::activateObject()
......@@ -879,6 +732,8 @@ bool RTUExchange::activateObject()
activated = false;
UniSetTypes::uniset_mutex_lock l(mutex_start, 5000);
UniSetObject_LT::activateObject();
if( !shm->isLocalwork() )
rtuQueryOptimization(rmap);
initIterators();
activated = true;
}
......@@ -892,6 +747,7 @@ void RTUExchange::sigterm( int signo )
activated = false;
#warning ...
// ....
/*
RSMap::iterator it=rsmap.begin();
for( ; it!=rsmap.end(); ++it )
{
......@@ -910,7 +766,7 @@ void RTUExchange::sigterm( int signo )
}
catch(...){}
}
*/
UniSetObject_LT::sigterm(signo);
}
// ------------------------------------------------------------------------------------------
......@@ -968,118 +824,125 @@ bool RTUExchange::readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec )
}
// ------------------------------------------------------------------------------------------
bool RTUExchange::initItem( UniXML_iterator& it )
RTUExchange::RTUDevice* RTUExchange::addDev( RTUDeviceMap& mp, ModbusRTU::ModbusAddr a, UniXML_iterator& xmlit )
{
string rstype = it.getProp("mbtype");
RSProperty p;
bool ret = false;
if( rstype == "mtr" || rstype == "MTR" )
ret = initMTRitem(it,p);
else if( rstype == "rtu" || rstype == "RTU" )
ret = initRTUitem(it,p);
else if ( rstype == "rtu188" || rstype == "RTU188" )
{
ret = initRTU188item(it,p);
if( ret )
RTUDeviceMap::iterator it = mp.find(a);
if( it != mp.end() )
{
RTUMap::iterator r = rtulist.find(p.mbaddr);
if( r == rtulist.end() )
DeviceType dtype = getDeviceType(xmlit.getProp("mbtype"));
if( it->second->dtype != dtype )
{
p.rtu = new RTUStorage(p.mbaddr);
rtulist[p.mbaddr] = p.rtu;
}
else
p.rtu = r->second;
}
dlog[Debug::CRIT] << myname << "(addDev): OTHER mbtype=" << dtype << " for " << xmlit.getProp("name")
<< ". Already used devtype=" << it->second->dtype
<< " for mbaddr=" << ModbusRTU::addr2str(it->second->mbaddr)
<< endl;
return 0;
}
if( ret )
{
//
// 10 ( )
// resize
//
if( maxItem >= rsmap.size() )
rsmap.resize(maxItem+10);
dlog[Debug::INFO] << myname << "(addDev): device for addr=" << ModbusRTU::addr2str(a)
<< " already added. Ignore device params for " << xmlit.getProp("name") << " ..." << endl;
return it->second;
}
rsmap[maxItem] = p;
maxItem++;
RTUExchange::RTUDevice* d = new RTUExchange::RTUDevice();
d->mbaddr = a;
if( dlog.debugging(Debug::INFO) )
dlog[Debug::INFO] << myname << "(initItem): add " << p << endl;
if( !initRTUDevice(d,xmlit) )
{
delete d;
return 0;
}
return ret;
mp.insert(RTUDeviceMap::value_type(a,d));
return d;
}
// ------------------------------------------------------------------------------------------
bool RTUExchange::initCommParam( UniXML_iterator& it, RSProperty& p )
RTUExchange::RegInfo* RTUExchange::addReg( RegMap& mp, ModbusRTU::ModbusData r,
UniXML_iterator& xmlit, RTUExchange::RTUDevice* dev,
RTUExchange::RegInfo* rcopy )
{
if( !IOBase::initItem( static_cast<IOBase*>(&p),it,shm,&dlog,myname) )
return false;
RegMap::iterator it = mp.find(r);
if( it != mp.end() )
{
if( !it->second->dev )
{
dlog[Debug::CRIT] << myname << "(addReg): for reg=" << ModbusRTU::dat2str(r)
<< " dev=0!!!! " << endl;
return 0;
}
string addr = it.getProp("mbaddr");
if( addr.empty() )
return true;
if( it->second->dev->dtype != dev->dtype )
{
dlog[Debug::CRIT] << myname << "(addReg): OTHER mbtype=" << dev->dtype << " for reg=" << ModbusRTU::dat2str(r)
<< ". Already used devtype=" << it->second->dev->dtype << " for " << it->second->dev << endl;
return 0;
}
p.mbaddr = ModbusRTU::str2mbAddr(addr);
p.mbfunc = ModbusRTU::fnUnknown;
dlog[Debug::INFO] << myname << "(addReg): reg=" << ModbusRTU::dat2str(r)
<< " already added. Ignore register params for " << xmlit.getProp("name") << " ..." << endl;
string f = it.getProp("mbfunc");
if( !f.empty() )
return it->second;
}
RTUExchange::RegInfo* ri;
if( rcopy )
{
p.mbfunc = (ModbusRTU::SlaveFunctionCode)UniSetTypes::uni_atoi(f.c_str());
if( p.mbfunc == ModbusRTU::fnUnknown )
ri = new RTUExchange::RegInfo(*rcopy);
ri->slst.clear();
ri->mbreg = r;
}
else
{
dlog[Debug::CRIT] << myname << "(initCommParam): mbfunc ='" << f
<< "' " << it.getProp("name") << endl;
return false;
ri = new RTUExchange::RegInfo();
if( !initRegInfo(ri,xmlit,dev) )
{
delete ri;
return 0;
}
ri->mbreg = r;
}
return true;
mp.insert(RegMap::value_type(r,ri));
return ri;
}
// ------------------------------------------------------------------------------------------
bool RTUExchange::initRTUitem( UniXML_iterator& it, RSProperty& p )
RTUExchange::RSProperty* RTUExchange::addProp( PList& plist, RSProperty& p )
{
p.devtype = dtRTU;
if( !initCommParam(it,p) )
return false;
if( mbregFromID )
for( PList::iterator it=plist.begin(); it!=plist.end(); ++it )
{
p.mbreg = p.si.id;
return true;
if( it->si.id == p.si.id && it->si.node == p.si.node )
return &(*it);
}
string reg = it.getProp("mbreg");
if( reg.empty() )
return true;
p.mbreg = ModbusRTU::str2mbData(reg);
plist.push_back(p);
PList::iterator it = plist.end();
it--;
return &(*it);
}
// ------------------------------------------------------------------------------------------
bool RTUExchange::initRSProperty( RSProperty& p, UniXML_iterator& it )
{
if( !IOBase::initItem(&p,it,shm,&dlog,myname) )
return false;
if( p.mbfunc == ModbusRTU::fnReadCoilStatus ||
p.mbfunc == ModbusRTU::fnReadInputStatus )
string sbit(it.getProp("nbit"));
if( !sbit.empty() )
{
string nb = it.getProp("nbit");
if( nb.empty() )
p.nbit = UniSetTypes::uni_atoi(sbit.c_str());
if( p.nbit < 0 || p.nbit >= ModbusRTU::BitsPerData )
{
dlog[Debug::CRIT] << myname << "(readRTUItem): Unknown nbit. for "
<< it.getProp("name")
<< " mbfunc=" << p.mbfunc
<< endl;
dlog[Debug::CRIT] << myname << "(initRSProperty): BAD nbit=" << p.nbit
<< ". (0 >= nbit < " << ModbusRTU::BitsPerData <<")." << endl;
return false;
}
}
p.nbit = UniSetTypes::uni_atoi(nb.c_str());
if( p.nbit > 0 &&
( p.stype == UniversalIO::AnalogInput ||
p.stype == UniversalIO::AnalogOutput ) )
{
dlog[Debug::WARN] << "(initRSProperty): (ignore) uncorrect param`s nbit>1 (" << p.nbit << ")"
<< " but iotype=" << p.stype << " for " << it.getProp("name") << endl;
}
string vt(it.getProp("vtype"));
......@@ -1093,7 +956,7 @@ bool RTUExchange::initRTUitem( UniXML_iterator& it, RSProperty& p )
VTypes::VType v(VTypes::str2type(vt));
if( v == VTypes::vtUnknown )
{
dlog[Debug::CRIT] << myname << "(readRTUItem): Unknown rtuVType=" << vt << " for "
dlog[Debug::CRIT] << myname << "(initRSProperty): Unknown rtuVType=" << vt << " for "
<< it.getProp("name")
<< endl;
......@@ -1107,99 +970,299 @@ bool RTUExchange::initRTUitem( UniXML_iterator& it, RSProperty& p )
return true;
}
// ------------------------------------------------------------------------------------------
bool RTUExchange::initMTRitem( UniXML_iterator& it, RSProperty& p )
bool RTUExchange::initRegInfo( RegInfo* r, UniXML_iterator& it, RTUExchange::RTUDevice* dev )
{
p.devtype = dtMTR;
r->dev = dev;
r->mbval = UniSetTypes::uni_atoi(it.getProp("default").c_str());
if( !initCommParam(it,p) )
if( dev->dtype == RTUExchange::dtMTR )
{
// only for MTR
if( !initMTRitem(it,r) )
return false;
p.mtrType = MTR::str2type(it.getProp("mtrtype"));
if( p.mtrType == MTR::mtUnknown )
}
else if( dev->dtype == RTUExchange::dtRTU188 )
{ // only for RTU188
if( !initRTU188item(it,r) )
return false;
}
else if( dev->dtype == RTUExchange::dtRTU )
{
dlog[Debug::CRIT] << myname << "(readMTRItem): MTR- '"
<< it.getProp("mtrtype")
<< "' " << it.getProp("name") << endl;
}
else
{
dlog[Debug::CRIT] << myname << "(initRegInfo): Unknown mbtype='" << dev->dtype
<< "' for " << it.getProp("name") << endl;
return false;
}
if( mbregFromID )
r->mbreg = conf->getSensorID(it.getProp("name"));
else if( dev->dtype != RTUExchange::dtRTU188 )
{
p.mbreg = p.si.id;
return true;
}
string reg = it.getProp("mbreg");
if( reg.empty() )
{
dlog[Debug::CRIT] << myname << "(initRegInfo): unknown mbreg for " << it.getProp("name") << endl;
return false;
}
r->mbreg = ModbusRTU::str2mbData(reg);
}
else // if( dev->dtype == RTUExchange::dtRTU188 )
{
UniversalIO::IOTypes stype = UniSetTypes::getIOType(it.getProp("iotype"));
r->mbreg = RTUStorage::getRegister(r->rtuJack,r->rtuChan,stype);
if( r->mbreg == -1 )
{
dlog[Debug::CRIT] << myname << "(initRegInfo): (RTU188) unknown mbreg for " << it.getProp("name") << endl;
return false;
}
}
r->mbfunc = ModbusRTU::fnUnknown;
string f = it.getProp("mbfunc");
if( !f.empty() )
{
r->mbfunc = (ModbusRTU::SlaveFunctionCode)UniSetTypes::uni_atoi(f.c_str());
if( r->mbfunc == ModbusRTU::fnUnknown )
{
dlog[Debug::CRIT] << myname << "(initRegInfo): Unknown mbfunc ='" << f
<< "' for " << it.getProp("name") << endl;
return false;
}
}
return true;
}
// ------------------------------------------------------------------------------------------
RTUExchange::DeviceType RTUExchange::getDeviceType( const std::string dtype )
{
if( dtype.empty() )
return dtUnknown;
if( dtype == "mtr" || dtype == "MTR" )
return dtMTR;
if( dtype == "rtu" || dtype == "RTU" )
return dtRTU;
if ( dtype == "rtu188" || dtype == "RTU188" )
return dtRTU188;
return dtUnknown;
p.mbreg = ModbusRTU::str2mbData(reg);
}
// ------------------------------------------------------------------------------------------
bool RTUExchange::initRTUDevice( RTUDevice* d, UniXML_iterator& it )
{
d->dtype = getDeviceType(it.getProp("mbtype"));
if( d->dtype == dtUnknown )
{
dlog[Debug::CRIT] << myname << "(initRTUDevice): Unknown mbtype=" << it.getProp("mbtype")
<< ". Use: rtu | mtr | rtu188"
<< " for " << it.getProp("name") << endl;
return false;
}
string addr = it.getProp("mbaddr");
if( addr.empty() )
{
dlog[Debug::CRIT] << myname << "(initRTUDevice): Unknown mbaddr for " << it.getProp("name") << endl;
return false;
}
d->mbaddr = ModbusRTU::str2mbAddr(addr);
return true;
}
// ------------------------------------------------------------------------------------------
bool RTUExchange::initRTU188item( UniXML_iterator& it, RSProperty& p )
bool RTUExchange::initItem( UniXML_iterator& it )
{
p.devtype = dtRTU188;
RSProperty p;
if( !initRSProperty(p,it) )
return false;
if( !check_item(it) )
string addr = it.getProp("mbaddr");
if( addr.empty() )
{
cerr << "******* false filter: " << it.getProp("name") << endl;
dlog[Debug::CRIT] << myname << "(initItem): Unknown mbaddr='" << addr << " for " << it.getProp("name") << endl;
return false;
}
if( !initCommParam(it,p) )
ModbusRTU::ModbusAddr mbaddr = ModbusRTU::str2mbAddr(addr);
RTUDevice* dev = addDev(rmap,mbaddr,it);
if( !dev )
{
dlog[Debug::CRIT] << myname << "(initItem): " << it.getProp("name") << " CAN`T ADD for polling!" << endl;
return false;
}
ModbusRTU::ModbusData mbreg;
if( mbregFromID )
mbreg = p.si.id; // conf->getSensorID(it.getProp("name"));
else if( dev->dtype != RTUExchange::dtRTU188 )
{
string reg = it.getProp("mbreg");
if( reg.empty() )
{
dlog[Debug::CRIT] << myname << "(initRegInfo): unknown mbreg for " << it.getProp("name") << endl;
return false;
}
mbreg = ModbusRTU::str2mbData(reg);
}
else // if( dev->dtype == RTUExchange::dtRTU188 )
{
RegInfo rr;
initRegInfo(&rr,it,dev);
mbreg = RTUStorage::getRegister(rr.rtuJack,rr.rtuChan,p.stype);
if( mbreg == -1 )
{
dlog[Debug::CRIT] << myname << "(initItem): unknown mbreg for " << it.getProp("name") << endl;
return false;
}
}
RegInfo* ri = addReg(dev->regmap,mbreg,it,dev);
if( dev->dtype == dtMTR )
{
p.rnum = MTR::wsize(ri->mtrType);
if( p.rnum <= 0 )
{
dlog[Debug::CRIT] << myname << "(initItem): unknown word size for " << it.getProp("name") << endl;
return false;
}
}
if( !ri )
return false;
ri->dev = dev;
// ПРОВЕРКА!
// если функция на запись, то надо проверить
// что один и тотже регистр не перезапишут несколько датчиков
// это возможно только, если они пишут биты!!
// ИТОГ:
// Если для функций записи список датчиков на один регистр > 1
// значит в списке могут быть только битовые датчики
// и если идёт попытка внести в список не битовый датчик то ОШИБКА!
// И наоборот: если идёт попытка внести битовый датчик, а в списке
// уже сидит датчик занимающий целый регистр, то тоже ОШИБКА!
if( ri->mbfunc == ModbusRTU::fnWriteOutputRegisters ||
ri->mbfunc == ModbusRTU::fnWriteOutputSingleRegister )
{
if( p.nbit<0 && ri->slst.size() > 1 )
{
dlog[Debug::CRIT] << myname << "(initItem): FAILED! Sharing SAVE (not bit saving) to "
<< " mbreg=" << ModbusRTU::dat2str(ri->mbreg)
<< " for " << it.getProp("name") << endl;
return false;
}
if( p.nbit >= 0 && ri->slst.size() == 1 )
{
PList::iterator it2 = ri->slst.begin();
if( it2->nbit < 0 )
{
dlog[Debug::CRIT] << myname << "(initItem): FAILED! Sharing SAVE (mbreg="
<< ModbusRTU::dat2str(ri->mbreg) << " already used)!"
<< " IGNORE --> " << it.getProp("name") << endl;
return false;
}
}
}
RSProperty* p1 = addProp(ri->slst,p);
if( !p1 )
return false;
p1->reg = ri;
if( p1->rnum > 1 )
{
for( int i=1; i<p1->rnum; i++ )
addReg(dev->regmap,mbreg+i,it,dev,ri);
}
if( dev->dtype == dtRTU188 )
{
if( !dev->rtu )
dev->rtu = new RTUStorage(mbaddr);
}
return true;
}
// ------------------------------------------------------------------------------------------
bool RTUExchange::initMTRitem( UniXML_iterator& it, RegInfo* p )
{
p->mtrType = MTR::str2type(it.getProp("mtrtype"));
if( p->mtrType == MTR::mtUnknown )
{
dlog[Debug::CRIT] << myname << "(readMTRItem): Unknown mtrtype '"
<< it.getProp("mtrtype")
<< "' for " << it.getProp("name") << endl;
return false;
}
return true;
}
// ------------------------------------------------------------------------------------------
bool RTUExchange::initRTU188item( UniXML_iterator& it, RegInfo* p )
{
string jack = it.getProp("jack");
string chan = it.getProp("channel");
if( jack.empty() )
{
dlog[Debug::CRIT] << myname << "(readRTUItem): ߣ jack='' "
<< " " << it.getProp("name") << endl;
dlog[Debug::CRIT] << myname << "(readRTU188Item): Unknown jack='' "
<< " for " << it.getProp("name") << endl;
return false;
}
p.rtuJack = RTUStorage::s2j(jack);
if( p.rtuJack == RTUStorage::nUnknown )
p->rtuJack = RTUStorage::s2j(jack);
if( p->rtuJack == RTUStorage::nUnknown )
{
dlog[Debug::CRIT] << myname << "(readRTUItem): jack=" << jack
<< " " << it.getProp("name") << endl;
dlog[Debug::CRIT] << myname << "(readRTU188Item): Unknown jack=" << jack
<< " for " << it.getProp("name") << endl;
return false;
}
if( chan.empty() )
{
dlog[Debug::CRIT] << myname << "(readRTUItem): ߣ channel='' "
<< " " << it.getProp("name") << endl;
dlog[Debug::CRIT] << myname << "(readRTU188Item): Unknown channel='' "
<< " for " << it.getProp("name") << endl;
return false;
}
p.rtuChan = UniSetTypes::uni_atoi(chan.c_str());
p->rtuChan = UniSetTypes::uni_atoi(chan.c_str());
if( dlog.debugging(Debug::LEVEL2) )
dlog[Debug::LEVEL2] << myname << "(readItem): " << p << endl;
dlog[Debug::LEVEL2] << myname << "(readRTU188Item): " << p << endl;
return true;
}
// -----------------------------------------------------------------------------
void RTUExchange::initIterators()
{
RSMap::iterator it=rsmap.begin();
for( ; it!=rsmap.end(); it++ )
{
shm->initDIterator(it->dit);
shm->initAIterator(it->ait);
}
shm->initAIterator(aitHeartBeat);
for( RespondMap::iterator it=respMap.begin(); it!=respMap.end(); ++it )
for( RTUExchange::RTUDeviceMap::iterator it1=rmap.begin(); it1!=rmap.end(); ++it1 )
{
RTUDevice* d(it1->second);
shm->initDIterator(d->resp_dit);
for( RTUExchange::RegMap::iterator it=d->regmap.begin(); it!=d->regmap.end(); ++it )
{
shm->initDIterator(it->second.dit);
it->second.ptTimeout.reset();
for( PList::iterator it2=it->second->slst.begin();it2!=it->second->slst.end(); ++it2 )
{
shm->initDIterator(it2->dit);
shm->initAIterator(it2->ait);
}
}
}
}
// -----------------------------------------------------------------------------
void RTUExchange::help_print( int argc, char* argv[] )
......@@ -1210,7 +1273,6 @@ void RTUExchange::help_print( int argc, char* argv[] )
cout << "--rs-ready-timeout - SM , . (-1 - '')" << endl;
cout << "--rs-force - SM, , " << endl;
cout << "--rs-initPause - ( )" << endl;
cout << "--rs-notRespondSensor - " << endl;
cout << "--rs-sm-ready-timeout - SM" << endl;
cout << " RS: " << endl;
cout << "--rs-dev devname - " << endl;
......@@ -1265,14 +1327,14 @@ std::ostream& operator<<( std::ostream& os, const RTUExchange::DeviceType& dt )
return os;
}
// -----------------------------------------------------------------------------
std::ostream& operator<<( std::ostream& os, RTUExchange::RSProperty& p )
std::ostream& operator<<( std::ostream& os, const RTUExchange::RSProperty& p )
{
os << " mbaddr=(" << (int)p.mbaddr << ")" << ModbusRTU::addr2str(p.mbaddr)
<< " mbreg=" << ModbusRTU::dat2str(p.mbreg)
<< " mbfunc=" << p.mbfunc
<< " devtype=" << p.devtype;
switch(p.devtype)
// os << " mbaddr=(" << (int)p.mbaddr << ")" << ModbusRTU::addr2str(p.mbaddr)
// << " mbreg=" << ModbusRTU::dat2str(p.mbreg)
// << " mbfunc=" << p.mbfunc
// << " dtype=" << p.dtype;
/*
switch(p.dtype)
{
case RTUExchange::dtRTU:
os << " nbit=" << p.nbit;
......@@ -1291,9 +1353,11 @@ std::ostream& operator<<( std::ostream& os, RTUExchange::RSProperty& p )
os << "Unknown type parameters ???!!!" << endl;
break;
}
*/
os << " sid=" << p.si.id
<< " stype=" << p.stype
<< " nbit=" << p.nbit
<< " rnum=" << p.rnum
<< " safety=" << p.safety
<< " invert=" << p.invert;
......@@ -1309,26 +1373,514 @@ std::ostream& operator<<( std::ostream& os, RTUExchange::RSProperty& p )
return os;
}
// -----------------------------------------------------------------------------
void RTUExchange::setRespond( ModbusRTU::ModbusAddr addr, bool respond )
bool RTUExchange::initRespondInfo( RTUDeviceMap& m, ModbusRTU::ModbusAddr a, UniXML_iterator& it )
{
RespondMap::iterator it = respMap.find(addr);
if( it != respMap.end() )
RTUDeviceMap::iterator d = m.find(a);
if( d == m.end() )
{
if( it->second.trTimeout.change(respond) )
dlog[Debug::WARN] << myname << "(initRespondInfo): not found device for addr=" << ModbusRTU::addr2str(a) << endl;
return false;
}
d->second->resp_id = conf->getSensorID(it.getProp("respondSensor"));
if( d->second->resp_id == DefaultObjectId )
{
if( dlog.debugging(Debug::INFO) )
dlog[Debug::INFO] << myname << "(setRespond): ("
<< (int)addr << ")" << ModbusRTU::addr2str(addr)
<< " state=" << respond << endl;
dlog[Debug::CRIT] << myname << ": not found ID for noRespondSensor=" << it.getProp("respondSensor") << endl;
return false;
}
if( respond )
it->second.state = true;
int tout = atoi(it.getProp("timeout").c_str());
if( tout > 0 )
d->second->resp_ptTimeout.setTiming(tout);
else
d->second->resp_ptTimeout.setTiming(UniSetTimer::WaitUpTime);
it->second.ptTimeout.reset();
d->second->resp_invert = atoi(it.getProp("invert").c_str());
return true;
}
// -----------------------------------------------------------------------------
void RTUExchange::printMap( RTUExchange::RTUDeviceMap& m )
{
cout << "devices: " << endl;
for( RTUExchange::RTUDeviceMap::iterator it=m.begin(); it!=m.end(); ++it )
{
cout << " " << *(it->second) << endl;
}
}
// -----------------------------------------------------------------------------
std::ostream& operator<<( std::ostream& os, RTUExchange::RTUDeviceMap& m )
{
os << "devices: " << endl;
for( RTUExchange::RTUDeviceMap::iterator it=m.begin(); it!=m.end(); ++it )
{
os << " " << *(it->second) << endl;
}
return os;
}
// -----------------------------------------------------------------------------
std::ostream& operator<<( std::ostream& os, RTUExchange::RTUDevice& d )
{
os << "addr=" << ModbusRTU::addr2str(d.mbaddr)
<< " type=" << d.dtype;
if( it->second.state && !respond && it->second.ptTimeout.checkTime() )
it->second.state = false;
os << " rtu=" << (d.rtu ? "yes" : "no" );
os << " repond_id=" << d.resp_id
<< " repond_timeout=" << d.resp_ptTimeout.getInterval()
<< " repond_state=" << d.resp_state
<< " repond_invert=" << d.resp_invert
<< endl;
os << " regs: " << endl;
for( RTUExchange::RegMap::iterator it=d.regmap.begin(); it!=d.regmap.end(); ++it )
os << " " << *(it->second) << endl;
return os;
}
// -----------------------------------------------------------------------------
std::ostream& operator<<( std::ostream& os, RTUExchange::RegInfo& r )
{
os << " mbreg=" << ModbusRTU::dat2str(r.mbreg)
<< " mbfunc=" << r.mbfunc
<< " mtrType=" << MTR::type2str(r.mtrType)
<< " jack=" << RTUStorage::j2s(r.rtuJack)
<< " chan=" << r.rtuChan
<< " q_num=" << r.q_num
<< " q_count=" << r.q_count
<< " value=" << ModbusRTU::dat2str(r.mbval) << "(" << (int)r.mbval << ")"
<< endl;
for( RTUExchange::PList::iterator it=r.slst.begin(); it!=r.slst.end(); ++it )
os << " " << (*it) << endl;
return os;
}
// -----------------------------------------------------------------------------
void RTUExchange::rtuQueryOptimization( RTUDeviceMap& m )
{
dlog[Debug::INFO] << myname << "(rtuQueryOptimization): optimization..." << endl;
for( RTUExchange::RTUDeviceMap::iterator it1=m.begin(); it1!=m.end(); ++it1 )
{
RTUDevice* d(it1->second);
for( RTUExchange::RegMap::iterator it=d->regmap.begin(); it!=d->regmap.end(); ++it )
{
RTUExchange::RegMap::iterator beg = it;
ModbusRTU::ModbusData reg = it->second->mbreg;
beg->second->q_num = 1;
beg->second->q_count = 1;
it++;
for( ;it!=d->regmap.end(); ++it )
{
if( (it->second->mbreg - reg) > 1 )
break;
if( beg->second->mbfunc != it->second->mbfunc )
break;
beg->second->q_count++;
reg = it->second->mbreg;
it->second->q_num = beg->second->q_count;
it->second->q_count = 0;
}
// check correct function...
if( beg->second->q_count>1 && beg->second->mbfunc==ModbusRTU::fnWriteOutputSingleRegister )
{
dlog[Debug::WARN] << myname << "(rtuQueryOptimization): "
<< " optimization change func=" << ModbusRTU::fnWriteOutputSingleRegister
<< " <--> func=" << ModbusRTU::fnWriteOutputRegisters
<< " for mbaddr=" << ModbusRTU::addr2str(d->mbaddr)
<< " mbreg=" << ModbusRTU::dat2str(beg->second->mbreg);
beg->second->mbfunc = ModbusRTU::fnWriteOutputRegisters;
}
if( it==d->regmap.end() )
break;
it--;
}
}
}
// -----------------------------------------------------------------------------
void RTUExchange::updateRTU( RegMap::iterator& rit )
{
RegInfo* r(rit->second);
using namespace ModbusRTU;
bool save = false;
if( r->mbfunc == fnWriteOutputRegisters || r->mbfunc == fnWriteOutputSingleRegister )
save = true;
ModbusRTU::DataBits16 b(r->mbval);
for( PList::iterator it=r->slst.begin(); it!=r->slst.end(); ++it )
{
try
{
if( it->vType == VTypes::vtUnknown )
{
if( it->nbit >= 0 )
{
if( save )
{
bool set = IOBase::processingAsDO( &(*it), shm, force );
b.set(it->nbit,set);
r->mbval = b.mdata();
}
else
{
bool set = b[it->nbit];
IOBase::processingAsDI( &(*it), set, shm, force );
}
continue;
}
if( it->rnum <= 1 )
{
if( save )
r->mbval = IOBase::processingAsAO( &(*it), shm, force );
else
IOBase::processingAsAI( &(*it), r->mbval, shm, force );
continue;
}
dlog[Debug::CRIT] << myname << "(updateRTU): IGNORE item: rnum=" << it->rnum
<< " > 1 ?!! for id=" << it->si.id << endl;
continue;
}
else if( it->vType == VTypes::vtF2 )
{
RegMap::iterator i(rit);
if( save )
{
float f = IOBase::processingFasAO( &(*it), shm, force );
VTypes::F2 f2(f);
for( int k=0; k<VTypes::F2::wsize(); k++, i++ )
i->second->mbval = f2.raw.v[k];
}
else
{
ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[VTypes::F2::wsize()];
for( int k=0; k<VTypes::F2::wsize(); k++, i++ )
data[k] = i->second->mbval;
VTypes::F2 f(data,VTypes::F2::wsize());
delete[] data;
IOBase::processingFasAI( &(*it), (float)f, shm, force );
}
}
else if( it->vType == VTypes::vtF4 )
{
RegMap::iterator i(rit);
if( save )
{
float f = IOBase::processingFasAO( &(*it), shm, force );
VTypes::F4 f4(f);
for( int k=0; k<VTypes::F4::wsize(); k++, i++ )
i->second->mbval = f4.raw.v[k];
}
else
{
ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[VTypes::F4::wsize()];
for( int k=0; k<VTypes::F4::wsize(); k++, i++ )
data[k] = i->second->mbval;
VTypes::F4 f(data,VTypes::F4::wsize());
delete[] data;
IOBase::processingFasAI( &(*it), (float)f, shm, force );
}
}
}
catch(IOController_i::NameNotFound &ex)
{
dlog[Debug::LEVEL3] << myname << "(updateRTU):(NameNotFound) " << ex.err << endl;
}
catch(IOController_i::IOBadParam& ex )
{
dlog[Debug::LEVEL3] << myname << "(updateRTU):(IOBadParam) " << ex.err << endl;
}
catch(IONotifyController_i::BadRange )
{
dlog[Debug::LEVEL3] << myname << "(updateRTU): (BadRange)..." << endl;
}
catch( Exception& ex )
{
dlog[Debug::LEVEL3] << myname << "(updateRTU): " << ex << endl;
}
catch(CORBA::SystemException& ex)
{
dlog[Debug::LEVEL3] << myname << "(updateRTU): CORBA::SystemException: "
<< ex.NP_minorString() << endl;
}
catch(...)
{
dlog[Debug::LEVEL3] << myname << "(updateRTU): catch ..." << endl;
}
}
}
// -----------------------------------------------------------------------------
void RTUExchange::updateMTR( RegMap::iterator& rit )
{
RegInfo* r(rit->second);
using namespace ModbusRTU;
bool save = false;
if( r->mbfunc == fnWriteOutputRegisters || r->mbfunc == fnWriteOutputSingleRegister )
save = true;
{
for( PList::iterator it=r->slst.begin(); it!=r->slst.end(); ++it )
{
try
{
if( r->mtrType == MTR::mtT1 )
{
if( save )
r->mbval = IOBase::processingAsAO( &(*it), shm, force );
else
{
MTR::T1 t(r->mbval);
IOBase::processingAsAI( &(*it), t.val, shm, force );
}
continue;
}
if( r->mtrType == MTR::mtT2 )
{
if( save )
{
MTR::T2 t(IOBase::processingAsAO( &(*it), shm, force ));
r->mbval = t.val;
}
else
{
MTR::T2 t(r->mbval);
IOBase::processingAsAI( &(*it), t.val, shm, force );
}
continue;
}
if( r->mtrType == MTR::mtT3 )
{
RegMap::iterator i(rit);
if( save )
{
MTR::T3 t(IOBase::processingAsAO( &(*it), shm, force ));
for( int k=0; k<MTR::T3::wsize(); k++, i++ )
i->second->mbval = t.raw.v[k];
}
else
{
ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[MTR::T3::wsize()];
for( int k=0; k<MTR::T3::wsize(); k++, i++ )
data[k] = i->second->mbval;
MTR::T3 t(data);
delete[] data;
IOBase::processingAsAI( &(*it), (long)t, shm, force );
}
continue;
}
if( r->mtrType == MTR::mtT4 )
{
if( save )
cerr << myname << "(updateMTR): write (T4) reg(" << dat2str(r->mbreg) << ") to MTR NOT YET!!!" << endl;
else
{
MTR::T4 t(r->mbval);
IOBase::processingAsAI( &(*it),atoi(t.sval.c_str()), shm, force );
}
continue;
}
if( r->mtrType == MTR::mtT5 )
{
RegMap::iterator i(rit);
if( save )
{
MTR::T5 t(IOBase::processingAsAO( &(*it), shm, force ));
for( int k=0; k<MTR::T5::wsize(); k++, i++ )
i->second->mbval = t.raw.v[k];
}
else
{
ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[MTR::T5::wsize()];
for( int k=0; k<MTR::T5::wsize(); k++, i++ )
data[k] = i->second->mbval;
MTR::T5 t(data);
delete[] data;
IOBase::processingFasAI( &(*it), (float)t.val, shm, force );
}
continue;
}
if( r->mtrType == MTR::mtT6 )
{
RegMap::iterator i(rit);
if( save )
{
MTR::T6 t(IOBase::processingAsAO( &(*it), shm, force ));
for( int k=0; k<MTR::T6::wsize(); k++, i++ )
i->second->mbval = t.raw.v[k];
}
else
{
ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[MTR::T6::wsize()];
for( int k=0; k<MTR::T6::wsize(); k++, i++ )
data[k] = i->second->mbval;
MTR::T6 t(data);
delete[] data;
IOBase::processingFasAI( &(*it), (float)t.val, shm, force );
}
continue;
}
if( r->mtrType == MTR::mtT7 )
{
RegMap::iterator i(rit);
if( save )
{
MTR::T7 t(IOBase::processingAsAO( &(*it), shm, force ));
for( int k=0; k<MTR::T7::wsize(); k++, i++ )
i->second->mbval = t.raw.v[k];
}
else
{
ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[MTR::T7::wsize()];
for( int k=0; k<MTR::T7::wsize(); k++, i++ )
data[k] = i->second->mbval;
MTR::T7 t(data);
delete[] data;
IOBase::processingFasAI( &(*it), (float)t.val, shm, force );
}
continue;
}
if( r->mtrType == MTR::mtF1 )
{
RegMap::iterator i(rit);
if( save )
{
float f = IOBase::processingFasAO( &(*it), shm, force );
MTR::F1 f1(f);
for( int k=0; k<MTR::F1::wsize(); k++, i++ )
i->second->mbval = f1.raw.v[k];
}
else
{
ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[MTR::F1::wsize()];
for( int k=0; k<MTR::F1::wsize(); k++, i++ )
data[k] = i->second->mbval;
MTR::F1 t(data);
delete[] data;
IOBase::processingFasAI( &(*it), (float)t, shm, force );
}
continue;
}
}
catch(IOController_i::NameNotFound &ex)
{
dlog[Debug::LEVEL3] << myname << "(updateMTR):(NameNotFound) " << ex.err << endl;
}
catch(IOController_i::IOBadParam& ex )
{
dlog[Debug::LEVEL3] << myname << "(updateMTR):(IOBadParam) " << ex.err << endl;
}
catch(IONotifyController_i::BadRange )
{
dlog[Debug::LEVEL3] << myname << "(updateMTR): (BadRange)..." << endl;
}
catch( Exception& ex )
{
dlog[Debug::LEVEL3] << myname << "(updateMTR): " << ex << endl;
}
catch(CORBA::SystemException& ex)
{
dlog[Debug::LEVEL3] << myname << "(updateMTR): CORBA::SystemException: "
<< ex.NP_minorString() << endl;
}
catch(...)
{
dlog[Debug::LEVEL3] << myname << "(updateMTR): catch ..." << endl;
}
}
}
}
// -----------------------------------------------------------------------------
void RTUExchange::updateRTU188( RegMap::iterator& it )
{
RegInfo* r(it->second);
if( !r->dev->rtu )
return;
using namespace ModbusRTU;
// bool save = false;
if( r->mbfunc == fnWriteOutputRegisters || r->mbfunc == fnWriteOutputSingleRegister )
{
// save = true;
cerr << myname << "(updateRTU188): write reg(" << dat2str(r->mbreg) << ") to RTU188 NOT YET!!!" << endl;
return;
}
for( PList::iterator it=r->slst.begin(); it!=r->slst.end(); ++it )
{
try
{
if( it->stype == UniversalIO::DigitalInput )
{
bool set = r->dev->rtu->getState(r->rtuJack,r->rtuChan,it->stype);
IOBase::processingAsDI( &(*it), set, shm, force );
continue;
}
if( it->stype == UniversalIO::AnalogInput )
{
long val = r->dev->rtu->getInt(r->rtuJack,r->rtuChan,it->stype);
IOBase::processingAsAI( &(*it),val, shm, force );
continue;
}
}
catch(IOController_i::NameNotFound &ex)
{
dlog[Debug::LEVEL3] << myname << "(updateMTR):(NameNotFound) " << ex.err << endl;
}
catch(IOController_i::IOBadParam& ex )
{
dlog[Debug::LEVEL3] << myname << "(updateMTR):(IOBadParam) " << ex.err << endl;
}
catch(IONotifyController_i::BadRange )
{
dlog[Debug::LEVEL3] << myname << "(updateMTR): (BadRange)..." << endl;
}
catch( Exception& ex )
{
dlog[Debug::LEVEL3] << myname << "(updateMTR): " << ex << endl;
}
catch(CORBA::SystemException& ex)
{
dlog[Debug::LEVEL3] << myname << "(updateMTR): CORBA::SystemException: "
<< ex.NP_minorString() << endl;
}
catch(...)
{
dlog[Debug::LEVEL3] << myname << "(updateMTR): catch ..." << endl;
}
}
}
// -----------------------------------------------------------------------------
extentions/RTUExchange/RTUExchange.h
View file @ 1b6f351e
......@@ -50,49 +50,116 @@ class RTUExchange:
dtMTR /*!< MTR (DEIF) */
};
static DeviceType getDeviceType( const std::string dtype );
friend std::ostream& operator<<( std::ostream& os, const DeviceType& dt );
// -------------------------------------------------------------------------------
struct RTUDevice;
struct RegInfo;
struct RSProperty:
public IOBase
{
DeviceType devtype; /*!< */
ModbusRTU::ModbusAddr mbaddr; /*!< */
ModbusRTU::ModbusData mbreg; /*!< */
ModbusRTU::SlaveFunctionCode mbfunc; /*!< / */
// only for RTU
short nbit; /*!< bit number (for func=[0x01,0x02]) */
VTypes::VType vType; /*!< type of value */
short rnum; /*!< count of registers */
RSProperty():
nbit(-1),vType(VTypes::vtUnknown),
rnum(VTypes::wsize(VTypes::vtUnknown)),
reg(0)
{}
RegInfo* reg;
};
friend std::ostream& operator<<( std::ostream& os, const RSProperty& p );
typedef std::list<RSProperty> PList;
struct RegInfo
{
RegInfo():
mbval(0),mbreg(0),mbfunc(ModbusRTU::fnUnknown),
mtrType(MTR::mtUnknown),
rtuJack(RTUStorage::nUnknown),rtuChan(0),
dev(0),
q_num(0),q_count(1)
{}
ModbusRTU::ModbusData mbval;
ModbusRTU::ModbusData mbreg; /*!< */
ModbusRTU::SlaveFunctionCode mbfunc; /*!< / */
PList slst;
// only for MTR
MTR::MTRType mtrType; /*!< ( MTR) */
// only for RTU188
RTUStorage* rtu;
RTUStorage::RTUJack rtuJack;
int rtuChan;
RSProperty():
devtype(dtUnknown),
mbaddr(0),mbreg(0),mbfunc(ModbusRTU::fnUnknown),
nbit(-1),vType(VTypes::vtUnknown),
rnum(VTypes::wsize(VTypes::vtUnknown)),
rtu(0),rtuJack(RTUStorage::nUnknown),rtuChan(0)
RTUDevice* dev;
// optimization
int q_num; /*! number in query */
int q_count; /*! count registers for query */
};
friend std::ostream& operator<<( std::ostream& os, RegInfo& r );
typedef std::map<ModbusRTU::ModbusData,RegInfo*> RegMap;
struct RTUDevice
{
RTUDevice():
respnond(false),
mbaddr(0),
dtype(dtUnknown),
resp_id(UniSetTypes::DefaultObjectId),
resp_state(false),
resp_invert(false),
resp_real(false),
rtu(0)
{}
friend std::ostream& operator<<( std::ostream& os, RSProperty& p );
bool respnond;
ModbusRTU::ModbusAddr mbaddr; /*!< */
RegMap regmap;
DeviceType dtype; /*!< */
UniSetTypes::ObjectId resp_id;
IOController::DIOStateList::iterator resp_dit;
PassiveTimer resp_ptTimeout;
Trigger resp_trTimeout;
bool resp_state;
bool resp_invert;
bool resp_real;
RTUStorage* rtu;
// return TRUE if state changed
bool checkRespond();
};
friend std::ostream& operator<<( std::ostream& os, RTUDevice& d );
typedef std::map<ModbusRTU::ModbusAddr,RTUDevice*> RTUDeviceMap;
friend std::ostream& operator<<( std::ostream& os, RTUDeviceMap& d );
void printMap(RTUDeviceMap& d);
// ----------------------------------
protected:
typedef std::vector<RSProperty> RSMap;
RSMap rsmap; /*!< / */
unsigned int maxItem; /*!< ( ) */
RTUDeviceMap rmap;
ModbusRTUMaster* mb;
UniSetTypes::uniset_mutex mbMutex;
std::string devname;
std::string speed;
int recv_timeout;
xmlNode* cnode;
std::string s_field;
......@@ -102,10 +169,12 @@ class RTUExchange:
void step();
void poll();
long pollRTU188( RSMap::iterator& p );
long pollMTR( RSMap::iterator& p );
long pollRTU( RSMap::iterator& p );
void setRespond(ModbusRTU::ModbusAddr addr, bool respond );
void pollRTU( RTUDevice* dev, RegMap::iterator& it );
void updateSM();
void updateRTU(RegMap::iterator& it);
void updateMTR(RegMap::iterator& it);
void updateRTU188(RegMap::iterator& it);
virtual void processingMessage( UniSetTypes::VoidMessage *msg );
void sysCommand( UniSetTypes::SystemMessage *msg );
......@@ -120,29 +189,29 @@ class RTUExchange:
//
virtual void sigterm( int signo );
void initMB();
void initIterators();
bool initItem( UniXML_iterator& it );
bool readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec );
bool initCommParam( UniXML_iterator& it, RSProperty& p );
bool initMTRitem( UniXML_iterator& it, RSProperty& p );
bool initRTU188item( UniXML_iterator& it, RSProperty& p );
bool initRTUitem( UniXML_iterator& it, RSProperty& p );
RTUDevice* addDev( RTUDeviceMap& dmap, ModbusRTU::ModbusAddr a, UniXML_iterator& it );
RegInfo* addReg( RegMap& rmap, ModbusRTU::ModbusData r, UniXML_iterator& it,
RTUDevice* dev, RegInfo* rcopy=0 );
RSProperty* addProp(PList& plist, RSProperty& p );
bool initMTRitem( UniXML_iterator& it, RegInfo* p );
bool initRTU188item( UniXML_iterator& it, RegInfo* p );
bool initRSProperty( RSProperty& p, UniXML_iterator& it );
bool initRegInfo( RegInfo* r, UniXML_iterator& it, RTUDevice* dev );
bool initRTUDevice( RTUDevice* d, UniXML_iterator& it );
bool initRespondInfo( RTUDeviceMap& m, ModbusRTU::ModbusAddr a, UniXML_iterator& it );
void rtuQueryOptimization( RTUDeviceMap& m );
void readConfiguration();
bool check_item( UniXML_iterator& it );
/*
struct RTUInfo
{
RTUInfo():rtu(0),sid_conn(UniSetTypes::DefaultObjectId){}
RTUStorage* rtu;
UniSetTypes::ObjectId sid_conn;
};
*/
typedef std::map<int,RTUStorage*> RTUMap;
RTUMap rtulist;
private:
RTUExchange();
bool initPause;
......@@ -152,6 +221,7 @@ class RTUExchange:
bool force_out; /*!< , */
bool mbregFromID;
int polltime; /*!< , [] */
PassiveTimer ptHeartBeat;
UniSetTypes::ObjectId sidHeartBeat;
int maxHeartBeat;
......@@ -160,28 +230,6 @@ class RTUExchange:
UniSetTypes::uniset_mutex pollMutex;
struct RespondInfo
{
RespondInfo():
id(UniSetTypes::DefaultObjectId),
state(false),
invert(false)
{}
UniSetTypes::ObjectId id;
IOController::DIOStateList::iterator dit;
PassiveTimer ptTimeout;
Trigger trTimeout;
bool state;
bool invert;
};
typedef std::map<ModbusRTU::ModbusAddr,RespondInfo> RespondMap;
RespondMap respMap;
PassiveTimer aiTimer;
int ai_polltime;
bool activated;
int activateTimeout;
};
......
extentions/RTUExchange/RTUStorage.cc
View file @ 1b6f351e
......@@ -267,6 +267,95 @@ bool RTUStorage::getState( RTUJack jack, unsigned short int chan, UniversalIO::I
return false;
}
// -----------------------------------------------------------------------------
ModbusRTU::ModbusData RTUStorage::getRegister( RTUJack jack, unsigned short chan, UniversalIO::IOTypes t )
{
if( t == UniversalIO::AnalogInput )
{
switch( jack )
{
case nJ1:
return 1032+chan;
case nJ2:
return 1032+24+chan;
case nJ5:
return 1000+chan;
case nX1:
return 1016+chan;
case nX2:
return 1016+4+chan;
default:
break;
}
return -1;
}
if( t == UniversalIO::AnalogOutput )
{
switch( jack )
{
case nJ1:
return 1016+chan;
case nJ2:
return 1016+24+chan;
case nJ5:
return 1000+chan;
case nX1:
return 1016+chan;
case nX2:
return 1016+4+chan;
default:
break;
}
return -1;
}
if( t == UniversalIO::DigitalInput )
{
switch( jack )
{
case nJ1:
return 32+chan;
case nJ2:
return 32+24+chan;
case nJ5:
return 16+chan;
case nX4:
return chan;
case nX5:
return 8+chan;
default:
break;
}
return -1;
}
if( t == UniversalIO::DigitalOutput )
{
switch( jack )
{
case nJ1:
return 16+chan;
case nJ2:
return 16+24+chan;
case nJ5:
return chan;
default:
break;
}
return -1;
}
return -1;
}
// -----------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& os, RTUStorage& m )
{
os << "-------------------" << endl
......
extentions/RTUExchange/RTUStorage.h
View file @ 1b6f351e
......@@ -47,6 +47,8 @@ class RTUStorage
float getFloat( RTUJack jack, unsigned short channel, UniversalIO::IOTypes t );
bool getState( RTUJack jack, unsigned short channel, UniversalIO::IOTypes t );
static ModbusRTU::ModbusData getRegister( RTUJack jack, unsigned short channel, UniversalIO::IOTypes t );
// : setState, setValue
void print();
......
extentions/RTUExchange/start_fg.sh
View file @ 1b6f351e
#!/bin/sh
uniset-start.sh -f ./uniset-rtuexchange --rs-name RTUExchange --confile test.xml \
--rs-filter-field rs --rs-filter-value 1 \
--rs-dev /dev/cbsideA0 --rs-reg-from-id 1 \
--rs-filter-field rs --rs-filter-value wago \
--rs-dev /dev/ttyUSB0 \
--dlog-add-levels info,crit,warn
#level3
#,level3
extentions/SharedMemory/SharedMemory.cc
View file @ 1b6f351e
......@@ -411,6 +411,7 @@ void SharedMemory::fastSaveValue(const IOController_i::SensorInfo& si, CORBA::Lo
SharedMemory* SharedMemory::init_smemory( int argc, char* argv[] )
{
string dfile = conf->getArgParam("--datfile",conf->getConfFileName());
if( dfile[0]!='.' && dfile[0]!='/' )
dfile = conf->getConfDir() + dfile;
......
extentions/SharedMemoryPlus/create_links.sh 0 → 100755
View file @ 1b6f351e
#!/bin/sh
ln -s -f /usr/bin/uniset-stop.sh stop.sh
ln -s -f ../../conf/test.xml test.xml
extentions/SharedMemoryPlus/start_fg.sh
View file @ 1b6f351e
......@@ -4,22 +4,21 @@ ulimit -Sc 10000000
START=uniset-start.sh
${START} -f ./uniset-smemory-plus --smemory-id SharedMemory --confile test.xml \
--unideb-add-levels info,crit,warn,level9,system \
--unideb-add-levels info,crit,warn,level9,system,level3,level2,level1 \
--add-io \
--io-force 1 \
--io-name IOControl1 \
--io-name IOControl \
--io-polltime 100 \
--io-s-filter-field io \
--io-s-filter-value ts \
--iodev1 /dev/null
--io-s-filter-value 1 \
--iodev1 /dev/null \
--iodev2 /dev/null \
--io-test-lamp TS_TestLamp_S \
--io-heartbeat-id _31_11_AS \
--io-sm-ready-test-sid TestMode_S \
--add-rtu \
--rtu-device /dev/cbsideA1 \
--rtu-id RTUExchange \
--add-mbslave \
--io-test-lamp RS_Test9_S \
--io-heartbeat-id AI_AS \
--io-sm-ready-test-sid RS_Test9_S
# --add-rtu \
# --rs-dev /dev/cbsideA1 \
# --rs-id RTUExchange \
# --add-mbslave \
#--skip-rtu1 --skip-rtu2 --skip-can --dlog-add-levels info,warn,crit
......
extentions/include/IOBase.h
View file @ 1b6f351e
......@@ -85,6 +85,7 @@ static const int NoSafety = -1;
static void processingAsAI( IOBase* it, long new_val, SMInterface* shm, bool force );
static void processingAsDI( IOBase* it, bool new_set, SMInterface* shm, bool force );
static long processingAsAO( IOBase* it, SMInterface* shm, bool force );
static float processingFasAO( IOBase* it, SMInterface* shm, bool force );
static bool processingAsDO( IOBase* it, SMInterface* shm, bool force );
static bool initItem( IOBase* b, UniXML_iterator& it, SMInterface* shm,
DebugStream* dlog=0, std::string myname="",
......
extentions/include/MTR.h
View file @ 1b6f351e
......@@ -81,7 +81,7 @@ namespace MTR
bool setDataBits( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, mtrDataBits d );
// -------------------------------------------------------------------------
static const int u2size = 2*sizeof(unsigned short);
static const int u2size = 2;
// -------------------------------------------------------------------------
class T1
{
......@@ -129,6 +129,8 @@ namespace MTR
// ...
T3(){ memset(raw.v,0,sizeof(raw.v)); }
T3( signed int i ){ raw.val = i; }
T3( unsigned short v1, unsigned short v2 )
{
raw.v[0] = v1;
......@@ -202,6 +204,7 @@ namespace MTR
unsigned int val:24;
signed char exp; // :8
} __attribute__( ( packed ) ) u2;
long lval;
} T5mem;
// ------------------------------------------
// ...
......@@ -213,6 +216,11 @@ namespace MTR
val = raw.u2.val * pow(10,raw.u2.exp);
}
T5( long v )
{
raw.lval = v;
}
T5( const ModbusRTU::ModbusData* data )
{
if( sizeof(data) >=u2size )
......@@ -247,6 +255,7 @@ namespace MTR
signed int val:24;
signed char exp; // :8
} u2;
long lval;
} T6mem;
// ------------------------------------------
// ...
......@@ -258,6 +267,11 @@ namespace MTR
val = raw.u2.val * pow(10,raw.u2.exp);
}
T6( long v )
{
raw.lval = v;
}
T6( const ModbusRTU::ModbusData* data )
{
if( sizeof(data) >=u2size )
......@@ -293,6 +307,7 @@ namespace MTR
unsigned char ic; // :8 - Inductive/capacitive
unsigned char ie; // :8 - Import/export
}__attribute__( ( packed ) ) u2;
long lval;
} T7mem;
// ------------------------------------------
// ...
......@@ -303,6 +318,10 @@ namespace MTR
raw.v[1] = v2;
val = raw.u2.val * pow(10,-4);
}
T7( const long v )
{
raw.lval = v;
}
T7( const ModbusRTU::ModbusData* data )
{
......@@ -442,6 +461,11 @@ namespace MTR
raw.v[1] = v2;
}
F1( float f )
{
raw.val = f;
}
F1( const ModbusRTU::ModbusData* data )
{
if( sizeof(data) >=u2size )
......
extentions/include/VTypes.h
View file @ 1b6f351e
......@@ -42,6 +42,7 @@ namespace VTypes
// ...
F2(){ memset(raw.v,0,sizeof(raw.v)); }
F2( float f ){ raw.val = f; }
F2( const ModbusRTU::ModbusData* data, int size )
{
for( int i=0; i<wsize() && i<size; i++ )
......@@ -76,6 +77,7 @@ namespace VTypes
// ...
F4(){ memset(raw.v,0,sizeof(raw.v)); }
F4( float f ){ raw.val = f; }
F4( const ModbusRTU::ModbusData* data, int size )
{
for( int i=0; i<wsize() && i<size; i++ )
......
extentions/lib/IOBase.cc
View file @ 1b6f351e
......@@ -148,14 +148,23 @@ void IOBase::processingAsAI( IOBase* it, long val, SMInterface* shm, bool force
shm->localSaveValue( it->ait,it->si.id,val,shm->ID() );
else if( it->stype == UniversalIO::AnalogOutput )
shm->localSetValue( it->ait,it->si.id,val,shm->ID() );
else if( it->stype == UniversalIO::DigitalOutput )
shm->localSetState( it->dit,it->si.id,(bool)val,shm->ID() );
else if( it->stype == UniversalIO::DigitalInput )
shm->localSaveState( it->dit,it->si.id,(bool)val,shm->ID() );
it->value = val;
}
}
}
// -----------------------------------------------------------------------------
void IOBase::processingFasAI( IOBase* it, float val, SMInterface* shm, bool force )
void IOBase::processingFasAI( IOBase* it, float fval, SMInterface* shm, bool force )
{
long val = lroundf(fval);
if( it->cal.precision > 0 )
val = lroundf( fval * pow10(it->cal.precision) );
//
if( it->check_channel_break(val) )
{
......@@ -185,15 +194,16 @@ void IOBase::processingFasAI( IOBase* it, float val, SMInterface* shm, bool forc
if( it->value == ChannelBreakValue )
shm->localSetUndefinedState(it->ait,false,it->si.id);
if( it->cal.precision > 0 )
val *= lroundf(pow10(it->cal.precision));
if( force || it->value != val )
{
if( it->stype == UniversalIO::AnalogInput )
shm->localSaveValue( it->ait,it->si.id,val,shm->ID() );
else if( it->stype == UniversalIO::AnalogOutput )
shm->localSetValue( it->ait,it->si.id,val,shm->ID() );
else if( it->stype == UniversalIO::DigitalOutput )
shm->localSetState( it->dit,it->si.id,(bool)val,shm->ID() );
else if( it->stype == UniversalIO::DigitalInput )
shm->localSaveState( it->dit,it->si.id,(bool)val,shm->ID() );
it->value = val;
}
......@@ -223,6 +233,10 @@ void IOBase::processingAsDI( IOBase* it, bool set, SMInterface* shm, bool force
shm->localSaveState(it->dit,it->si.id,set,shm->ID());
else if( it->stype == UniversalIO::DigitalOutput )
shm->localSetState(it->dit,it->si.id,set,shm->ID());
else if( it->stype == UniversalIO::AnalogInput )
shm->localSaveValue( it->ait,it->si.id,(set ? 1:0),shm->ID() );
else if( it->stype == UniversalIO::AnalogOutput )
shm->localSetValue( it->ait,it->si.id,(set ? 1:0),shm->ID() );
it->value = set ? 1 : 0;
}
......@@ -292,6 +306,52 @@ bool IOBase::processingAsDO( IOBase* it, SMInterface* shm, bool force )
return false;
}
// -----------------------------------------------------------------------------
float IOBase::processingFasAO( IOBase* it, SMInterface* shm, bool force )
{
uniset_spin_lock lock(it->val_lock);
long val = it->value;
if( force )
{
val = shm->localGetValue(it->ait,it->si.id);
it->value = val;
}
if( it->stype == UniversalIO::AnalogOutput ||
it->stype == UniversalIO::AnalogInput )
{
if( it->cdiagram ) //
{
if( it->cprev != it->value )
{
it->cprev = it->value;
val = it->cdiagram->getRawValue(val);
it->craw = val;
}
else
val = it->craw; //
}
else
{
float fval = val;
IOController_i::CalibrateInfo* cal( &(it->cal) );
if( cal->maxRaw!=0 && cal->maxRaw!=cal->minRaw ) //
{
// !!!
fval = UniSetTypes::fcalibrate(fval,
cal->minCal, cal->maxCal, cal->minRaw, cal->maxRaw, true );
}
if( it->cal.precision > 0 )
return ( fval / pow10(it->cal.precision) );
}
}
return val;
}
// -----------------------------------------------------------------------------
bool IOBase::initItem( IOBase* b, UniXML_iterator& it, SMInterface* shm,
DebugStream* dlog, std::string myname,
int def_filtersize, float def_filterT )
......@@ -347,20 +407,12 @@ bool IOBase::initItem( IOBase* b, UniXML_iterator& it, SMInterface* shm,
else
b->safety = NoSafety;
string stype( it.getProp("iotype") );
if( stype == "AI" )
b->stype = UniversalIO::AnalogInput;
else if ( stype == "AO" )
b->stype = UniversalIO::AnalogOutput;
else if ( stype == "DO" )
b->stype = UniversalIO::DigitalOutput;
else if ( stype == "DI" )
b->stype = UniversalIO::DigitalInput;
else
b->stype = UniSetTypes::getIOType(it.getProp("iotype"));
if( b->stype == UniversalIO::UnknownIOType )
{
if( dlog )
dlog[Debug::CRIT] << myname << "(IOBase::readItem): iotype=: "
<< stype << " " << sname << endl;
<< it.getProp("iotype") << " " << sname << endl;
return false;
}
......
extentions/lib/VTypes.cc
View file @ 1b6f351e
......@@ -41,7 +41,7 @@ int wsize( VType t )
if( t == vtF4 )
return F4::wsize();
return 0;
return 1;
}
// -----------------------------------------------------------------------------
} // end of namespace VTypes
......
include/Configuration.h
View file @ 1b6f351e
......@@ -130,8 +130,6 @@ namespace UniSetTypes
std::string getArgParam(const std::string name, const std::string defval="");
xmlNode* initDebug( DebugStream& deb, const std::string& nodename );
static bool file_exist( const std::string filename );
UniSetTypes::ListOfNode::const_iterator listNodesBegin()
{
return lnodes.begin();
......
include/UniSetTypes.h
View file @ 1b6f351e
......@@ -32,6 +32,7 @@
#include <string>
#include <list>
#include <limits>
#include <ostream>
#include <omniORB4/CORBA.h>
#include "UniSetTypes_i.hh"
......@@ -49,6 +50,9 @@ namespace UniSetTypes
typedef CORBA::Object_ptr ObjectPtr; /*!< ObjectRepository */
typedef CORBA::Object_var ObjectVar; /*!< ObjectRepository */
UniversalIO::IOTypes getIOType( const std::string s );
std::ostream& operator<<( std::ostream& os, const UniversalIO::IOTypes t );
/*! */
enum LampCommand
{
......@@ -214,6 +218,8 @@ namespace UniSetTypes
return n;
}
bool file_exist( const std::string filename );
IDList explode( const std::string str, char sep=',' );
}
......
include/modbus/ModbusTypes.h
View file @ 1b6f351e
......@@ -161,6 +161,9 @@ namespace ModbusRTU
operator ModbusData();
ModbusData mdata();
bool operator[]( const int i ){ return b[i]; }
void set( int n, bool s ){ b.set(n,s); }
std::bitset<BitsPerData> b;
};
......
src/Interfaces/UniversalInterface.cc
View file @ 1b6f351e
......@@ -78,6 +78,7 @@ void UniversalInterface::init()
// NameSerivice
// . ޣ
// localIOR
localctx=CosNaming::NamingContext::_nil();
try
{
if( CORBA::is_nil(orb) )
......@@ -88,13 +89,20 @@ void UniversalInterface::init()
else
localctx = ORepHelpers::getRootNamingContext( orb, oind->getRealNodeName(uconf->getLocalNode()) );
}
catch(Exception& ex )
catch( Exception& ex )
{
if( !uconf->isLocalIOR() )
throw ex;
localctx=CosNaming::NamingContext::_nil();
}
catch( ... )
{
if( !uconf->isLocalIOR() )
throw;
localctx=CosNaming::NamingContext::_nil();
}
}
// ------------------------------------------------------------------------------------------------------------
void UniversalInterface::initBackId( UniSetTypes::ObjectId backid )
......@@ -1563,26 +1571,21 @@ void UniversalInterface::registered( UniSetTypes::ObjectId id, UniSetTypes::Obje
{
// ޣ
// IOR
// ݣ
// NameService (omniNames)
if( uconf->isLocalIOR() )
{
if( CORBA::is_nil(orb) )
orb = uconf->getORB();
string sior(orb->object_to_string(oRef));
uconf->iorfile.setIOR(id,node,sior);
uconf->iorfile.setIOR(id,node,orb->object_to_string(oRef));
return;
}
try
{
string nm=oind->getNameById(id, node);
rep.registration(nm,oRef,(bool)force);
rep.registration(oind->getNameById(id, node),oRef,(bool)force);
}
catch(Exception& ex )
{
if( !uconf->isLocalIOR() )
throw;
}
}
......@@ -1591,16 +1594,17 @@ void UniversalInterface::registered( UniSetTypes::ObjectId id, UniSetTypes::Obje
void UniversalInterface::unregister(UniSetTypes::ObjectId id, UniSetTypes::ObjectId node)throw(ORepFailed)
{
if( uconf->isLocalIOR() )
{
uconf->iorfile.unlinkIOR(id,node);
return;
}
try
{
string nm = oind->getNameById(id,node);
rep.unregistration(nm);
rep.unregistration(oind->getNameById(id,node));
}
catch(Exception& ex )
{
if( !uconf->isLocalIOR() )
throw;
}
}
......@@ -1638,14 +1642,17 @@ ObjectPtr UniversalInterface::resolve( ObjectId rid , ObjectId node, int timeout
{
// NameService ,
//
if( CORBA::is_nil(localctx) )
// if( CORBA::is_nil(localctx) )
// {
if( unideb.debugging(Debug::WARN) )
{
unideb[Debug::WARN] << " IOR- " << uconf->oind->getNameById(rid,node) << endl;
throw UniSetTypes::ResolveNameError();
}
throw UniSetTypes::ResolveNameError();
// }
// NameService (omniNames)
unideb[Debug::WARN] << " IOR- " << uconf->oind->getNameById(rid,node)
<< " NameService \n";
// unideb[Debug::WARN] << " IOR- " << uconf->oind->getNameById(rid,node)
// << " NameService \n";
}
}
......@@ -2314,17 +2321,21 @@ bool UniversalInterface::isExist( UniSetTypes::ObjectId id )
{
try
{
/*
try
if( uconf->isLocalIOR() )
{
oref = rcache.resolve(id, uconf->getLocalNode());
}
catch(NameNotFound){}
if( CORBA::is_nil(orb) )
orb = uconf->getORB();
if(!oref)
oref = resolve(id, uconf->getLocalNode());
string sior(uconf->iorfile.getIOR(id,uconf->getLocalNode()));
if( !sior.empty() )
{
CORBA::Object_var oref = orb->string_to_object(sior.c_str());
return rep.isExist( oref );
*/
}
return false;
}
string nm = oind->getNameById(id);
return rep.isExist(nm);
}
......
src/ObjectRepository/UniSetTypes.cc
View file @ 1b6f351e
......@@ -24,6 +24,7 @@
*/
// -----------------------------------------------------------------------------
#include <cmath>
#include <fstream>
#include "UniSetTypes.h"
#include "Configuration.h"
// -----------------------------------------------------------------------------
......@@ -163,6 +164,23 @@ using namespace UniSetTypes;
return seq;
}
// -------------------------------------------------------------------------
bool UniSetTypes::file_exist( const std::string filename )
{
std::ifstream file;
#ifdef HAVE_IOS_NOCREATE
file.open( filename.c_str(), std::ios::in | std::ios::nocreate );
#else
file.open( filename.c_str(), std::ios::in );
#endif
bool result = false;
if( file )
result = true;
file.close();
return result;
}
// -------------------------------------------------------------------------
UniSetTypes::IDList UniSetTypes::explode( const string str, char sep )
{
UniSetTypes::IDList l;
......@@ -184,3 +202,34 @@ using namespace UniSetTypes;
return l;
}
// ------------------------------------------------------------------------------------------
UniversalIO::IOTypes UniSetTypes::getIOType( const std::string stype )
{
if( stype == "AI" )
return UniversalIO::AnalogInput;
if ( stype == "AO" )
return UniversalIO::AnalogOutput;
if ( stype == "DO" )
return UniversalIO::DigitalOutput;
if ( stype == "DI" )
return UniversalIO::DigitalInput;
return UniversalIO::UnknownIOType;
}
// ------------------------------------------------------------------------------------------
std::ostream& UniSetTypes::operator<<( std::ostream& os, const UniversalIO::IOTypes t )
{
if( t == UniversalIO::AnalogInput )
return os << "AI";
if( t == UniversalIO::DigitalInput )
return os << "DI";
if( t == UniversalIO::AnalogOutput )
return os << "AO";
if( t == UniversalIO::DigitalOutput )
return os << "DO";
return os << "UnknownIOType";
}
// ------------------------------------------------------------------------------------------
src/Various/Configuration.cc
View file @ 1b6f351e
......@@ -890,23 +890,6 @@ string Configuration::getPort()
return UniSetDefaultPort;
}
// -------------------------------------------------------------------------
bool Configuration::file_exist( const string filename )
{
std::ifstream file;
#ifdef HAVE_IOS_NOCREATE
file.open( filename.c_str(), std::ios::in | std::ios::nocreate );
#else
file.open( filename.c_str(), std::ios::in );
#endif
bool result(false);
if( file )
result = true;
file.close();
return result;
}
// -------------------------------------------------------------------------
ObjectId Configuration::getSensorID( const std::string name )
{
return oind->getIdByName(conf->getSensorsSection()+"/"+name);
......
src/Various/NCRestorer_XML.cc
View file @ 1b6f351e
......@@ -147,6 +147,9 @@ void NCRestorer_XML::read_list( UniXML& xml, xmlNode* node, IONotifyController*
}
}
break;
default:
break;
}
rslot(xml,it,node);
......@@ -276,21 +279,12 @@ bool NCRestorer_XML::getSensorInfo( UniXML& xml, xmlNode* it, SInfo& inf )
}
}
string iotype(xml.getProp(it,"iotype"));
if( iotype=="DI" )
inf.type=UniversalIO::DigitalInput;
else if( iotype=="AI" )
inf.type=UniversalIO::AnalogInput;
else if( iotype=="AO" )
inf.type=UniversalIO::AnalogOutput;
else if( iotype=="DO" )
inf.type=UniversalIO::DigitalOutput;
else
inf.type = UniSetTypes::getIOType(xml.getProp(it,"iotype"));
if( inf.type == UniversalIO::UnknownIOType )
{
unideb[Debug::CRIT] << "(NCRestorer_XML:getSensorInfo): ("
<< iotype << ") / "
<< xml.getProp(it,"name") << endl;
unideb[Debug::CRIT] << "(NCRestorer_XML:getSensorInfo): unknown iotype=" << xml.getProp(it,"iotype")
<< " for " << xml.getProp(it,"name") << endl;
return false;
}
......
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