6568658631

Committed 19 Oct 2023 01:31AM UTC coverage: 31.23% (+0.02%) from 31.215%

Build # 6568658631

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #2155 from mavlink/pr-static-fixes

Threading fixes, MAVLink sequence number cleanup

Run Details

1386 of 1386 new or added lines in 46 files covered. (100.0%)

7906 of 25315 relevant lines covered (31.23%)

23.54 hits per line

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

0.0

/src/mavsdk/plugins/shell/shell_impl.cpp

#include "shell_impl.h"
#include "mavlink_address.h"
#include "system.h"
#include "callback_list.tpp"

namespace mavsdk {

template class CallbackList<std::string>;

void ShellImpl::init()
{
    _system_impl->register_mavlink_message_handler(
        MAVLINK_MSG_ID_SERIAL_CONTROL,
        [this](const mavlink_message_t& message) { process_shell_message(message); },
        this);
}

void ShellImpl::deinit()
{
    _system_impl->unregister_all_mavlink_message_handlers(this);
}

void ShellImpl::enable() {}

void ShellImpl::disable() {}

ShellImpl::ShellImpl(System& system) : PluginImplBase(system)
{
    _system_impl->register_plugin(this);
}

ShellImpl::ShellImpl(std::shared_ptr<System> system) : PluginImplBase(std::move(system))
{
    _system_impl->register_plugin(this);
}

ShellImpl::~ShellImpl()
{
    _system_impl->unregister_plugin(this);
}

Shell::Result ShellImpl::send(std::string command)
{
    if (!_system_impl->is_connected()) {
        return Shell::Result::NoSystem;
    }

    // In case a newline at the end of the command is missing, we add it here.
    if (command.back() != '\n') {
        command.append(1, '\n');
    }

    if (!send_command_message(command)) {
        return Shell::Result::ConnectionError;
    }

    return Shell::Result::Success;
}

Shell::ReceiveHandle ShellImpl::subscribe_receive(const Shell::ReceiveCallback& callback)
{
    std::lock_guard<std::mutex> lock(_receive.mutex);
    return _receive.callbacks.subscribe(callback);
}

void ShellImpl::unsubscribe_receive(Shell::ReceiveHandle handle)
{
    std::lock_guard<std::mutex> lock(_receive.mutex);
    _receive.callbacks.unsubscribe(handle);
}

bool ShellImpl::send_command_message(std::string command)
{
    mavlink_message_t message;

    while (command.length() > MAVLINK_MSG_SERIAL_CONTROL_FIELD_DATA_LEN) {
        if (!_system_impl->queue_message([&](MavlinkAddress mavlink_address, uint8_t channel) {
                mavlink_msg_serial_control_pack_chan(
                    mavlink_address.system_id,
                    mavlink_address.component_id,
                    channel,
                    &message,
                    static_cast<uint8_t>(SERIAL_CONTROL_DEV::SERIAL_CONTROL_DEV_SHELL),
                    0,
                    timeout_ms,
                    0,
                    static_cast<uint8_t>(MAVLINK_MSG_SERIAL_CONTROL_FIELD_DATA_LEN),
                    reinterpret_cast<const uint8_t*>(command.c_str()),
                    _system_impl->get_system_id(),
                    _system_impl->get_autopilot_id());
                command.erase(0, MAVLINK_MSG_SERIAL_CONTROL_FIELD_DATA_LEN);
                return message;
            })) {
            return false;
        }
    }

    uint8_t flags = 0;
    {
        // We only ask for a response if we have subscribed to a response.
        std::lock_guard<std::mutex> lock(_receive.mutex);
        if (!_receive.callbacks.empty()) {
            flags |= SERIAL_CONTROL_FLAG_RESPOND;
        }
    }

    uint8_t data[MAVLINK_MSG_SERIAL_CONTROL_FIELD_DATA_LEN]{};
    memcpy(data, command.c_str(), command.length());

    return _system_impl->queue_message([&](MavlinkAddress mavlink_address, uint8_t channel) {
        mavlink_msg_serial_control_pack_chan(
            mavlink_address.system_id,
            mavlink_address.component_id,
            channel,
            &message,
            static_cast<uint8_t>(SERIAL_CONTROL_DEV::SERIAL_CONTROL_DEV_SHELL),
            flags,
            timeout_ms,
            0,
            static_cast<uint8_t>(command.length()),
            data,
            _system_impl->get_system_id(),
            _system_impl->get_autopilot_id());
        return message;
    });
}

void ShellImpl::process_shell_message(const mavlink_message_t& message)
{
    mavlink_serial_control_t serial_control;
    mavlink_msg_serial_control_decode(&message, &serial_control);

    // This adds an additional byte for the null termination.
    char str_copy[sizeof(serial_control.data) + 1]{0};

    const auto len =
        std::min(static_cast<std::size_t>(serial_control.count), sizeof(serial_control.data));

    memcpy(str_copy, serial_control.data, len);

    std::string response(str_copy);

    // For the NuttShell (nsh>) we see these characters being sent but we're not sure
    // what they are for, so we're removing them for now.
    auto index = response.find({32, 27, '[', 'K'});
    if (index != std::string::npos) {
        response.erase(index, 4);
    }

    std::lock_guard<std::mutex> lock(_receive.mutex);
    _receive.callbacks.queue(
        response, [this](const auto& func) { _system_impl->call_user_callback(func); });
}

} // namespace mavsdk

