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

0.0

/src/rpc/rpc_device_handler.h

#pragma once
#include "rpc_port_driver_list.h"
#include "templates_map.h"

const std::chrono::seconds DefaultRPCTotalTimeout(10);

class TRPCDeviceParametersCache
{
public:
    TRPCDeviceParametersCache() = default;

    /**
     * Registes DeviceConnectionStateChanged callbacks to remove cached data if device connection lost.
     */
    void RegisterCallbacks(PHandlerConfig handlerConfig);

    /**
     * Creates cache item identifier string based on simlified port description and device address.
     * For example: "/dev/ttyRS485-2:12" or "192.168.18.7:2321:33"
     */
    std::string GetId(const TPort& port, const std::string& slaveId) const;

    /**
     * Puts device paramerers data into cache.
     * This method is thread safe.
     */
    void Add(const std::string& id, const Json::Value& value);

    /**
     * Removes device paramerers data from cache.
     * This method is thread safe.
     */
    void Remove(const std::string& id);

    /**
     * Returns true if cache contains device paramerers data or false overwise.
     * This method is thread safe.
     */
    bool Contains(const std::string& id) const;

    /**
     * Returns device paramerers data if cache contains it or defaultData overwise.
     * This method is thread safe.
     */
    const Json::Value& Get(const std::string& id, const Json::Value& defaultValue = Json::Value()) const;

private:
    mutable std::mutex Mutex;
    std::unordered_map<std::string, Json::Value> DeviceParameters;
};

class TRPCDeviceHelper
{
public:
    TRPCDeviceHelper(const Json::Value& request,
                     const TSerialDeviceFactory& deviceFactory,
                     PTemplateMap templates,
                     TSerialClientTaskRunner& serialClientTaskRunner);

    TDeviceProtocolParams ProtocolParams;
    PSerialDevice Device;
    PDeviceTemplate DeviceTemplate;
    bool DeviceFromConfig = false;
};

class TRPCDeviceRequest
{
public:
    TRPCDeviceRequest(const TDeviceProtocolParams& protocolParams,
                      PSerialDevice device,
                      PDeviceTemplate deviceTemplate,
                      bool deviceFromConfig);

    TDeviceProtocolParams ProtocolParams;
    PSerialDevice Device;
    PDeviceTemplate DeviceTemplate;
    bool DeviceFromConfig;

    TSerialPortConnectionSettings SerialPortSettings;

    std::chrono::milliseconds ResponseTimeout = DEFAULT_RESPONSE_TIMEOUT;
    std::chrono::milliseconds FrameTimeout = DefaultFrameTimeout;
    std::chrono::milliseconds TotalTimeout = DefaultRPCTotalTimeout;

    WBMQTT::TMqttRpcServer::TResultCallback OnResult = nullptr;
    WBMQTT::TMqttRpcServer::TErrorCallback OnError = nullptr;

    void ParseSettings(const Json::Value& request,
                       WBMQTT::TMqttRpcServer::TResultCallback onResult,
                       WBMQTT::TMqttRpcServer::TErrorCallback onError);
};

class TRPCDeviceHandler
{
public:
    TRPCDeviceHandler(const std::string& requestDeviceLoadConfigSchemaFilePath,
                      const std::string& requestDeviceLoadSchemaFilePath,
                      const std::string& requestDeviceLSetSchemaFilePath,
                      const std::string& requestDeviceProbeSchemaFilePath,
                      const std::string& requestDeviceSetPollSchemaFilePath,
                      const TSerialDeviceFactory& deviceFactory,
                      PTemplateMap templates,
                      TSerialClientTaskRunner& serialClientTaskRunner,
                      TRPCDeviceParametersCache& parametersCache,
                      WBMQTT::PMqttRpcServer rpcServer);

private:
    const TSerialDeviceFactory& DeviceFactory;

    Json::Value RequestDeviceLoadConfigSchema;
    Json::Value RequestDeviceLoadSchema;
    Json::Value RequestDeviceSetSchema;
    Json::Value RequestDeviceProbeSchema;
    Json::Value RequestDeviceSetPollSchema;

    PTemplateMap Templates;
    TSerialClientTaskRunner& SerialClientTaskRunner;
    TRPCDeviceParametersCache& ParametersCache;

    void LoadConfig(const Json::Value& request,
                    WBMQTT::TMqttRpcServer::TResultCallback onResult,
                    WBMQTT::TMqttRpcServer::TErrorCallback onError);

    void Load(const Json::Value& request,
              WBMQTT::TMqttRpcServer::TResultCallback onResult,
              WBMQTT::TMqttRpcServer::TErrorCallback onError);

    void Set(const Json::Value& request,
             WBMQTT::TMqttRpcServer::TResultCallback onResult,
             WBMQTT::TMqttRpcServer::TErrorCallback onError);

