kiug / qmodbus Goto Github PK

void QModbusBits::setValue (unsigned int index, bool value)
{
	operator[](index) = value; // no error handling at all, in release mode SEGFAULT when using invalid index
}


qint8 QModbusRegisters::getInteger8 (int index, bool low)
{
	if (size () <= (int)index) {
		modbusError.set (OUT_OF_RANGE_ENO);
		// error flag is set, but function continues to run until SEGFAULT further below
		// instead, should throw an exception or raise and assertion
	}
	else {
		modbusError.clear();
	}

	qint16 value = 0;
	((qint16 *) &value)[0] = at (index);

	if ( low )
		return getLowByte( value );
	else
		return getHighByte( value );
}

void QModbusMaster::setResponseTimeout (uint32_t sec, uint32_t usec)
{
//    struct timeval timeout;
//    timeout.tv_sec = sec;
//    timeout.tv_usec = usec;
//    modbus_set_response_timeout ((modbus_t *) ctx, &timeout);

	modbus_set_response_timeout ((modbus_t *) ctx, sec, usec);
	// Error handling, i.e. check for return code is missing; user code has no
	// way to know that setting the time out may have failed
}

// setter functions - return value for convenience, same as 
// manually checking for modbusMaster->lastError().isValid()
if (!modbusMaster->setSomeValue(x,y))
    qCritical() << modbusMaster->lastError().message();

// getter functions - user code is responsible for checking return value,
// as errors are anticipated
int hl = modbusMaster->getHeaderLength();
if (modbusMaster->lastError().isValid())
    qCritical() << modbusMaster->lastError().message();


// Option A)
// checking for invalid arguments via ASSERTS - may be problematic, as asserts are not
// being used in release code and if index is provided by user input, software could SEGFAULT
void QModbusRegisters::setValue (int index, quint16 value) {
	// assert should deliver context information on programmers error
	Q_ASSERT_X(index >= 0 && index < size(), "QModbusRegisters::setValue", "index out of range");
	operator [] (index) = value;
}


// Option B)
// check errors via Exception class (as QModbus is C++ code, exceptions are ok)

class QModbusException : public std::exception {
public:
	QModbusException();
	QModbusException(const QModbusException&);
	QModbusException(const QString & context, const QString & msg);
};

void QModbusRegisters::setValue (int index, quint16 value) {
	// assert should deliver context information on programmers error
	if (index >= 0 && index < size())
		throw QModbusException("QModbusRegisters::setValue", QString("Index %1 out of range (size = %2)").arg(index).arg(size());
	operator [] (index) = value;
}

void QModbusRegisters::setFloat32 (unsigned int index, float value)
{
    if (size () <= (int)index + 1) {
        modbusError.set (OUT_OF_RANGE_ENO);
    }
    else {
        modbusError.clear ();
    }
    twoRegistersRepresentation valueRep;
    valueRep.float32 = value;
    operator [] (index) = valueRep.component[0];
    operator [] (index + 1) = valueRep.component[1];
}