1	#include "shell_impl.h"
2	#include "mavlink_address.h"
3	#include "system.h"
4	#include "callback_list.tpp"
5
6	namespace mavsdk {
7
8	template class CallbackList<std::string>;
9
10	void ShellImpl::init()	×
11	{
12	_system_impl->register_mavlink_message_handler(	×
13	MAVLINK_MSG_ID_SERIAL_CONTROL,
14	[this](const mavlink_message_t& message) { process_shell_message(message); },	×
15	this);
16	}	×
17
18	void ShellImpl::deinit()	×
19	{
20	_system_impl->unregister_all_mavlink_message_handlers(this);	×
21	}	×
22
23	void ShellImpl::enable() {}	×
24
25	void ShellImpl::disable() {}	×
26
27	ShellImpl::ShellImpl(System& system) : PluginImplBase(system)	×
28	{
29	_system_impl->register_plugin(this);	×
30	}	×
31
32	ShellImpl::ShellImpl(std::shared_ptr<System> system) : PluginImplBase(std::move(system))	×
33	{
34	_system_impl->register_plugin(this);	×
35	}	×
36
37	ShellImpl::~ShellImpl()	×
38	{
39	_system_impl->unregister_plugin(this);	×
40	}	×
41
42	Shell::Result ShellImpl::send(std::string command)	×
43	{
44	if (!_system_impl->is_connected()) {	×
45	return Shell::Result::NoSystem;	×
46	}
47
48	// In case a newline at the end of the command is missing, we add it here.
49	if (command.back() != '\n') {	×
50	command.append(1, '\n');	×
51	}
52
53	if (!send_command_message(command)) {	×
54	return Shell::Result::ConnectionError;	×
55	}
56
57	return Shell::Result::Success;	×
58	}
59
60	Shell::ReceiveHandle ShellImpl::subscribe_receive(const Shell::ReceiveCallback& callback)	×
61	{
62	std::lock_guard<std::mutex> lock(_receive.mutex);	×
63	return _receive.callbacks.subscribe(callback);	×
64	}
65
66	void ShellImpl::unsubscribe_receive(Shell::ReceiveHandle handle)	×
67	{
68	std::lock_guard<std::mutex> lock(_receive.mutex);	×
69	_receive.callbacks.unsubscribe(handle);	×
70	}	×
71
72	bool ShellImpl::send_command_message(std::string command)	×
73	{
74	mavlink_message_t message;	×
75
76	while (command.length() > MAVLINK_MSG_SERIAL_CONTROL_FIELD_DATA_LEN) {	×
77	if (!_system_impl->queue_message([&](MavlinkAddress mavlink_address, uint8_t channel) {	×
78	mavlink_msg_serial_control_pack_chan(	×
79	mavlink_address.system_id,	×
80	mavlink_address.component_id,	×
81	channel,
82	&message,	×
83	static_cast<uint8_t>(SERIAL_CONTROL_DEV::SERIAL_CONTROL_DEV_SHELL),
84	0,
85	timeout_ms,
86	0,
87	static_cast<uint8_t>(MAVLINK_MSG_SERIAL_CONTROL_FIELD_DATA_LEN),
88	reinterpret_cast<const uint8_t*>(command.c_str()),	×
89	_system_impl->get_system_id(),	×
90	_system_impl->get_autopilot_id());	×
91	command.erase(0, MAVLINK_MSG_SERIAL_CONTROL_FIELD_DATA_LEN);	×
92	return message;	×
93	})) {
94	return false;	×
95	}
96	}
97
98	uint8_t flags = 0;	×
99	{
100	// We only ask for a response if we have subscribed to a response.
101	std::lock_guard<std::mutex> lock(_receive.mutex);	×
102	if (!_receive.callbacks.empty()) {	×
103	flags \|= SERIAL_CONTROL_FLAG_RESPOND;	×
104	}
105	}
106
107	uint8_t data[MAVLINK_MSG_SERIAL_CONTROL_FIELD_DATA_LEN]{};	×
108	memcpy(data, command.c_str(), command.length());	×
109
110	return _system_impl->queue_message([&](MavlinkAddress mavlink_address, uint8_t channel) {	×
111	mavlink_msg_serial_control_pack_chan(	×
112	mavlink_address.system_id,	×
113	mavlink_address.component_id,	×
114	channel,
115	&message,	×
116	static_cast<uint8_t>(SERIAL_CONTROL_DEV::SERIAL_CONTROL_DEV_SHELL),
117	flags,	×
118	timeout_ms,
119	0,
120	static_cast<uint8_t>(command.length()),	×
121	data,	×
122	_system_impl->get_system_id(),	×
123	_system_impl->get_autopilot_id());	×
124	return message;	×
125	});	×
126	}
127
128	void ShellImpl::process_shell_message(const mavlink_message_t& message)	×
129	{
130	mavlink_serial_control_t serial_control;	×
131	mavlink_msg_serial_control_decode(&message, &serial_control);	×
132
133	// This adds an additional byte for the null termination.
134	char str_copy[sizeof(serial_control.data) + 1]{0};	×
135
136	const auto len =
137	std::min(static_cast<std::size_t>(serial_control.count), sizeof(serial_control.data));	×
138
139	memcpy(str_copy, serial_control.data, len);	×
140
141	std::string response(str_copy);	×
142
143	// For the NuttShell (nsh>) we see these characters being sent but we're not sure
144	// what they are for, so we're removing them for now.
145	auto index = response.find({32, 27, '[', 'K'});	×
146	if (index != std::string::npos) {	×
147	response.erase(index, 4);	×
148	}
149
150	std::lock_guard<std::mutex> lock(_receive.mutex);	×
151	_receive.callbacks.queue(	×
152	response, [this](const auto& func) { _system_impl->call_user_callback(func); });	×
153	}	×
154
155	} // namespace mavsdk

mavlink / MAVSDK / 6568658631

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