wirenboard / wb-mqtt-serial / 1

Committed 08 Jul 2025 01:20PM UTC coverage: 73.854% (+1.0%) from 72.836%

Build # 1

Build Type

Pull #963

github

Specific Base 39d9bc

Committed by

KraPete

Commit Message

Bump version

Pull Request Pull Request #963: Bump version

Run Details

6444 of 9057 branches covered (71.15%)

12341 of 16710 relevant lines covered (73.85%)

305.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.44

/src/devices/modbus_device.cpp

#include "modbus_device.h"
#include "modbus_common.h"

namespace
{
    const TRegisterTypes ModbusRegisterTypes({{Modbus::REG_HOLDING, "holding", "value", U16},
                                              {Modbus::REG_HOLDING_SINGLE, "holding_single", "value", U16},
                                              {Modbus::REG_HOLDING_MULTI, "holding_multi", "value", U16},
                                              {Modbus::REG_COIL, "coil", "switch", U8},
                                              {Modbus::REG_DISCRETE, "discrete", "switch", U8, true},
                                              {Modbus::REG_INPUT, "input", "value", U16, true},
                                              {Modbus::REG_INPUT, "press_counter", "value", U16, true}});

    class TModbusProtocol: public IProtocol
    {
    public:
        TModbusProtocol(const char* name): IProtocol(name, ModbusRegisterTypes)
        {}

        bool IsSameSlaveId(const std::string& id1, const std::string& id2) const override
        {
            return (TUInt32SlaveId(id1) == TUInt32SlaveId(id2));
        }

        bool IsModbus() const override
        {
            return true;
        }
    };
}

void TModbusDevice::Register(TSerialDeviceFactory& factory)
{
    factory.RegisterProtocol(
        new TModbusProtocol("modbus"),
        new TModbusDeviceFactory<TModbusDevice>(std::make_unique<Modbus::TModbusRTUTraitsFactory>()));
    factory.RegisterProtocol(
        new TModbusProtocol("modbus-tcp"),
        new TModbusDeviceFactory<TModbusDevice>(std::make_unique<Modbus::TModbusTCPTraitsFactory>()));
}

TModbusDevice::TModbusDevice(std::unique_ptr<Modbus::IModbusTraits> modbusTraits,
                             const TModbusDeviceConfig& config,
                             PProtocol protocol)
    : TSerialDevice(config.CommonConfig, protocol),
      TUInt32SlaveId(config.CommonConfig->SlaveId),
      ModbusTraits(std::move(modbusTraits)),
      ResponseTime(std::chrono::milliseconds::zero()),
      EnableWbContinuousRead(config.EnableWbContinuousRead),
      ContinuousReadEnabled(false)
{}

bool TModbusDevice::GetForceFrameTimeout()
{
    return ModbusTraits->GetForceFrameTimeout();
}

bool TModbusDevice::GetContinuousReadEnabled()
{
    return ContinuousReadEnabled;
}

PRegisterRange TModbusDevice::CreateRegisterRange() const
{
    return Modbus::CreateRegisterRange(ResponseTime.GetValue());
}

void TModbusDevice::PrepareImpl(TPort& port)
{
    TSerialDevice::PrepareImpl(port);
    if (GetConnectionState() != TDeviceConnectionState::CONNECTED && EnableWbContinuousRead) {
        ContinuousReadEnabled =
            Modbus::EnableWbContinuousRead(shared_from_this(), *ModbusTraits, port, SlaveId, ModbusCache);
    }
}

void TModbusDevice::WriteRegisterImpl(TPort& port, const TRegisterConfig& reg, const TRegisterValue& value)
{
    Modbus::WriteRegister(*ModbusTraits,
                          port,
                          SlaveId,
                          reg,
                          value,
                          ModbusCache,
                          DeviceConfig()->RequestDelay,
                          GetResponseTimeout(port),
                          GetFrameTimeout(port));
}

void TModbusDevice::ReadRegisterRange(TPort& port, PRegisterRange range)
{
    auto modbus_range = std::dynamic_pointer_cast<Modbus::TModbusRegisterRange>(range);
    if (!modbus_range) {
        throw std::runtime_error("modbus range expected");
    }
    Modbus::ReadRegisterRange(*ModbusTraits, port, SlaveId, *modbus_range, ModbusCache);
    ResponseTime.AddValue(modbus_range->GetResponseTime());
}

void TModbusDevice::WriteSetupRegisters(TPort& port)
{
    Modbus::WriteSetupRegisters(*ModbusTraits,
                                port,
                                SlaveId,
                                GetSetupItems(),
                                ModbusCache,
                                DeviceConfig()->RequestDelay,
                                GetResponseTimeout(port),
                                GetFrameTimeout(port));
}

std::chrono::milliseconds TModbusDevice::GetFrameTimeout(TPort& port) const
{
    return std::max(
        DeviceConfig()->FrameTimeout,
        std::chrono::ceil<std::chrono::milliseconds>(port.GetSendTimeBytes(Modbus::STANDARD_FRAME_TIMEOUT_BYTES)));
}

