4899817366

Build Type

github

Committed by GitHub

Commit Message

Merge c0bb90862 into e4e9c71dd

Pull Request Pull Request #1772: Refactor MAVLinkParameters into client and server classes

Run Details

2192 of 2192 new or added lines in 34 files covered. (100.0%)

7708 of 24812 relevant lines covered (31.07%)

19.96 hits per line

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

0.0

/src/mavsdk/plugins/component_information_server/component_information_server_impl.cpp

#include "component_information_server_impl.h"
#include "mavlink_request_message_handler.h"
#include "callback_list.tpp"

#include <algorithm>
#include <string>
#include <json/json.h>

namespace mavsdk {

template class CallbackList<ComponentInformationServer::FloatParamUpdate>;

ComponentInformationServerImpl::ComponentInformationServerImpl(
    std::shared_ptr<ServerComponent> server_component) :
    ServerPluginImplBase(server_component)
{
    // FIXME: allow other component IDs
    _server_component_impl->register_plugin(this);
}

ComponentInformationServerImpl::~ComponentInformationServerImpl()
{
    _server_component_impl->register_plugin(this);
}

void ComponentInformationServerImpl::init()
{
    _server_component_impl->mavlink_request_message_handler().register_handler(
        MAVLINK_MSG_ID_COMPONENT_INFORMATION,
        [this](uint8_t, uint8_t, MavlinkRequestMessageHandler::Params) {
            return process_component_information_requested();
        },
        this);
}

void ComponentInformationServerImpl::deinit()
{
    _server_component_impl->mavlink_request_message_handler().unregister_all_handlers(this);
}

ComponentInformationServer::Result
ComponentInformationServerImpl::provide_float_param(ComponentInformationServer::FloatParam param)
{
    std::lock_guard<std::mutex> lock(_mutex);

    if (std::find_if(
            _float_params.begin(),
            _float_params.end(),
            [&](ComponentInformationServer::FloatParam& existing_param) {
                return existing_param.name == param.name;
            }) != std::end(_float_params)) {
        return ComponentInformationServer::Result::DuplicateParam;
    }

    if (param.start_value > param.max_value || param.start_value < param.min_value) {
        return ComponentInformationServer::Result::InvalidParamStartValue;
    }

    if (param.default_value > param.max_value || param.default_value < param.min_value) {
        return ComponentInformationServer::Result::InvalidParamDefaultValue;
    }

    if (param.name.size() > 16) {
        return ComponentInformationServer::Result::InvalidParamName;
    }

    _float_params.push_back(param);

    update_json_files_with_lock();

    _server_component_impl->mavlink_parameter_receiver().provide_server_param_float(
        param.name, param.start_value);
    _server_component_impl->mavlink_parameter_receiver().subscribe_param_float_changed(
        param.name,
        [this, name = param.name](float new_value) { param_update(name, new_value); },
        this);

    return ComponentInformationServer::Result::Success;
}

ComponentInformationServer::FloatParamHandle ComponentInformationServerImpl::subscribe_float_param(
    const ComponentInformationServer::FloatParamCallback& callback)
{
    std::lock_guard<std::mutex> lock(_mutex);
    return _float_param_update_callbacks.subscribe(callback);
}

void ComponentInformationServerImpl::unsubscribe_float_param(
    ComponentInformationServer::FloatParamHandle handle)
{
    std::lock_guard<std::mutex> lock(_mutex);
    _float_param_update_callbacks.unsubscribe(handle);
}

void ComponentInformationServerImpl::param_update(const std::string& name, float new_value)
{
    std::lock_guard<std::mutex> lock(_mutex);
    ComponentInformationServer::FloatParamUpdate param_update{name, new_value};
    _float_param_update_callbacks.queue(param_update, [this](const auto& func) {
        _server_component_impl->call_user_callback(func);
    });
}

std::optional<MAV_RESULT> ComponentInformationServerImpl::process_component_information_requested()
{
    const char general_metadata_uri[100] = "mftp://general.json";
    const char peripherals_metadata_uri[100] = "";

    mavlink_message_t message;
    mavlink_msg_component_information_pack(
        _server_component_impl->get_own_system_id(),
        _server_component_impl->get_own_component_id(),
        &message,
        _server_component_impl->get_time().elapsed_ms(),
        0,
        general_metadata_uri,
        0,
        peripherals_metadata_uri);
    _server_component_impl->send_message(message);

    // FIXME: REMOVE again
    update_json_files_with_lock();

    return MAV_RESULT_ACCEPTED;
}

void ComponentInformationServerImpl::update_json_files_with_lock()
{
    auto parameter_file = generate_parameter_file();
    auto meta_file = generate_meta_file();

    // std::cout << "parameter: " << parameter_file << '\n';
    // std::cout << "meta: " << meta_file << '\n';

    // FIXME: needs refactoring
    //_server_component_impl->mavlink_ftp().write_tmp_file("general.json",
    // meta_file);
    //_server_component_impl->mavlink_ftp().write_tmp_file("parameter.json",
    // parameter_file);
}

std::string ComponentInformationServerImpl::generate_parameter_file()
{
    Json::Value root;
    root["version"] = 1;
    Json::Value parameters = Json::arrayValue;
    for (const auto& param : _float_params) {
        Json::Value parameter;
        parameter["name"] = param.name;
        parameter["type"] = "Float";
        parameter["shortDesc"] = param.short_description;
        parameter["longDesc"] = param.long_description;
        parameter["units"] = param.unit;
        parameter["decimalPlaces"] = param.decimal_places;
        parameter["min"] = static_cast<double>(param.min_value);
        parameter["max"] = static_cast<double>(param.max_value);
        parameter["default"] = static_cast<double>(param.default_value);
        parameters.append(parameter);
    }
    root["parameters"] = parameters;

    return root.toStyledString();
}

std::string ComponentInformationServerImpl::generate_meta_file()
{
    Json::Value root;
    root["version"] = 1;
    root["vendorName"] = "Vendor";
    root["modelName"] = "Model";
    root["firmwareVersion"] = "1.0.0.0";
    root["hardwareVersion"] = "1.0.0.0";
    Json::Value metadata_types = Json::arrayValue;
    Json::Value metadata_type;
    metadata_type["type"] = Json::Int{COMP_METADATA_TYPE_PARAMETER};
    metadata_type["uri"] = "mftp://parameter.json";
    metadata_type["fileCrc"] = 0; // TODO
    metadata_type["uriFallback"] = ""; // TODO
    metadata_type["fileCrcFallback"] = 0;
    metadata_types.append(metadata_type);
    root["metadataTypes"] = metadata_types;

    return root.toStyledString();
}

} // namespace mavsdk

