wirenboard / wb-mqtt-serial / 2

Committed 29 Dec 2025 12:28PM UTC coverage: 76.817% (+4.0%) from 72.836%

Build # 2

Build Type

Pull #1045

github

Specific Base 54aa0c

Committed by

pgasheev

Commit Message

up changelog

Pull Request Pull Request #1045: Fix firmware version in WB-M1W2 template

Run Details

6873 of 9161 branches covered (75.02%)

12966 of 16879 relevant lines covered (76.82%)

1651.61 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)	644✔
18	{}	644✔
19
20	bool IsSameSlaveId(const std::string& id1, const std::string& id2) const override	56✔
21	{
22	return (TUInt32SlaveId(id1) == TUInt32SlaveId(id2));	56✔
23	}
24
25	bool IsModbus() const override	×
26	{
27	return true;	×
28	}
29	};
30	}
31
32	void TModbusDevice::Register(TSerialDeviceFactory& factory)	322✔
33	{
34	factory.RegisterProtocol(	322✔
35	new TModbusProtocol("modbus"),	322✔
36	new TModbusDeviceFactory<TModbusDevice>(std::make_unique<Modbus::TModbusRTUTraitsFactory>()));	644✔
37	factory.RegisterProtocol(	322✔
38	new TModbusProtocol("modbus-tcp"),	322✔
39	new TModbusDeviceFactory<TModbusDevice>(std::make_unique<Modbus::TModbusTCPTraitsFactory>()));	644✔
40	}	322✔
41
42	TModbusDevice::TModbusDevice(std::unique_ptr<Modbus::IModbusTraits> modbusTraits,	194✔
43	const TModbusDeviceConfig& config,
44	PProtocol protocol)	194✔
45	: TSerialDevice(config.CommonConfig, protocol),	194✔
46	TUInt32SlaveId(config.CommonConfig->SlaveId),	388✔
47	ModbusTraits(std::move(modbusTraits)),	194✔
48	ResponseTime(std::chrono::milliseconds::zero()),	×
49	EnableWbContinuousRead(config.EnableWbContinuousRead),	194✔
50	ContinuousReadEnabled(false)	194✔
51	{}	194✔
52
53	bool TModbusDevice::GetForceFrameTimeout()	2,002✔
54	{
55	return ModbusTraits->GetForceFrameTimeout();	2,002✔
56	}
57
58	bool TModbusDevice::GetContinuousReadEnabled()	2,002✔
59	{
60	return ContinuousReadEnabled;	2,002✔
61	}
62
63	PRegisterRange TModbusDevice::CreateRegisterRange() const	1,054✔
64	{
65	return Modbus::CreateRegisterRange(ResponseTime.GetValue());	1,054✔
66	}
67
68	void TModbusDevice::PrepareImpl(TPort& port)	188✔
69	{
70	TSerialDevice::PrepareImpl(port);	188✔
71	if (GetConnectionState() != TDeviceConnectionState::CONNECTED && EnableWbContinuousRead) {	188✔
72	ContinuousReadEnabled =	12✔
73	Modbus::EnableWbContinuousRead(shared_from_this(), *ModbusTraits, port, SlaveId, ModbusCache);	12✔
74	}
75	}	188✔
76
77	void TModbusDevice::WriteRegisterImpl(TPort& port, const TRegisterConfig& reg, const TRegisterValue& value)	88✔
78	{
79	Modbus::WriteRegister(*ModbusTraits,	176✔
80	port,
81	SlaveId,	88✔
82	reg,
83	value,
84	ModbusCache,	88✔
85	DeviceConfig()->RequestDelay,	176✔
86	GetResponseTimeout(port),	88✔
87	GetFrameTimeout(port));	88✔
88	}	76✔
89
90	void TModbusDevice::ReadRegisterRange(TPort& port, PRegisterRange range, bool breakOnError)	970✔
91	{
92	auto modbus_range = std::dynamic_pointer_cast<Modbus::TModbusRegisterRange>(range);	970✔
93	if (!modbus_range) {	970✔
94	throw std::runtime_error("modbus range expected");	×
95	}
96	Modbus::ReadRegisterRange(ModbusTraits, port, SlaveId, modbus_range, ModbusCache, breakOnError);	970✔
97	ResponseTime.AddValue(modbus_range->GetResponseTime());	970✔
98	}	970✔
99
100	void TModbusDevice::WriteSetupRegisters(TPort& port, const TDeviceSetupItems& setupItems, bool breakOnError)	156✔
101	{
102	Modbus::WriteSetupRegisters(*ModbusTraits,	312✔
103	port,
104	SlaveId,	156✔
105	setupItems,
106	ModbusCache,	156✔
107	DeviceConfig()->RequestDelay,	312✔
108	GetResponseTimeout(port),	156✔
109	GetFrameTimeout(port),	156✔
110	breakOnError);
111	}	144✔
112
113	std::chrono::milliseconds TModbusDevice::GetFrameTimeout(TPort& port) const	1,418✔
114	{
115	return std::max(
116	DeviceConfig()->FrameTimeout,	2,836✔
117	std::chrono::ceil<std::chrono::milliseconds>(port.GetSendTimeBytes(Modbus::STANDARD_FRAME_TIMEOUT_BYTES)));	2,836✔
118	}

wirenboard / wb-mqtt-serial / 2

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