7965506471

Committed 19 Feb 2024 09:51PM UTC coverage: 36.22% (+0.008%) from 36.212%

Build # 7965506471

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #2223 from mavlink/pr-absl-fix

Fix illegal instruction on RPi 4

Run Details

10035 of 27706 relevant lines covered (36.22%)

127.69 hits per line

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

0.0

/src/mavsdk/core/serial_connection.cpp

#include "serial_connection.h"
#include "log.h"

#if defined(APPLE) || defined(LINUX)
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <poll.h>

#include <utility>
#endif

namespace mavsdk {

#ifndef WINDOWS
#define GET_ERROR() strerror(errno)
#else
#define GET_ERROR() GetLastErrorStdStr()
// Taken from:
// https://coolcowstudio.wordpress.com/2012/10/19/getlasterror-as-stdstring/
std::string GetLastErrorStdStr()
{
    DWORD error = GetLastError();
    if (error) {
        LPVOID lpMsgBuf;
        DWORD bufLen = FormatMessage(
            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
                FORMAT_MESSAGE_IGNORE_INSERTS,
            NULL,
            error,
            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
            (LPTSTR)&lpMsgBuf,
            0,
            NULL);
        if (bufLen) {
            LPCSTR lpMsgStr = (LPCSTR)lpMsgBuf;
            std::string result(lpMsgStr, lpMsgStr + bufLen);

            LocalFree(lpMsgBuf);

            return result;
        }
    }
    return std::string();
}
#endif

SerialConnection::SerialConnection(
    Connection::ReceiverCallback receiver_callback,
    std::string path,
    int baudrate,
    bool flow_control,
    ForwardingOption forwarding_option) :
    Connection(std::move(receiver_callback), forwarding_option),
    _serial_node(std::move(path)),
    _baudrate(baudrate),
    _flow_control(flow_control)
{}

SerialConnection::~SerialConnection()
{
    // If no one explicitly called stop before, we should at least do it.
    stop();
}

ConnectionResult SerialConnection::start()
{
    if (!start_mavlink_receiver()) {
        return ConnectionResult::ConnectionsExhausted;
    }

    ConnectionResult ret = setup_port();
    if (ret != ConnectionResult::Success) {
        return ret;
    }

    start_recv_thread();

    return ConnectionResult::Success;
}

ConnectionResult SerialConnection::setup_port()
{
#if defined(LINUX) || defined(APPLE)
    // open() hangs on macOS or Linux devices(e.g. pocket beagle) unless you give it O_NONBLOCK
    _fd = open(_serial_node.c_str(), O_RDWR | O_NOCTTY | O_NONBLOCK);
    if (_fd == -1) {
        LogErr() << "open failed: " << GET_ERROR();
        return ConnectionResult::ConnectionError;
    }
    // We need to clear the O_NONBLOCK again because we can block while reading
    // as we do it in a separate thread.
    if (fcntl(_fd, F_SETFL, 0) == -1) {
        LogErr() << "fcntl failed: " << GET_ERROR();
        return ConnectionResult::ConnectionError;
    }
#elif defined(WINDOWS)
    // Required for COM ports > 9.
    const auto full_serial_path = "\\\\.\\" + _serial_node;

    _handle = CreateFile(
        full_serial_path.c_str(),
        GENERIC_READ | GENERIC_WRITE,
        0, // exclusive-access
        NULL, //  default security attributes
        OPEN_EXISTING,
        0, //  not overlapped I/O
        NULL); //  hTemplate must be NULL for comm devices

    if (_handle == INVALID_HANDLE_VALUE) {
        LogErr() << "CreateFile failed with: " << GET_ERROR();
        return ConnectionResult::ConnectionError;
    }
#endif

#if defined(LINUX) || defined(APPLE)
    struct termios tc;
    bzero(&tc, sizeof(tc));

    if (tcgetattr(_fd, &tc) != 0) {
        LogErr() << "tcgetattr failed: " << GET_ERROR();
        close(_fd);
        return ConnectionResult::ConnectionError;
    }
#endif

#if defined(LINUX) || defined(APPLE)
    tc.c_iflag &= ~(IGNBRK | BRKINT | ICRNL | INLCR | PARMRK | INPCK | ISTRIP | IXON);
    tc.c_oflag &= ~(OCRNL | ONLCR | ONLRET | ONOCR | OFILL | OPOST);
    tc.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN | ISIG | TOSTOP);
    tc.c_cflag &= ~(CSIZE | PARENB | CRTSCTS);
    tc.c_cflag |= CS8;