    void Probe(const Json::Value& request,
               WBMQTT::TMqttRpcServer::TResultCallback onResult,
               WBMQTT::TMqttRpcServer::TErrorCallback onError);

    Json::Value SetPoll(const Json::Value& request);
};

struct TRPCRegister
{
    std::string Id;
    PRegister Register;
    bool CheckUnsupported;
};

typedef std::shared_ptr<TRPCDeviceHandler> PRPCDeviceHandler;
typedef std::vector<TRPCRegister> TRPCRegisterList;

/**
 * @brief Creates named PRegister map based on template items (channels/parameters) JSON array or object.
 *
 * @param protocolParams - device protocol params for LoadRegisterConfig call
 * @param device - serial device object pointer for TRegister object creation
 * @param templateItems - device template items JSON array or object
 * @param knownItems - known items JSON object, where the key is the item id and the value is the known
 *                     item value, for example: {"baudrate": 96, "in1_mode": 2},
 *                     used to exclule known items from regiter list
 * @param fwVersion - device firmvare version string, used to exclude items unsupporterd by firmware
 * @param checkUnsupported - if set as true, template item's enums and ranges will be checked for presense of
 *                           default Wiren Board devices unsupported register value 0xFFFE,
 *                           to set register list item checkValue flag
 *
 * @return TRPCRegisterList - named PRegister list
 */
TRPCRegisterList CreateRegisterList(const TDeviceProtocolParams& protocolParams,
                                    const PSerialDevice& device,
                                    const Json::Value& templateItems,
                                    const Json::Value& knownItems = Json::Value(),
                                    const std::string& fwVersion = std::string(),
                                    bool checkUnsupported = false);

/**
 * @brief Reads TRPCRegisterList registers and puts valuet to JSON object.
 *
 * @param port - serial port refrence
 * @param device - serial device object pointer
 * @param registerList - named PRegister map
 * @param result - result JSON object reference
 * @param maxRetries - number of request retries in case of error
 */
void ReadRegisterList(TPort& port,
                      PSerialDevice device,
                      TRPCRegisterList& registerList,
                      Json::Value& result,
                      int maxRetries = 0);

Json::Value RawValueToJSON(const TRegisterConfig& reg, TRegisterValue val);