1	#include "modbus_device.h"
2	#include "modbus_common.h"
3
4	namespace
5	{
6	const TRegisterTypes ModbusRegisterTypes({{Modbus::REG_HOLDING, "holding", "value", U16},
7	{Modbus::REG_HOLDING_SINGLE, "holding_single", "value", U16},
8	{Modbus::REG_HOLDING_MULTI, "holding_multi", "value", U16},
9	{Modbus::REG_COIL, "coil", "switch", U8},
10	{Modbus::REG_DISCRETE, "discrete", "switch", U8, true},
11	{Modbus::REG_INPUT, "input", "value", U16, true},
12	{Modbus::REG_INPUT, "press_counter", "value", U16, true}});
13
14	class TModbusProtocol: public IProtocol
15	{
16	public:
17	TModbusProtocol(const char* name): IProtocol(name, ModbusRegisterTypes)	312✔
18	{}	312✔
19
20	bool IsSameSlaveId(const std::string& id1, const std::string& id2) const override	28✔
21	{
22	return (TUInt32SlaveId(id1) == TUInt32SlaveId(id2));	28✔
23	}
24
25	bool IsModbus() const override	×
26	{
27	return true;	×
28	}
29	};
30	}
31
32	void TModbusDevice::Register(TSerialDeviceFactory& factory)	156✔
33	{
34	factory.RegisterProtocol(	156✔
35	new TModbusProtocol("modbus"),	156✔
36	new TModbusDeviceFactory<TModbusDevice>(std::make_unique<Modbus::TModbusRTUTraitsFactory>()));	312✔
37	factory.RegisterProtocol(	156✔
38	new TModbusProtocol("modbus-tcp"),	156✔
39	new TModbusDeviceFactory<TModbusDevice>(std::make_unique<Modbus::TModbusTCPTraitsFactory>()));	312✔
40	}	156✔
41
42	TModbusDevice::TModbusDevice(std::unique_ptr<Modbus::IModbusTraits> modbusTraits,	92✔
43	const TModbusDeviceConfig& config,
44	PProtocol protocol)	92✔
45	: TSerialDevice(config.CommonConfig, protocol),	92✔
46	TUInt32SlaveId(config.CommonConfig->SlaveId),	184✔
47	ModbusTraits(std::move(modbusTraits)),	92✔
48	ResponseTime(std::chrono::milliseconds::zero()),	×
49	EnableWbContinuousRead(config.EnableWbContinuousRead),	92✔
50	ContinuousReadEnabled(false)	92✔
51	{}	92✔
52
53	bool TModbusDevice::GetForceFrameTimeout()	956✔
54	{
55	return ModbusTraits->GetForceFrameTimeout();	956✔
56	}
57
58	bool TModbusDevice::GetContinuousReadEnabled()	956✔
59	{
60	return ContinuousReadEnabled;	956✔
61	}
62
63	PRegisterRange TModbusDevice::CreateRegisterRange() const	482✔
64	{
65	return Modbus::CreateRegisterRange(ResponseTime.GetValue());	482✔
66	}
67
68	void TModbusDevice::PrepareImpl(TPort& port)	65✔
69	{
70	TSerialDevice::PrepareImpl(port);	65✔
71	if (GetConnectionState() != TDeviceConnectionState::CONNECTED && EnableWbContinuousRead) {	65✔
72	ContinuousReadEnabled =	2✔
73	Modbus::EnableWbContinuousRead(shared_from_this(), *ModbusTraits, port, SlaveId, ModbusCache);	2✔
74	}
75	}	65✔
76
77	void TModbusDevice::WriteRegisterImpl(TPort& port, const TRegisterConfig& reg, const TRegisterValue& value)	44✔
78	{
79	Modbus::WriteRegister(*ModbusTraits,	88✔
80	port,
81	SlaveId,	44✔
82	reg,
83	value,
84	ModbusCache,	44✔
85	DeviceConfig()->RequestDelay,	88✔
86	GetResponseTimeout(port),	44✔
87	GetFrameTimeout(port));	44✔
88	}	38✔
89
90	void TModbusDevice::ReadRegisterRange(TPort& port, PRegisterRange range)	437✔
91	{
92	auto modbus_range = std::dynamic_pointer_cast<Modbus::TModbusRegisterRange>(range);	437✔
93	if (!modbus_range) {	437✔
94	throw std::runtime_error("modbus range expected");	×
95	}
96	Modbus::ReadRegisterRange(ModbusTraits, port, SlaveId, modbus_range, ModbusCache);	437✔
97	ResponseTime.AddValue(modbus_range->GetResponseTime());	437✔
98	}	437✔
99
100	void TModbusDevice::WriteSetupRegisters(TPort& port)	49✔
101	{
102	Modbus::WriteSetupRegisters(*ModbusTraits,	98✔
103	port,
104	SlaveId,	49✔
105	GetSetupItems(),
106	ModbusCache,	49✔
107	DeviceConfig()->RequestDelay,	98✔
108	GetResponseTimeout(port),	49✔
109	GetFrameTimeout(port));	49✔
110	}	40✔
111
112	std::chrono::milliseconds TModbusDevice::GetFrameTimeout(TPort& port) const	599✔
113	{
114	return std::max(
115	DeviceConfig()->FrameTimeout,	1,198✔
116	std::chrono::ceil<std::chrono::milliseconds>(port.GetSendTimeBytes(Modbus::STANDARD_FRAME_TIMEOUT_BYTES)));	1,198✔
117	}

wirenboard / wb-mqtt-serial / 1

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous