Skip to content

U
uniset2
Commit 67691e43 authored by Pavel Vainerman's avatar Pavel Vainerman
Browse files
Options

(ModbusSlave): добавил поддержку "контроля mbfunc".

Теперь для MBSlave разрешены одинаковые регистры для разных mbfunc. Но это нужно включать аргументом --prefix-check-mbfunc 1
parent 566c96f1
Show whitespace changes
Inline Side-by-side
Showing with 135 additions and 94 deletions
extensions/ModbusMaster/MBExchange.cc
View file @ 67691e43
......@@ -472,24 +472,6 @@ bool MBExchange::checkPoll( bool wrFunc )
return true;
}
// -----------------------------------------------------------------------------
MBExchange::RegID MBExchange::genRegID( const ModbusRTU::ModbusData mbreg, const int fn )
{
// формула для вычисления ID
// требования:
// 1. ID > диапазона возможных регистров
// 2. одинаковые регистры, но разные функции должны давать разный ID
// 3. регистры идущие подряд, должна давать ID идущие тоже подряд
// Вообще диапазоны:
// mbreg: 0..65535
// fn: 0...255
int max = numeric_limits<ModbusRTU::ModbusData>::max(); // по идее 65535
int fn_max = numeric_limits<ModbusRTU::ModbusByte>::max(); // по идее 255
// fn необходимо привести к диапазону 0..max
return max + mbreg + max + UniSetTypes::lcalibrate(fn, 0, fn_max, 0, max, false);
}
// ------------------------------------------------------------------------------------------
void MBExchange::printMap( MBExchange::RTUDeviceMap& m )
{
cout << "devices: " << endl;
......@@ -566,7 +548,7 @@ void MBExchange::rtuQueryOptimization( RTUDeviceMap& m )
for( auto it = d->regmap.begin(); it != d->regmap.end(); ++it )
{
auto beg = it;
RegID id = it->second->id; // или собственно it->first
ModbusRTU::RegID id = it->second->id; // или собственно it->first
beg->second->q_num = 1;
beg->second->q_count = 1;
++it;
......@@ -2000,7 +1982,7 @@ MBExchange::RTUDevice* MBExchange::addDev( RTUDeviceMap& mp, ModbusRTU::ModbusAd
return d;
}
// ------------------------------------------------------------------------------------------
MBExchange::RegInfo* MBExchange::addReg( RegMap& mp, RegID id, ModbusRTU::ModbusData r,
MBExchange::RegInfo* MBExchange::addReg( RegMap& mp, ModbusRTU::RegID id, ModbusRTU::ModbusData r,
UniXML::iterator& xmlit, MBExchange::RTUDevice* dev )
{
auto it = mp.find(id);
......@@ -2332,7 +2314,7 @@ bool MBExchange::initItem( UniXML::iterator& it )
// требования:
// - ID > диапазона возможных регитров
// - разные функции должны давать разный ID
RegID rID = genRegID(mbreg, fn);
ModbusRTU::RegID rID = ModbusRTU::genRegID(mbreg, fn);
RegInfo* ri = addReg(dev->regmap, rID, mbreg, it, dev);
......@@ -2424,7 +2406,7 @@ bool MBExchange::initItem( UniXML::iterator& it )
for( auto i = 1; i < p1->rnum; i++ )
{
RegID id1 = genRegID(mbreg + i, ri->mbfunc);
ModbusRTU::RegID id1 = ModbusRTU::genRegID(mbreg + i, ri->mbfunc);
RegInfo* r = addReg(dev->regmap, id1, mbreg + i, it, dev);
r->q_num = i + 1;
r->q_count = 1;
......
extensions/ModbusMaster/MBExchange.h
View file @ 67691e43
......@@ -93,9 +93,7 @@ class MBExchange:
typedef std::list<RSProperty> PList;
static std::ostream& print_plist( std::ostream& os, const PList& p );
typedef unsigned long RegID;
typedef std::map<RegID, RegInfo*> RegMap;
typedef std::map<ModbusRTU::RegID, RegInfo*> RegMap;
struct RegInfo
{
// т.к. RSProperty содержит rwmutex с запрещённым конструктором копирования
......@@ -117,7 +115,7 @@ class MBExchange:
ModbusRTU::ModbusData mbreg; /*!< регистр */
ModbusRTU::SlaveFunctionCode mbfunc; /*!< функция для чтения/записи */
PList slst;
RegID id;
ModbusRTU::RegID id;
RTUDevice* dev;
......@@ -204,8 +202,6 @@ class MBExchange:
void printMap(RTUDeviceMap& d);
// ----------------------------------
static RegID genRegID( const ModbusRTU::ModbusData r, const int fn );
enum Timer
{
tmExchange
......@@ -276,7 +272,7 @@ class MBExchange:
void initOffsetList();
RTUDevice* addDev( RTUDeviceMap& dmap, ModbusRTU::ModbusAddr a, UniXML::iterator& it );
RegInfo* addReg( RegMap& rmap, RegID id, ModbusRTU::ModbusData r, UniXML::iterator& it, RTUDevice* dev );
RegInfo* addReg( RegMap& rmap, ModbusRTU::RegID id, ModbusRTU::ModbusData r, UniXML::iterator& it, RTUDevice* dev );
RSProperty* addProp( PList& plist, RSProperty&& p );
bool initMTRitem( UniXML::iterator& it, RegInfo* p );
......
extensions/ModbusSlave/MBSlave.cc
View file @ 67691e43
......@@ -79,23 +79,18 @@ MBSlave::MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, cons
// int recv_timeout = conf->getArgParam("--" + prefix + "-recv-timeout",it.getProp("recv_timeout")));
string saddr = conf->getArgParam("--" + prefix + "-my-addr", it.getProp("addr"));
addr = ModbusRTU::str2mbAddr(conf->getArg2Param("--" + prefix + "-my-addr", it.getProp("addr"),"0x01"));
if( saddr.empty() )
addr = 0x01;
else
addr = ModbusRTU::str2mbAddr(saddr);
default_mbfunc = conf->getArgPInt("--" + prefix + "-default-mbfunc", it.getProp("default_mbfunc"),0);
mbregFromID = conf->getArgInt("--" + prefix + "-reg-from-id", it.getProp("reg_from_id"));
checkMBFunc = conf->getArgInt("--" + prefix + "-check-mbfunc", it.getProp("check_mbfunc"));
dinfo << myname << "(init): mbregFromID=" << mbregFromID << endl;
respond_id = conf->getSensorID(conf->getArgParam("--" + prefix + "-respond-id", it.getProp("respond_id")));
respond_invert = conf->getArgInt("--" + prefix + "-respond-invert", it.getProp("respond_invert"));
timeout_t reply_tout = conf->getArgInt("--" + prefix + "-reply-timeout", it.getProp("replyTimeout"));
if( reply_tout == 0 )
reply_tout = 3000;
timeout_t reply_tout = conf->getArgPInt("--" + prefix + "-reply-timeout", it.getProp("replyTimeout"),3000);
timeout_t aftersend_pause = conf->getArgInt("--" + prefix + "-aftersend-pause", it.getProp("afterSendPause"));
......@@ -902,6 +897,10 @@ bool MBSlave::initItem( UniXML::iterator& it )
p.mbreg = ModbusRTU::str2mbData(r);
}
int mbfunc = IOBase::initIntProp(it, "mbfunc", prop_prefix, false, default_mbfunc);
p.regID = ModbusRTU::genRegID(p.mbreg,mbfunc);
p.amode = MBSlave::amRW;
string am(IOBase::initProp(it, "accessmode", prop_prefix, false));
......@@ -923,7 +922,7 @@ bool MBSlave::initItem( UniXML::iterator& it )
return false;
}
auto i = iomap.find(p.mbreg);
auto i = iomap.find(p.regID);
if( i != iomap.end() )
{
......@@ -965,7 +964,7 @@ bool MBSlave::initItem( UniXML::iterator& it )
p_dummy.bitreg->bvec[nbit] = std::move(p);
dinfo << myname << "(initItem): add bit register: " << p_dummy.bitreg.get() << endl;
iomap[mbreg] = std::move(p_dummy);
iomap[p.regID] = std::move(p_dummy);
}
return true;
......@@ -978,7 +977,7 @@ bool MBSlave::initItem( UniXML::iterator& it )
p.vtype = VTypes::vtUnknown;
p.wnum = 0;
dinfo << myname << "(initItem): add " << p << endl;
iomap[p.mbreg] = std::move(p);
iomap[p.regID] = std::move(p);
}
else
{
......@@ -1021,7 +1020,8 @@ bool MBSlave::initItem( UniXML::iterator& it )
p.mbreg += i;
p.wnum += i;
dinfo << myname << "(initItem): add " << p << endl;
iomap[p.mbreg] = std::move(p);
p.regID = genRegID(p.mbreg,mbfunc);
iomap[p.regID] = std::move(p);
}
}
......@@ -1056,7 +1056,6 @@ void MBSlave::initIterators()
}
}
shm->initIterator(itHeartBeat);
shm->initIterator(itAskCount);
shm->initIterator(itRespond);
......@@ -1084,6 +1083,9 @@ void MBSlave::help_print( int argc, const char* const* argv )
cout << "--prefix-reply-timeout msec - Контрольное время для формирования ответа. " << endl
<< " Если обработка запроса превысит это время, ответ не будет послан (timeout)." << endl
<< " По умолчанию: 3 сек" << endl;
cout << "--prefix-default-mbfunc [0..255] - Функция по умолчанию, если не указан параметр mbfunc в настройках регистра. Только если включён контроль функций. " << endl;
cout << "--prefix-check-mbfunc [0|1] - Включить контроль (обработку) свойства mbfunc. По умолчанию: отключён." << endl;
cout << "--prefix-set-prop-prefix [val] - Использовать для свойств указанный или пустой префикс." << endl;
cout << "--prefix-allow-setdatetime - On set date and time (0x50) modbus function" << endl;
......@@ -1150,7 +1152,8 @@ std::ostream& operator<<( std::ostream& os, MBSlave::IOProperty& p )
<< " wnum=" << p.wnum
<< " nbyte=" << p.nbyte
<< " safety=" << p.safety
<< " invert=" << p.invert;
<< " invert=" << p.invert
<< " regID=" << p.regID;
if( p.stype == UniversalIO::AI || p.stype == UniversalIO::AO )
{
......@@ -1180,7 +1183,7 @@ ModbusRTU::mbErrCode MBSlave::readOutputRegisters( ModbusRTU::ReadOutputMessage&
}
// Фомирование ответа:
ModbusRTU::mbErrCode ret = much_real_read(query.start, buf, query.count);
ModbusRTU::mbErrCode ret = much_real_read(query.start, buf, query.count, query.func);
if( ret == ModbusRTU::erNoError )
{
......@@ -1198,7 +1201,7 @@ ModbusRTU::mbErrCode MBSlave::writeOutputRegisters( ModbusRTU::WriteOutputMessag
dinfo << myname << "(writeOutputRegisters): " << query << endl;
// Формирование ответа:
ModbusRTU::mbErrCode ret = much_real_write(query.start, query.data, query.quant);
ModbusRTU::mbErrCode ret = much_real_write(query.start, query.data, query.quant, query.func);
if( ret == ModbusRTU::erNoError )
reply.set(query.start, query.quant);
......@@ -1211,7 +1214,7 @@ ModbusRTU::mbErrCode MBSlave::writeOutputSingleRegister( ModbusRTU::WriteSingleO
{
dinfo << myname << "(writeOutputSingleRegisters): " << query << endl;
ModbusRTU::mbErrCode ret = real_write(query.start, query.data);
ModbusRTU::mbErrCode ret = real_write(query.start, query.data, query.func);
if( ret == ModbusRTU::erNoError )
reply.set(query.start, query.data);
......@@ -1219,8 +1222,8 @@ ModbusRTU::mbErrCode MBSlave::writeOutputSingleRegister( ModbusRTU::WriteSingleO
return ret;
}
// -------------------------------------------------------------------------
ModbusRTU::mbErrCode MBSlave::much_real_write( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat,
int count )
ModbusRTU::mbErrCode MBSlave::much_real_write( const ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat,
int count, const int fn )
{
dinfo << myname << "(much_real_write): write mbID="
<< ModbusRTU::dat2str(reg) << "(" << (int)reg << ")" << " count=" << count << endl;
......@@ -1228,13 +1231,16 @@ ModbusRTU::mbErrCode MBSlave::much_real_write( ModbusRTU::ModbusData reg, Modbus
int i = 0;
auto it = iomap.end();
int mbfunc = checkMBFunc ? fn : default_mbfunc;
ModbusRTU::RegID regID = genRegID(reg,mbfunc);
for( ; i < count; i++ )
{
it = iomap.find(reg + i);
it = iomap.find(regID);
if( it != iomap.end() )
{
reg += i;
regID += i;
break;
}
}
......@@ -1242,9 +1248,9 @@ ModbusRTU::mbErrCode MBSlave::much_real_write( ModbusRTU::ModbusData reg, Modbus
if( it == iomap.end() )
return ModbusRTU::erBadDataAddress;
for( ; (it != iomap.end()) && (i < count); i++, reg++ )
for( ; (it != iomap.end()) && (i < count); i++, regID++ )
{
if( it->first == reg )
if( it->first == regID )
{
real_write_it(it, dat, i, count);
--i; // т.к. внутри real_write_it будет сделан ++
......@@ -1255,14 +1261,14 @@ ModbusRTU::mbErrCode MBSlave::much_real_write( ModbusRTU::ModbusData reg, Modbus
return ModbusRTU::erNoError;
}
// -------------------------------------------------------------------------
ModbusRTU::mbErrCode MBSlave::real_write( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData val )
ModbusRTU::mbErrCode MBSlave::real_write( const ModbusRTU::ModbusData reg, ModbusRTU::ModbusData val, const int fn )
{
ModbusRTU::ModbusData dat[1] = {val};
int i = 0;
return real_write(reg, dat, i, 1);
return real_write(reg, dat, i, 1, fn);
}
// -------------------------------------------------------------------------
ModbusRTU::mbErrCode MBSlave::real_write( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat, int& i, int count )
ModbusRTU::mbErrCode MBSlave::real_write( const ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat, int& i, int count, const int fn )
{
ModbusRTU::ModbusData mbval = dat[i];
......@@ -1271,7 +1277,9 @@ ModbusRTU::mbErrCode MBSlave::real_write( ModbusRTU::ModbusData reg, ModbusRTU::
<< " data=" << ModbusRTU::dat2str(mbval)
<< "(" << (int)mbval << ")" << endl;
auto it = iomap.find(reg);
ModbusRTU::RegID regID = checkMBFunc ? genRegID(reg,fn) : genRegID(reg,default_mbfunc);
auto it = iomap.find(regID);
return real_write_it(it, dat, i, count);
}
// -------------------------------------------------------------------------
......@@ -1520,22 +1528,25 @@ ModbusRTU::mbErrCode MBSlave::real_write_prop( IOProperty* p, ModbusRTU::ModbusD
return ModbusRTU::erTimeOut;
}
// -------------------------------------------------------------------------
ModbusRTU::mbErrCode MBSlave::much_real_read( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat,
int count )
ModbusRTU::mbErrCode MBSlave::much_real_read( const ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat,
int count, const int fn )
{
dinfo << myname << "(much_real_read): read mbID="
<< ModbusRTU::dat2str(reg) << "(" << (int)reg << ") " << " count=" << count << endl;
<< ModbusRTU::dat2str(reg) << "(" << (int)reg << ") " << " count=" << count
<< " mbfunc=" << fn << endl;
int mbfunc = checkMBFunc ? fn : default_mbfunc;
auto it = iomap.end();
int i = 0;
ModbusRTU::RegID regID = genRegID(reg,mbfunc);
for( ; i < count; i++ )
{
it = iomap.find(reg + i);
it = iomap.find(regID+i);
if( it != iomap.end() )
{
reg += i;
regID += i;
break;
}
......@@ -1547,12 +1558,12 @@ ModbusRTU::mbErrCode MBSlave::much_real_read( ModbusRTU::ModbusData reg, ModbusR
ModbusRTU::ModbusData val = 0;
for( ; (it != iomap.end()) && (i < count); i++, reg++ )
for( ; (it != iomap.end()) && (i < count); i++, regID++ )
{
val = 0;
// если регистры идут не подряд, то просто вернём ноль
if( it->first == reg )
if( it->first == regID )
{
real_read_it(it, val);
++it;
......@@ -1572,12 +1583,14 @@ ModbusRTU::mbErrCode MBSlave::much_real_read( ModbusRTU::ModbusData reg, ModbusR
return ModbusRTU::erNoError;
}
// -------------------------------------------------------------------------
ModbusRTU::mbErrCode MBSlave::real_read( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData& val )
ModbusRTU::mbErrCode MBSlave::real_read( const ModbusRTU::ModbusData reg, ModbusRTU::ModbusData& val, const int fn )
{
dinfo << myname << "(real_read): read mbID="
<< ModbusRTU::dat2str(reg) << "(" << (int)reg << ")" << endl;
<< ModbusRTU::dat2str(reg) << "(" << (int)reg << ")" << " fn=" << fn << endl;
ModbusRTU::RegID regID = checkMBFunc ? genRegID(reg,fn) : genRegID(reg,default_mbfunc);
auto it = iomap.find(reg);
auto it = iomap.find(regID);
return real_read_it(it, val);
}
// -------------------------------------------------------------------------
......@@ -1586,11 +1599,11 @@ ModbusRTU::mbErrCode MBSlave::real_read_it( IOMap::iterator& it, ModbusRTU::Modb
if( it == iomap.end() )
return ModbusRTU::erBadDataAddress;
dinfo << myname << "(real_read_it): read mbID="
<< ModbusRTU::dat2str(it->first) << "(" << (int)it->first << ")" << endl;
IOProperty* p(&it->second);
dinfo << myname << "(real_read_it): read mbID="
<< ModbusRTU::dat2str(p->mbreg) << "(" << (int)(p->mbreg) << ")" << endl;
if( p->bitreg )
return real_bitreg_read_it(p->bitreg, val);
......@@ -1766,7 +1779,7 @@ mbErrCode MBSlave::readInputRegisters( ReadInputMessage& query, ReadInputRetMess
if( query.count <= 1 )
{
ModbusRTU::ModbusData d = 0;
ModbusRTU::mbErrCode ret = real_read(query.start, d);
ModbusRTU::mbErrCode ret = real_read(query.start, d,query.func);
if( ret == ModbusRTU::erNoError )
reply.addData(d);
......@@ -1777,7 +1790,7 @@ mbErrCode MBSlave::readInputRegisters( ReadInputMessage& query, ReadInputRetMess
}
// Фомирование ответа:
ModbusRTU::mbErrCode ret = much_real_read(query.start, buf, query.count);
ModbusRTU::mbErrCode ret = much_real_read(query.start, buf, query.count, query.func);
if( ret == ModbusRTU::erNoError )
{
......@@ -1825,7 +1838,7 @@ ModbusRTU::mbErrCode MBSlave::readCoilStatus( ReadCoilMessage& query,
if( query.count <= 1 )
{
ModbusRTU::ModbusData d = 0;
ModbusRTU::mbErrCode ret = real_read(query.start, d);
ModbusRTU::mbErrCode ret = real_read(query.start, d,query.func);
reply.addData(0);
if( ret == ModbusRTU::erNoError )
......@@ -1837,7 +1850,7 @@ ModbusRTU::mbErrCode MBSlave::readCoilStatus( ReadCoilMessage& query,
return ret;
}
much_real_read(query.start, buf, query.count);
much_real_read(query.start, buf, query.count, query.func);
int bnum = 0;
unsigned int i = 0;
......@@ -1890,7 +1903,7 @@ ModbusRTU::mbErrCode MBSlave::readInputStatus( ReadInputStatusMessage& query,
if( query.count <= 1 )
{
ModbusRTU::ModbusData d = 0;
ModbusRTU::mbErrCode ret = real_read(query.start, d);
ModbusRTU::mbErrCode ret = real_read(query.start, d, query.func);
reply.addData(0);
if( ret == ModbusRTU::erNoError )
......@@ -1902,7 +1915,7 @@ ModbusRTU::mbErrCode MBSlave::readInputStatus( ReadInputStatusMessage& query,
return ret;
}
much_real_read(query.start, buf, query.count);
much_real_read(query.start, buf, query.count, query.func);
int bnum = 0;
unsigned int i = 0;
......@@ -1960,7 +1973,7 @@ ModbusRTU::mbErrCode MBSlave::forceMultipleCoils( ModbusRTU::ForceCoilsMessage&
for( auto k = 0; k < ModbusRTU::BitsPerByte && nbit < query.quant; k++, nbit++ )
{
// ModbusRTU::mbErrCode ret =
real_write(query.start + nbit, (b[k] ? 1 : 0) );
real_write(query.start + nbit, (b[k] ? 1 : 0), query.func );
//if( ret == ModbusRTU::erNoError )
}
}
......@@ -1977,7 +1990,7 @@ ModbusRTU::mbErrCode MBSlave::forceSingleCoil( ModbusRTU::ForceSingleCoilMessage
{
dinfo << myname << "(forceSingleCoil): " << query << endl;
ModbusRTU::mbErrCode ret = real_write(query.start, (query.cmd() ? 1 : 0) );
ModbusRTU::mbErrCode ret = real_write(query.start, (query.cmd() ? 1 : 0), query.func );
if( ret == ModbusRTU::erNoError )
reply.set(query.start, query.data);
......
extensions/ModbusSlave/MBSlave.h
View file @ 67691e43
......@@ -304,6 +304,7 @@ class MBSlave:
int nbyte; /*!< номер байта, который надо "сохранить" из "пришедщего в запросе" слова. [1-2] */
bool rawdata; /*!< флаг, что в SM просто сохраняются 4-байта (актуально для типа F4)*/
std::shared_ptr<BitRegProperty> bitreg; /*!< указатель, как признак является ли данный регистр "сборным" из битовых */
ModbusRTU::RegID regID;
IOProperty():
mbreg(0),
......@@ -311,7 +312,8 @@ class MBSlave:
vtype(VTypes::vtUnknown),
wnum(0),
nbyte(0),
rawdata(false)
rawdata(false),
regID(0)
{}
friend std::ostream& operator<<( std::ostream& os, IOProperty& p );
......@@ -404,7 +406,7 @@ class MBSlave:
// т.к. в функциях (much_real_read,nuch_real_write) рассчёт на отсортированность IOMap
// то использовать unordered_map нельзя
typedef std::map<ModbusRTU::ModbusData, IOProperty> IOMap;
typedef std::map<ModbusRTU::RegID, IOProperty> IOMap;
IOMap iomap; /*!< список входов/выходов */
std::shared_ptr<ModbusServerSlot> mbslot;
......@@ -413,6 +415,7 @@ class MBSlave:
xmlNode* cnode;
std::string s_field;
std::string s_fvalue;
int default_mbfunc={0}; // функция по умолчанию, для вычисления RegID
std::shared_ptr<SMInterface> shm;
......@@ -437,17 +440,16 @@ class MBSlave:
void readConfiguration();
bool check_item( UniXML::iterator& it );
ModbusRTU::mbErrCode real_write( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData val );
ModbusRTU::mbErrCode real_write( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat, int& i, int count );
ModbusRTU::mbErrCode real_read( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData& val );
ModbusRTU::mbErrCode much_real_read( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat, int count );
ModbusRTU::mbErrCode much_real_write( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat, int count );
ModbusRTU::mbErrCode real_write( const ModbusRTU::ModbusData reg, ModbusRTU::ModbusData val, const int fn=0 );
ModbusRTU::mbErrCode real_write( const ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat, int& i, int count, const int fn=0 );
ModbusRTU::mbErrCode real_read( const ModbusRTU::ModbusData reg, ModbusRTU::ModbusData& val, const int fn=0 );
ModbusRTU::mbErrCode much_real_read( const ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat, int count, const int fn=0 );
ModbusRTU::mbErrCode much_real_write( const ModbusRTU::ModbusData reg, ModbusRTU::ModbusData* dat, int count, const int fn=0 );
ModbusRTU::mbErrCode real_read_it( IOMap::iterator& it, ModbusRTU::ModbusData& val );
ModbusRTU::mbErrCode real_bitreg_read_it( std::shared_ptr<BitRegProperty>& bp, ModbusRTU::ModbusData& val );
ModbusRTU::mbErrCode real_read_prop( IOProperty* p, ModbusRTU::ModbusData& val );
ModbusRTU::mbErrCode real_write_it( IOMap::iterator& it, ModbusRTU::ModbusData* dat, int& i, int count );
ModbusRTU::mbErrCode real_bitreg_write_it( std::shared_ptr<BitRegProperty>& bp, const ModbusRTU::ModbusData val );
ModbusRTU::mbErrCode real_write_prop( IOProperty* p, ModbusRTU::ModbusData* dat, int& i, int count );
......@@ -482,7 +484,8 @@ class MBSlave:
timeout_t wait_msec;
bool force; /*!< флаг означающий, что надо сохранять в SM, даже если значение не менялось */
bool mbregFromID;
bool mbregFromID={0};
bool checkMBFunc={0};
typedef std::unordered_map<int, std::string> FileList;
FileList flist;
......
extensions/ModbusSlave/tests/test_mbslave.cc
View file @ 67691e43
......@@ -454,7 +454,7 @@ TEST_CASE("(0x10): write register outputs or memories", "[modbus][mbslave][mbtcp
}
}
TEST_CASE("Read(0x03,0x04): vtypes..", "[modbus][mbslave][mbtcpslave]")
TEST_CASE("Read(0x03,0x04): vtypes..", "[modbus][mbslave][mbread][mbtcpslave]")
{
using namespace VTypes;
InitTest();
......@@ -475,6 +475,7 @@ TEST_CASE("Read(0x03,0x04): vtypes..", "[modbus][mbslave][mbtcpslave]")
REQUIRE( (int)i2 == -100000 );
}
}
#if 0
SECTION("Test: read vtype 'I2r'")
{
ModbusRTU::ModbusData tREG = 102;
......@@ -603,6 +604,7 @@ TEST_CASE("Read(0x03,0x04): vtypes..", "[modbus][mbslave][mbtcpslave]")
REQUIRE( (unsigned short)b == 200 );
}
}
#endif
}
// -------------------------------------------------------------
......
include/modbus/ModbusTypes.h
View file @ 67691e43
......@@ -74,6 +74,17 @@ namespace ModbusRTU
// 21 ...65535 RESERVED
};
typedef unsigned long RegID;
/*! Получение уникального ID (hash?) на основе номера функции и регистра
* Требования к данной функции:
* 1. ID > диапазона возможных регистров (>65535)
* 2. одинаковые регистры, но разные функции должны давать разный ID
* 3. регистры идущие подряд, должны давать ID идущие тоже подряд
*/
RegID genRegID( const ModbusRTU::ModbusData r, const int fn );
// определение размера данных в зависимости от типа сообщения
// возвращает -1 - если динамический размер сообщения или размер неизвестен
int szRequestDiagnosticData( DiagnosticsSubFunction f );
......
src/Communications/Modbus/ModbusTypes.cc
View file @ 67691e43
#include <assert.h>
#include <string>
#include <iostream>
#include <limits>
#include <sstream>
#include <iomanip>
#include "modbus/ModbusTypes.h"
......@@ -3558,3 +3559,15 @@ std::string ModbusRTU::rdi2str( int id )
return s.str();
}
// -----------------------------------------------------------------------
ModbusRTU::RegID ModbusRTU::genRegID( const ModbusRTU::ModbusData mbreg, const int fn )
{
// диапазоны:
// mbreg: 0..65535
// fn: 0...255
int max = numeric_limits<ModbusRTU::ModbusData>::max(); // по идее 65535
int fn_max = numeric_limits<ModbusRTU::ModbusByte>::max(); // по идее 255
// fn необходимо привести к диапазону 0..max
return max + mbreg + max + UniSetTypes::lcalibrate(fn, 0, fn_max, 0, max, false);
}
// -----------------------------------------------------------------------
tests/test_modbustypes.cc
View file @ 67691e43
#include <catch.hpp>
#include <limits>
#include "modbus/ModbusTypes.h"
using namespace std;
// ---------------------------------------------------------------
TEST_CASE("WriteOutputMessage", "[modbus][WriteOutputMessage]" )
{
SECTION("WriteOutputMessage: limit the amount of data verification")
......@@ -19,7 +20,7 @@ TEST_CASE("WriteOutputMessage", "[modbus][WriteOutputMessage]" )
WARN("Tests for 'Modbus types' incomplete..");
}
// ---------------------------------------------------------------
TEST_CASE("Modbus helpers", "[modbus][helpers]" )
{
using namespace ModbusRTU;
......@@ -70,7 +71,7 @@ TEST_CASE("Modbus helpers", "[modbus][helpers]" )
REQUIRE( b2str(-1) == "ff" );
}
}
// ---------------------------------------------------------------
#if 0
/*! \TODO Надо ещё подумать как тут протестировать */
TEST_CASE("dat2f", "[modbus]" )
......@@ -81,7 +82,7 @@ TEST_CASE("dat2f", "[modbus]" )
// REQUIRE( dat2f(0xff,0xff) == 0.0f );
}
#endif
// ---------------------------------------------------------------
TEST_CASE("isWriteFunction", "[modbus][isWriteFunction]" )
{
using namespace ModbusRTU;
......@@ -104,8 +105,28 @@ TEST_CASE("isWriteFunction", "[modbus][isWriteFunction]" )
CHECK_FALSE( isWriteFunction(fnJournalCommand) );
CHECK_FALSE( isWriteFunction(fnFileTransfer) );
}
// ---------------------------------------------------------------
TEST_CASE("checkCRC", "[modbus][checkCRC]" )
{
// ModbusCRC checkCRC( ModbusByte* start, int len );
}
// ---------------------------------------------------------------
#if 0
#warning VERY LONG TIME TEST
TEST_CASE("genRegID", "[modbus][genRegID]" )
{
int max_reg = numeric_limits<ModbusRTU::ModbusData>::max();
int max_fn = numeric_limits<ModbusRTU::ModbusByte>::max();
ModbusRTU::RegID prevID = ModbusRTU::genRegID(0,0);
for( int f=1; f<max_fn; f++ )
{
ModbusRTU::RegID minID = ModbusRTU::genRegID(0,f);
REQUIRE( minID > prevID );
for( int r=1; r<max_reg; r++ )
REQUIRE( ModbusRTU::genRegID(r,f) == minID+r );
}
}
#endif
// ---------------------------------------------------------------
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