    tc.c_cc[VMIN] = 0; // We are ok with 0 bytes.
    tc.c_cc[VTIME] = 10; // Timeout after 1 second.

    if (_flow_control) {
        tc.c_cflag |= CRTSCTS;
    }
#endif

#if defined(LINUX) || defined(APPLE)
    tc.c_cflag |= CLOCAL; // Without this a write() blocks indefinitely.

#if defined(LINUX)
    const int baudrate_or_define = define_from_baudrate(_baudrate);
#elif defined(APPLE)
    const int baudrate_or_define = _baudrate;
#endif

    if (baudrate_or_define == -1) {
        return ConnectionResult::BaudrateUnknown;
    }

    if (cfsetispeed(&tc, baudrate_or_define) != 0) {
        LogErr() << "cfsetispeed failed: " << GET_ERROR();
        close(_fd);
        return ConnectionResult::ConnectionError;
    }

    if (cfsetospeed(&tc, baudrate_or_define) != 0) {
        LogErr() << "cfsetospeed failed: " << GET_ERROR();
        close(_fd);
        return ConnectionResult::ConnectionError;
    }

    if (tcsetattr(_fd, TCSANOW, &tc) != 0) {
        LogErr() << "tcsetattr failed: " << GET_ERROR();
        close(_fd);
        return ConnectionResult::ConnectionError;
    }
#endif

#if defined(WINDOWS)
    DCB dcb;
    SecureZeroMemory(&dcb, sizeof(DCB));
    dcb.DCBlength = sizeof(DCB);

    if (!GetCommState(_handle, &dcb)) {
        LogErr() << "GetCommState failed with error: " << GET_ERROR();
        return ConnectionResult::ConnectionError;
    }

    dcb.BaudRate = _baudrate;
    dcb.ByteSize = 8;
    dcb.Parity = NOPARITY;
    dcb.StopBits = ONESTOPBIT;
    if (_flow_control) {
        dcb.fOutxCtsFlow = TRUE;
        dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
        dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
    } else {
        dcb.fDtrControl = DTR_CONTROL_DISABLE;
        dcb.fRtsControl = RTS_CONTROL_DISABLE;
    }
    dcb.fOutX = FALSE;
    dcb.fInX = FALSE;
    dcb.fBinary = TRUE;
    dcb.fNull = FALSE;
    dcb.fDsrSensitivity = FALSE;

    if (!SetCommState(_handle, &dcb)) {
        LogErr() << "SetCommState failed with error: " << GET_ERROR();
        return ConnectionResult::ConnectionError;
    }

    COMMTIMEOUTS timeout = {0, 0, 0, 0, 0};
    timeout.ReadIntervalTimeout = 1;
    timeout.ReadTotalTimeoutConstant = 1;
    timeout.ReadTotalTimeoutMultiplier = 1;
    timeout.WriteTotalTimeoutConstant = 1;
    timeout.WriteTotalTimeoutMultiplier = 1;
    SetCommTimeouts(_handle, &timeout);

    if (!SetCommTimeouts(_handle, &timeout)) {
        LogErr() << "SetCommTimeouts failed with error: " << GET_ERROR();
        return ConnectionResult::ConnectionError;
    }

#endif

    return ConnectionResult::Success;
}

void SerialConnection::start_recv_thread()
{
    _recv_thread = std::make_unique<std::thread>(&SerialConnection::receive, this);
}

ConnectionResult SerialConnection::stop()
{
    _should_exit = true;

    if (_recv_thread) {
        _recv_thread->join();
        _recv_thread.reset();
    }

#if defined(LINUX) || defined(APPLE)
    close(_fd);
#elif defined(WINDOWS)
    CloseHandle(_handle);
#endif

    // We need to stop this after stopping the receive thread, otherwise
    // it can happen that we interfere with the parsing of a message.
    stop_mavlink_receiver();

    return ConnectionResult::Success;
}

