wirenboard / wb-mqtt-serial / 6

Committed 13 Jan 2026 06:31AM UTC coverage: 76.817% (+4.0%) from 72.836%

Build # 6

Build Type

Pull #1049

github

Specific Base 8b2ffc

Committed by

Ilia1S

Commit Message

Remove fw from groups

Pull Request Pull Request #1049: WB-MR templates: Add delays

Run Details

6873 of 9161 branches covered (75.02%)

12966 of 16879 relevant lines covered (76.82%)

830.18 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, bool breakOnError)
{
    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, breakOnError);
    ResponseTime.AddValue(modbus_range->GetResponseTime());
}

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

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)	322✔
18	{}	322✔
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)	161✔
33	{
34	factory.RegisterProtocol(	161✔
35	new TModbusProtocol("modbus"),	161✔
36	new TModbusDeviceFactory<TModbusDevice>(std::make_unique<Modbus::TModbusRTUTraitsFactory>()));	322✔
37	factory.RegisterProtocol(	161✔
38	new TModbusProtocol("modbus-tcp"),	161✔
39	new TModbusDeviceFactory<TModbusDevice>(std::make_unique<Modbus::TModbusTCPTraitsFactory>()));	322✔
40	}	161✔
41
42	TModbusDevice::TModbusDevice(std::unique_ptr<Modbus::IModbusTraits> modbusTraits,	97✔
43	const TModbusDeviceConfig& config,
44	PProtocol protocol)	97✔
45	: TSerialDevice(config.CommonConfig, protocol),	97✔
46	TUInt32SlaveId(config.CommonConfig->SlaveId),	194✔
47	ModbusTraits(std::move(modbusTraits)),	97✔
48	ResponseTime(std::chrono::milliseconds::zero()),	×
49	EnableWbContinuousRead(config.EnableWbContinuousRead),	97✔
50	ContinuousReadEnabled(false)	97✔
51	{}	97✔
52
53	bool TModbusDevice::GetForceFrameTimeout()	1,001✔
54	{
55	return ModbusTraits->GetForceFrameTimeout();	1,001✔
56	}
57
58	bool TModbusDevice::GetContinuousReadEnabled()	1,001✔
59	{
60	return ContinuousReadEnabled;	1,001✔
61	}
62
63	PRegisterRange TModbusDevice::CreateRegisterRange() const	527✔
64	{
65	return Modbus::CreateRegisterRange(ResponseTime.GetValue());	527✔
66	}
67
68	void TModbusDevice::PrepareImpl(TPort& port)	94✔
69	{
70	TSerialDevice::PrepareImpl(port);	94✔
71	if (GetConnectionState() != TDeviceConnectionState::CONNECTED && EnableWbContinuousRead) {	94✔
72	ContinuousReadEnabled =	6✔
73	Modbus::EnableWbContinuousRead(shared_from_this(), *ModbusTraits, port, SlaveId, ModbusCache);	6✔
74	}
75	}	94✔
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, bool breakOnError)	485✔
91	{
92	auto modbus_range = std::dynamic_pointer_cast<Modbus::TModbusRegisterRange>(range);	485✔
93	if (!modbus_range) {	485✔
94	throw std::runtime_error("modbus range expected");	×
95	}
96	Modbus::ReadRegisterRange(ModbusTraits, port, SlaveId, modbus_range, ModbusCache, breakOnError);	485✔
97	ResponseTime.AddValue(modbus_range->GetResponseTime());	485✔
98	}	485✔
99
100	void TModbusDevice::WriteSetupRegisters(TPort& port, const TDeviceSetupItems& setupItems, bool breakOnError)	78✔
101	{
102	Modbus::WriteSetupRegisters(*ModbusTraits,	156✔
103	port,
104	SlaveId,	78✔
105	setupItems,
106	ModbusCache,	78✔
107	DeviceConfig()->RequestDelay,	156✔
108	GetResponseTimeout(port),	78✔
109	GetFrameTimeout(port),	78✔
110	breakOnError);
111	}	72✔
112
113	std::chrono::milliseconds TModbusDevice::GetFrameTimeout(TPort& port) const	709✔
114	{
115	return std::max(
116	DeviceConfig()->FrameTimeout,	1,418✔
117	std::chrono::ceil<std::chrono::milliseconds>(port.GetSendTimeBytes(Modbus::STANDARD_FRAME_TIMEOUT_BYTES)));	1,418✔
118	}

wirenboard / wb-mqtt-serial / 6

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