1	#pragma once
2	#include "rpc_port_driver_list.h"
3	#include "templates_map.h"
4
5	const std::chrono::seconds DefaultRPCTotalTimeout(10);
6
7	class TRPCDeviceParametersCache
8	{
9	public:
10	TRPCDeviceParametersCache() = default;	×
11
12	/**
13	* Registes DeviceConnectionStateChanged callbacks to remove cached data if device connection lost.
14	*/
15	void RegisterCallbacks(PHandlerConfig handlerConfig);
16
17	/**
18	* Creates cache item identifier string based on simlified port description and device address.
19	* For example: "/dev/ttyRS485-2:12" or "192.168.18.7:2321:33"
20	*/
21	std::string GetId(const TPort& port, const std::string& slaveId) const;
22
23	/**
24	* Puts device paramerers data into cache.
25	* This method is thread safe.
26	*/
27	void Add(const std::string& id, const Json::Value& value);
28
29	/**
30	* Removes device paramerers data from cache.
31	* This method is thread safe.
32	*/
33	void Remove(const std::string& id);
34
35	/**
36	* Returns true if cache contains device paramerers data or false overwise.
37	* This method is thread safe.
38	*/
39	bool Contains(const std::string& id) const;
40
41	/**
42	* Returns device paramerers data if cache contains it or defaultData overwise.
43	* This method is thread safe.
44	*/
45	const Json::Value& Get(const std::string& id, const Json::Value& defaultValue = Json::Value()) const;	×
46
47	private:
48	mutable std::mutex Mutex;
49	std::unordered_map<std::string, Json::Value> DeviceParameters;
50	};
51
52	class TRPCDeviceHelper
53	{
54	public:
55	TRPCDeviceHelper(const Json::Value& request,
56	const TSerialDeviceFactory& deviceFactory,
57	PTemplateMap templates,
58	TSerialClientTaskRunner& serialClientTaskRunner);
59
60	TDeviceProtocolParams ProtocolParams;
61	PSerialDevice Device;
62	PDeviceTemplate DeviceTemplate;
63	bool DeviceFromConfig = false;
64	};
65
66	class TRPCDeviceRequest
67	{
68	public:
69	TRPCDeviceRequest(const TDeviceProtocolParams& protocolParams,
70	PSerialDevice device,
71	PDeviceTemplate deviceTemplate,
72	bool deviceFromConfig);
73
74	TDeviceProtocolParams ProtocolParams;
75	PSerialDevice Device;
76	PDeviceTemplate DeviceTemplate;
77	bool DeviceFromConfig;
78
79	TSerialPortConnectionSettings SerialPortSettings;
80
81	std::chrono::milliseconds ResponseTimeout = DEFAULT_RESPONSE_TIMEOUT;
82	std::chrono::milliseconds FrameTimeout = DefaultFrameTimeout;
83	std::chrono::milliseconds TotalTimeout = DefaultRPCTotalTimeout;
84
85	WBMQTT::TMqttRpcServer::TResultCallback OnResult = nullptr;
86	WBMQTT::TMqttRpcServer::TErrorCallback OnError = nullptr;
87
88	void ParseSettings(const Json::Value& request,
89	WBMQTT::TMqttRpcServer::TResultCallback onResult,
90	WBMQTT::TMqttRpcServer::TErrorCallback onError);
91	};
92
93	class TRPCDeviceHandler
94	{
95	public:
96	TRPCDeviceHandler(const std::string& requestDeviceLoadConfigSchemaFilePath,
97	const std::string& requestDeviceLoadSchemaFilePath,
98	const std::string& requestDeviceLSetSchemaFilePath,
99	const std::string& requestDeviceProbeSchemaFilePath,
100	const std::string& requestDeviceSetPollSchemaFilePath,
101	const TSerialDeviceFactory& deviceFactory,
102	PTemplateMap templates,
103	TSerialClientTaskRunner& serialClientTaskRunner,
104	TRPCDeviceParametersCache& parametersCache,
105	WBMQTT::PMqttRpcServer rpcServer);
106
107	private:
108	const TSerialDeviceFactory& DeviceFactory;
109
110	Json::Value RequestDeviceLoadConfigSchema;
111	Json::Value RequestDeviceLoadSchema;
112	Json::Value RequestDeviceSetSchema;
113	Json::Value RequestDeviceProbeSchema;
114	Json::Value RequestDeviceSetPollSchema;
115
116	PTemplateMap Templates;
117	TSerialClientTaskRunner& SerialClientTaskRunner;
118	TRPCDeviceParametersCache& ParametersCache;
119
120	void LoadConfig(const Json::Value& request,
121	WBMQTT::TMqttRpcServer::TResultCallback onResult,
122	WBMQTT::TMqttRpcServer::TErrorCallback onError);
123
124	void Load(const Json::Value& request,
125	WBMQTT::TMqttRpcServer::TResultCallback onResult,
126	WBMQTT::TMqttRpcServer::TErrorCallback onError);
127
128	void Set(const Json::Value& request,
129	WBMQTT::TMqttRpcServer::TResultCallback onResult,
130	WBMQTT::TMqttRpcServer::TErrorCallback onError);
131
132	void Probe(const Json::Value& request,
133	WBMQTT::TMqttRpcServer::TResultCallback onResult,
134	WBMQTT::TMqttRpcServer::TErrorCallback onError);
135
136	Json::Value SetPoll(const Json::Value& request);
137	};
138
139	struct TRPCRegister
140	{
141	std::string Id;
142	PRegister Register;
143	bool CheckUnsupported;
144	};
145
146	typedef std::shared_ptr<TRPCDeviceHandler> PRPCDeviceHandler;
147	typedef std::vector<TRPCRegister> TRPCRegisterList;
148
149	/**
150	* @brief Creates named PRegister map based on template items (channels/parameters) JSON array or object.
151	*
152	* @param protocolParams - device protocol params for LoadRegisterConfig call
153	* @param device - serial device object pointer for TRegister object creation
154	* @param templateItems - device template items JSON array or object
155	* @param knownItems - known items JSON object, where the key is the item id and the value is the known
156	* item value, for example: {"baudrate": 96, "in1_mode": 2},
157	* used to exclule known items from regiter list
158	* @param fwVersion - device firmvare version string, used to exclude items unsupporterd by firmware
159	* @param checkUnsupported - if set as true, template item's enums and ranges will be checked for presense of
160	* default Wiren Board devices unsupported register value 0xFFFE,
161	* to set register list item checkValue flag
162	*
163	* @return TRPCRegisterList - named PRegister list
164	*/
165	TRPCRegisterList CreateRegisterList(const TDeviceProtocolParams& protocolParams,
166	const PSerialDevice& device,
167	const Json::Value& templateItems,
168	const Json::Value& knownItems = Json::Value(),	×
169	const std::string& fwVersion = std::string(),	×
170	bool checkUnsupported = false);
171
172	/**
173	* @brief Reads TRPCRegisterList registers and puts valuet to JSON object.
174	*
175	* @param port - serial port refrence
176	* @param device - serial device object pointer
177	* @param registerList - named PRegister map
178	* @param result - result JSON object reference
179	* @param maxRetries - number of request retries in case of error
180	*/
181	void ReadRegisterList(TPort& port,
182	PSerialDevice device,
183	TRPCRegisterList& registerList,
184	Json::Value& result,
185	int maxRetries = 0);
186
187	Json::Value RawValueToJSON(const TRegisterConfig& reg, TRegisterValue val);

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