bool SerialConnection::send_message(const mavlink_message_t& message)
{
    if (_serial_node.empty()) {
        LogErr() << "Dev Path unknown";
        return false;
    }

    if (_baudrate == 0) {
        LogErr() << "Baudrate unknown";
        return false;
    }

    uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
    uint16_t buffer_len = mavlink_msg_to_send_buffer(buffer, &message);

    int send_len;
#if defined(LINUX) || defined(APPLE)
    send_len = static_cast<int>(write(_fd, buffer, buffer_len));
#else
    if (!WriteFile(_handle, buffer, buffer_len, LPDWORD(&send_len), NULL)) {
        LogErr() << "WriteFile failure: " << GET_ERROR();
        return false;
    }
#endif

    if (send_len != buffer_len) {
        LogErr() << "write failure: " << GET_ERROR();
        return false;
    }

    return true;
}

void SerialConnection::receive()
{
    // Enough for MTU 1500 bytes.
    char buffer[2048];

#if defined(LINUX) || defined(APPLE)
    struct pollfd fds[1];
    fds[0].fd = _fd;
    fds[0].events = POLLIN;
#endif

    while (!_should_exit) {
        int recv_len;
#if defined(LINUX) || defined(APPLE)
        int pollrc = poll(fds, 1, 1000);
        if (pollrc == 0 || !(fds[0].revents & POLLIN)) {
            continue;
        } else if (pollrc == -1) {
            LogErr() << "read poll failure: " << GET_ERROR();
        }
        // We enter here if (fds[0].revents & POLLIN) == true
        recv_len = static_cast<int>(read(_fd, buffer, sizeof(buffer)));
        if (recv_len < -1) {
            LogErr() << "read failure: " << GET_ERROR();
        }
#else
        if (!ReadFile(_handle, buffer, sizeof(buffer), LPDWORD(&recv_len), NULL)) {
            LogErr() << "ReadFile failure: " << GET_ERROR();
            continue;
        }
#endif
        if (recv_len > static_cast<int>(sizeof(buffer)) || recv_len == 0) {
            continue;
        }
        _mavlink_receiver->set_new_datagram(buffer, recv_len);
        // Parse all mavlink messages in one data packet. Once exhausted, we'll exit while.
        while (_mavlink_receiver->parse_message()) {
            receive_message(_mavlink_receiver->get_last_message(), this);
        }
    }
}

#if defined(LINUX)
int SerialConnection::define_from_baudrate(int baudrate)
{
    switch (baudrate) {
        case 9600:
            return B9600;
        case 19200:
            return B19200;
        case 38400:
            return B38400;
        case 57600:
            return B57600;
        case 115200:
            return B115200;
        case 230400:
            return B230400;
        case 460800:
            return B460800;
        case 500000:
            return B500000;
        case 576000:
            return B576000;
        case 921600:
            return B921600;
        case 1000000:
            return B1000000;
        case 1152000:
            return B1152000;
        case 1500000:
            return B1500000;
        case 2000000:
            return B2000000;
        case 2500000:
            return B2500000;
        case 3000000:
            return B3000000;
        case 3500000:
            return B3500000;
        case 4000000:
            return B4000000;
        default: {
            LogErr() << "Unknown baudrate";
            return -1;
        }
    }
}
#endif

} // namespace mavsdk