1	#include "component_information_server_impl.h"
2	#include "mavlink_request_message_handler.h"
3	#include "callback_list.tpp"
4
5	#include <algorithm>
6	#include <string>
7	#include <json/json.h>
8
9	namespace mavsdk {
10
11	template class CallbackList<ComponentInformationServer::FloatParamUpdate>;
12
13	ComponentInformationServerImpl::ComponentInformationServerImpl(	×
14	std::shared_ptr<ServerComponent> server_component) :	×
15	ServerPluginImplBase(server_component)	×
16	{
17	// FIXME: allow other component IDs
18	_server_component_impl->register_plugin(this);	×
19	}	×
20
21	ComponentInformationServerImpl::~ComponentInformationServerImpl()	×
22	{
23	_server_component_impl->register_plugin(this);	×
24	}	×
25
26	void ComponentInformationServerImpl::init()	×
27	{
28	_server_component_impl->mavlink_request_message_handler().register_handler(	×
29	MAVLINK_MSG_ID_COMPONENT_INFORMATION,
30	[this](uint8_t, uint8_t, MavlinkRequestMessageHandler::Params) {	×
31	return process_component_information_requested();	×
32	},
33	this);
34	}	×
35
36	void ComponentInformationServerImpl::deinit()	×
37	{
38	_server_component_impl->mavlink_request_message_handler().unregister_all_handlers(this);	×
39	}	×
40
41	ComponentInformationServer::Result
42	ComponentInformationServerImpl::provide_float_param(ComponentInformationServer::FloatParam param)	×
43	{
44	std::lock_guard<std::mutex> lock(_mutex);	×
45
46	if (std::find_if(	×
47	_float_params.begin(),
48	_float_params.end(),
49	[&](ComponentInformationServer::FloatParam& existing_param) {	×
50	return existing_param.name == param.name;	×
51	}) != std::end(_float_params)) {	×
52	return ComponentInformationServer::Result::DuplicateParam;	×
53	}
54
55	if (param.start_value > param.max_value \|\| param.start_value < param.min_value) {	×
56	return ComponentInformationServer::Result::InvalidParamStartValue;	×
57	}
58
59	if (param.default_value > param.max_value \|\| param.default_value < param.min_value) {	×
60	return ComponentInformationServer::Result::InvalidParamDefaultValue;	×
61	}
62
63	if (param.name.size() > 16) {	×
64	return ComponentInformationServer::Result::InvalidParamName;	×
65	}
66
67	_float_params.push_back(param);	×
68
69	update_json_files_with_lock();	×
70
71	_server_component_impl->mavlink_parameter_receiver().provide_server_param_float(	×
72	param.name, param.start_value);	×
73	_server_component_impl->mavlink_parameter_receiver().subscribe_param_float_changed(	×
74	param.name,	×
75	[this, name = param.name](float new_value) { param_update(name, new_value); },	×
76	this);
77
78	return ComponentInformationServer::Result::Success;	×
79	}
80
81	ComponentInformationServer::FloatParamHandle ComponentInformationServerImpl::subscribe_float_param(	×
82	const ComponentInformationServer::FloatParamCallback& callback)
83	{
84	std::lock_guard<std::mutex> lock(_mutex);	×
85	return _float_param_update_callbacks.subscribe(callback);	×
86	}
87
88	void ComponentInformationServerImpl::unsubscribe_float_param(	×
89	ComponentInformationServer::FloatParamHandle handle)
90	{
91	std::lock_guard<std::mutex> lock(_mutex);	×
92	_float_param_update_callbacks.unsubscribe(handle);	×
93	}	×
94
95	void ComponentInformationServerImpl::param_update(const std::string& name, float new_value)	×
96	{
97	std::lock_guard<std::mutex> lock(_mutex);	×
98	ComponentInformationServer::FloatParamUpdate param_update{name, new_value};	×
99	_float_param_update_callbacks.queue(param_update, [this](const auto& func) {	×
100	_server_component_impl->call_user_callback(func);	×
101	});	×
102	}	×
103
104	std::optional<MAV_RESULT> ComponentInformationServerImpl::process_component_information_requested()	×
105	{
106	const char general_metadata_uri[100] = "mftp://general.json";	×
107	const char peripherals_metadata_uri[100] = "";	×
108
109	mavlink_message_t message;	×
110	mavlink_msg_component_information_pack(	×
111	_server_component_impl->get_own_system_id(),	×
112	_server_component_impl->get_own_component_id(),	×
113	&message,
114	_server_component_impl->get_time().elapsed_ms(),	×
115	0,
116	general_metadata_uri,
117	0,
118	peripherals_metadata_uri);
119	_server_component_impl->send_message(message);	×
120
121	// FIXME: REMOVE again
122	update_json_files_with_lock();	×
123
124	return MAV_RESULT_ACCEPTED;	×
125	}
126
127	void ComponentInformationServerImpl::update_json_files_with_lock()	×
128	{
129	auto parameter_file = generate_parameter_file();	×
130	auto meta_file = generate_meta_file();	×
131
132	// std::cout << "parameter: " << parameter_file << '\n';
133	// std::cout << "meta: " << meta_file << '\n';
134
135	// FIXME: needs refactoring
136	//_server_component_impl->mavlink_ftp().write_tmp_file("general.json",
137	// meta_file);
138	//_server_component_impl->mavlink_ftp().write_tmp_file("parameter.json",
139	// parameter_file);
140	}	×
141
142	std::string ComponentInformationServerImpl::generate_parameter_file()	×
143	{
144	Json::Value root;	×
145	root["version"] = 1;	×
146	Json::Value parameters = Json::arrayValue;	×
147	for (const auto& param : _float_params) {	×
148	Json::Value parameter;	×
149	parameter["name"] = param.name;	×
150	parameter["type"] = "Float";	×
151	parameter["shortDesc"] = param.short_description;	×
152	parameter["longDesc"] = param.long_description;	×
153	parameter["units"] = param.unit;	×
154	parameter["decimalPlaces"] = param.decimal_places;	×
155	parameter["min"] = static_cast<double>(param.min_value);	×
156	parameter["max"] = static_cast<double>(param.max_value);	×
157	parameter["default"] = static_cast<double>(param.default_value);	×
158	parameters.append(parameter);	×
159	}
160	root["parameters"] = parameters;	×
161
162	return root.toStyledString();	×
163	}
164
165	std::string ComponentInformationServerImpl::generate_meta_file()	×
166	{
167	Json::Value root;	×
168	root["version"] = 1;	×
169	root["vendorName"] = "Vendor";	×
170	root["modelName"] = "Model";	×
171	root["firmwareVersion"] = "1.0.0.0";	×
172	root["hardwareVersion"] = "1.0.0.0";	×
173	Json::Value metadata_types = Json::arrayValue;	×
174	Json::Value metadata_type;	×
175	metadata_type["type"] = Json::Int{COMP_METADATA_TYPE_PARAMETER};	×
176	metadata_type["uri"] = "mftp://parameter.json";	×
177	metadata_type["fileCrc"] = 0; // TODO	×
178	metadata_type["uriFallback"] = ""; // TODO	×
179	metadata_type["fileCrcFallback"] = 0;	×
180	metadata_types.append(metadata_type);	×
181	root["metadataTypes"] = metadata_types;	×
182
183	return root.toStyledString();	×
184	}
185
186	} // namespace mavsdk

mavlink / MAVSDK / 4899817366

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