1	#include "serial_connection.h"
2	#include "log.h"
3
4	#if defined(APPLE) \|\| defined(LINUX)
5	#include <unistd.h>
6	#include <fcntl.h>
7	#include <termios.h>
8	#include <poll.h>
9
10	#include <utility>
11	#endif
12
13	namespace mavsdk {
14
15	#ifndef WINDOWS
16	#define GET_ERROR() strerror(errno)
17	#else
18	#define GET_ERROR() GetLastErrorStdStr()
19	// Taken from:
20	// https://coolcowstudio.wordpress.com/2012/10/19/getlasterror-as-stdstring/
21	std::string GetLastErrorStdStr()
22	{
23	DWORD error = GetLastError();
24	if (error) {
25	LPVOID lpMsgBuf;
26	DWORD bufLen = FormatMessage(
27	FORMAT_MESSAGE_ALLOCATE_BUFFER \| FORMAT_MESSAGE_FROM_SYSTEM \|
28	FORMAT_MESSAGE_IGNORE_INSERTS,
29	NULL,
30	error,
31	MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
32	(LPTSTR)&lpMsgBuf,
33	0,
34	NULL);
35	if (bufLen) {
36	LPCSTR lpMsgStr = (LPCSTR)lpMsgBuf;
37	std::string result(lpMsgStr, lpMsgStr + bufLen);
38
39	LocalFree(lpMsgBuf);
40
41	return result;
42	}
43	}
44	return std::string();
45	}
46	#endif
47
48	SerialConnection::SerialConnection(	×
49	Connection::ReceiverCallback receiver_callback,
50	std::string path,
51	int baudrate,
52	bool flow_control,
53	ForwardingOption forwarding_option) :	×
54	Connection(std::move(receiver_callback), forwarding_option),	×
55	_serial_node(std::move(path)),	×
56	_baudrate(baudrate),
57	_flow_control(flow_control)	×
58	{}	×
59
60	SerialConnection::~SerialConnection()	×
61	{
62	// If no one explicitly called stop before, we should at least do it.
63	stop();	×
64	}	×
65
66	ConnectionResult SerialConnection::start()	×
67	{
68	if (!start_mavlink_receiver()) {	×
69	return ConnectionResult::ConnectionsExhausted;	×
70	}
71
72	ConnectionResult ret = setup_port();	×
73	if (ret != ConnectionResult::Success) {	×
74	return ret;	×
75	}
76
77	start_recv_thread();	×
78
79	return ConnectionResult::Success;	×
80	}
81
82	ConnectionResult SerialConnection::setup_port()	×
83	{
84	#if defined(LINUX) \|\| defined(APPLE)
85	// open() hangs on macOS or Linux devices(e.g. pocket beagle) unless you give it O_NONBLOCK
86	_fd = open(_serial_node.c_str(), O_RDWR \| O_NOCTTY \| O_NONBLOCK);	×
87	if (_fd == -1) {	×
88	LogErr() << "open failed: " << GET_ERROR();	×
89	return ConnectionResult::ConnectionError;	×
90	}
91	// We need to clear the O_NONBLOCK again because we can block while reading
92	// as we do it in a separate thread.
93	if (fcntl(_fd, F_SETFL, 0) == -1) {	×
94	LogErr() << "fcntl failed: " << GET_ERROR();	×
95	return ConnectionResult::ConnectionError;	×
96	}
97	#elif defined(WINDOWS)
98	// Required for COM ports > 9.
99	const auto full_serial_path = "\\\\.\\" + _serial_node;
100
101	_handle = CreateFile(
102	full_serial_path.c_str(),
103	GENERIC_READ \| GENERIC_WRITE,
104	0, // exclusive-access
105	NULL, // default security attributes
106	OPEN_EXISTING,
107	0, // not overlapped I/O
108	NULL); // hTemplate must be NULL for comm devices
109
110	if (_handle == INVALID_HANDLE_VALUE) {
111	LogErr() << "CreateFile failed with: " << GET_ERROR();
112	return ConnectionResult::ConnectionError;
113	}
114	#endif
115
116	#if defined(LINUX) \|\| defined(APPLE)
117	struct termios tc;	×
118	bzero(&tc, sizeof(tc));	×
119
120	if (tcgetattr(_fd, &tc) != 0) {	×
121	LogErr() << "tcgetattr failed: " << GET_ERROR();	×
122	close(_fd);	×
123	return ConnectionResult::ConnectionError;	×
124	}
125	#endif
126
127	#if defined(LINUX) \|\| defined(APPLE)
128	tc.c_iflag &= ~(IGNBRK \| BRKINT \| ICRNL \| INLCR \| PARMRK \| INPCK \| ISTRIP \| IXON);	×
129	tc.c_oflag &= ~(OCRNL \| ONLCR \| ONLRET \| ONOCR \| OFILL \| OPOST);	×
130	tc.c_lflag &= ~(ECHO \| ECHONL \| ICANON \| IEXTEN \| ISIG \| TOSTOP);	×
131	tc.c_cflag &= ~(CSIZE \| PARENB \| CRTSCTS);	×
132	tc.c_cflag \|= CS8;	×
133
134	tc.c_cc[VMIN] = 0; // We are ok with 0 bytes.	×
135	tc.c_cc[VTIME] = 10; // Timeout after 1 second.	×
136
137	if (_flow_control) {	×
138	tc.c_cflag \|= CRTSCTS;	×
139	}
140	#endif
141
142	#if defined(LINUX) \|\| defined(APPLE)
143	tc.c_cflag \|= CLOCAL; // Without this a write() blocks indefinitely.	×
144
145	#if defined(LINUX)
146	const int baudrate_or_define = define_from_baudrate(_baudrate);	×
147	#elif defined(APPLE)
148	const int baudrate_or_define = _baudrate;
149	#endif
150
151	if (baudrate_or_define == -1) {	×
152	return ConnectionResult::BaudrateUnknown;	×
153	}
154
155	if (cfsetispeed(&tc, baudrate_or_define) != 0) {	×
156	LogErr() << "cfsetispeed failed: " << GET_ERROR();	×
157	close(_fd);	×
158	return ConnectionResult::ConnectionError;	×
159	}
160
161	if (cfsetospeed(&tc, baudrate_or_define) != 0) {	×
162	LogErr() << "cfsetospeed failed: " << GET_ERROR();	×
163	close(_fd);	×
164	return ConnectionResult::ConnectionError;	×
165	}
166
167	if (tcsetattr(_fd, TCSANOW, &tc) != 0) {	×
168	LogErr() << "tcsetattr failed: " << GET_ERROR();	×
169	close(_fd);	×
170	return ConnectionResult::ConnectionError;	×
171	}
172	#endif
173
174	#if defined(WINDOWS)
175	DCB dcb;
176	SecureZeroMemory(&dcb, sizeof(DCB));
177	dcb.DCBlength = sizeof(DCB);
178
179	if (!GetCommState(_handle, &dcb)) {
180	LogErr() << "GetCommState failed with error: " << GET_ERROR();
181	return ConnectionResult::ConnectionError;
182	}
183
184	dcb.BaudRate = _baudrate;
185	dcb.ByteSize = 8;
186	dcb.Parity = NOPARITY;
187	dcb.StopBits = ONESTOPBIT;
188	if (_flow_control) {
189	dcb.fOutxCtsFlow = TRUE;
190	dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
191	dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
192	} else {
193	dcb.fDtrControl = DTR_CONTROL_DISABLE;
194	dcb.fRtsControl = RTS_CONTROL_DISABLE;
195	}
196	dcb.fOutX = FALSE;
197	dcb.fInX = FALSE;
198	dcb.fBinary = TRUE;
199	dcb.fNull = FALSE;
200	dcb.fDsrSensitivity = FALSE;
201
202	if (!SetCommState(_handle, &dcb)) {
203	LogErr() << "SetCommState failed with error: " << GET_ERROR();
204	return ConnectionResult::ConnectionError;
205	}
206
207	COMMTIMEOUTS timeout = {0, 0, 0, 0, 0};
208	timeout.ReadIntervalTimeout = 1;
209	timeout.ReadTotalTimeoutConstant = 1;
210	timeout.ReadTotalTimeoutMultiplier = 1;
211	timeout.WriteTotalTimeoutConstant = 1;
212	timeout.WriteTotalTimeoutMultiplier = 1;
213	SetCommTimeouts(_handle, &timeout);
214
215	if (!SetCommTimeouts(_handle, &timeout)) {
216	LogErr() << "SetCommTimeouts failed with error: " << GET_ERROR();
217	return ConnectionResult::ConnectionError;
218	}
219
220	#endif
221
222	return ConnectionResult::Success;	×
223	}
224
225	void SerialConnection::start_recv_thread()	×
226	{
227	_recv_thread = std::make_unique<std::thread>(&SerialConnection::receive, this);	×
228	}	×
229
230	ConnectionResult SerialConnection::stop()	×
231	{
232	_should_exit = true;	×
233
234	if (_recv_thread) {	×
235	_recv_thread->join();	×
236	_recv_thread.reset();	×
237	}
238
239	#if defined(LINUX) \|\| defined(APPLE)
240	close(_fd);	×
241	#elif defined(WINDOWS)
242	CloseHandle(_handle);
243	#endif
244
245	// We need to stop this after stopping the receive thread, otherwise
246	// it can happen that we interfere with the parsing of a message.
247	stop_mavlink_receiver();	×
248
249	return ConnectionResult::Success;	×
250	}
251
252	bool SerialConnection::send_message(const mavlink_message_t& message)	×
253	{
254	if (_serial_node.empty()) {	×
255	LogErr() << "Dev Path unknown";	×
256	return false;	×
257	}
258
259	if (_baudrate == 0) {	×
260	LogErr() << "Baudrate unknown";	×
261	return false;	×
262	}
263
264	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];	×
265	uint16_t buffer_len = mavlink_msg_to_send_buffer(buffer, &message);	×
266
267	int send_len;
268	#if defined(LINUX) \|\| defined(APPLE)
269	send_len = static_cast<int>(write(_fd, buffer, buffer_len));	×
270	#else
271	if (!WriteFile(_handle, buffer, buffer_len, LPDWORD(&send_len), NULL)) {
272	LogErr() << "WriteFile failure: " << GET_ERROR();
273	return false;
274	}
275	#endif
276
277	if (send_len != buffer_len) {	×
278	LogErr() << "write failure: " << GET_ERROR();	×
279	return false;	×
280	}
281
282	return true;	×
283	}
284
285	void SerialConnection::receive()	×
286	{
287	// Enough for MTU 1500 bytes.
288	char buffer[2048];	×
289
290	#if defined(LINUX) \|\| defined(APPLE)
291	struct pollfd fds[1];	×
292	fds[0].fd = _fd;	×
293	fds[0].events = POLLIN;	×
294	#endif
295
296	while (!_should_exit) {	×
297	int recv_len;
298	#if defined(LINUX) \|\| defined(APPLE)
299	int pollrc = poll(fds, 1, 1000);	×
300	if (pollrc == 0 \|\| !(fds[0].revents & POLLIN)) {	×
301	continue;	×
302	} else if (pollrc == -1) {	×
303	LogErr() << "read poll failure: " << GET_ERROR();	×
304	}
305	// We enter here if (fds[0].revents & POLLIN) == true
306	recv_len = static_cast<int>(read(_fd, buffer, sizeof(buffer)));	×
307	if (recv_len < -1) {	×
308	LogErr() << "read failure: " << GET_ERROR();	×
309	}
310	#else
311	if (!ReadFile(_handle, buffer, sizeof(buffer), LPDWORD(&recv_len), NULL)) {
312	LogErr() << "ReadFile failure: " << GET_ERROR();
313	continue;
314	}
315	#endif
316	if (recv_len > static_cast<int>(sizeof(buffer)) \|\| recv_len == 0) {	×
317	continue;	×
318	}
319	_mavlink_receiver->set_new_datagram(buffer, recv_len);	×
320	// Parse all mavlink messages in one data packet. Once exhausted, we'll exit while.
321	while (_mavlink_receiver->parse_message()) {	×
322	receive_message(_mavlink_receiver->get_last_message(), this);	×
323	}
324	}
325	}	×
326
327	#if defined(LINUX)
328	int SerialConnection::define_from_baudrate(int baudrate)	×
329	{
330	switch (baudrate) {	×
331	case 9600:	×
332	return B9600;	×
333	case 19200:	×
334	return B19200;	×
335	case 38400:	×
336	return B38400;	×
337	case 57600:	×
338	return B57600;	×
339	case 115200:	×
340	return B115200;	×
341	case 230400:	×
342	return B230400;	×
343	case 460800:	×
344	return B460800;	×
345	case 500000:	×
346	return B500000;	×
347	case 576000:	×
348	return B576000;	×
349	case 921600:	×
350	return B921600;	×
351	case 1000000:	×
352	return B1000000;	×
353	case 1152000:	×
354	return B1152000;	×
355	case 1500000:	×
356	return B1500000;	×
357	case 2000000:	×
358	return B2000000;	×
359	case 2500000:	×
360	return B2500000;	×
361	case 3000000:	×
362	return B3000000;	×
363	case 3500000:	×
364	return B3500000;	×
365	case 4000000:	×
366	return B4000000;	×
367	default: {	×
368	LogErr() << "Unknown baudrate";	×
369	return -1;	×
370	}
371	}
372	}
373	#endif
374
375	} // namespace mavsdk

mavlink / MAVSDK / 7965506471

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