RflySimSDK v3.05
RflySimSDK说明文档
载入中...
搜索中...
未找到
testsuite.h
浏览该文件的文档.
1
5#pragma once
6#ifndef COMMON_TESTSUITE_H
7#define COMMON_TESTSUITE_H
8
9#ifdef __cplusplus
10extern "C" {
11#endif
12
13#ifndef MAVLINK_TEST_ALL
14#define MAVLINK_TEST_ALL
15
16static void mavlink_test_common(uint8_t, uint8_t, mavlink_message_t *last_msg);
17
18static void mavlink_test_all(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
19{
20
21 mavlink_test_common(system_id, component_id, last_msg);
22}
23#endif
24
25
26
27
28static void mavlink_test_heartbeat(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
29{
30#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
31 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
32 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HEARTBEAT >= 256) {
33 return;
34 }
35#endif
36 mavlink_message_t msg;
37 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
38 uint16_t i;
39 mavlink_heartbeat_t packet_in = {
40 963497464,17,84,151,218,3
41 };
42 mavlink_heartbeat_t packet1, packet2;
43 memset(&packet1, 0, sizeof(packet1));
44 packet1.custom_mode = packet_in.custom_mode;
45 packet1.type = packet_in.type;
46 packet1.autopilot = packet_in.autopilot;
47 packet1.base_mode = packet_in.base_mode;
48 packet1.system_status = packet_in.system_status;
49 packet1.mavlink_version = packet_in.mavlink_version;
50
51
52#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
53 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
54 // cope with extensions
55 memset(MAVLINK_MSG_ID_HEARTBEAT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HEARTBEAT_MIN_LEN);
56 }
57#endif
58 memset(&packet2, 0, sizeof(packet2));
59 mavlink_msg_heartbeat_encode(system_id, component_id, &msg, &packet1);
60 mavlink_msg_heartbeat_decode(&msg, &packet2);
61 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
62
63 memset(&packet2, 0, sizeof(packet2));
64 mavlink_msg_heartbeat_pack(system_id, component_id, &msg , packet1.type , packet1.autopilot , packet1.base_mode , packet1.custom_mode , packet1.system_status );
65 mavlink_msg_heartbeat_decode(&msg, &packet2);
66 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
67
68 memset(&packet2, 0, sizeof(packet2));
69 mavlink_msg_heartbeat_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.type , packet1.autopilot , packet1.base_mode , packet1.custom_mode , packet1.system_status );
70 mavlink_msg_heartbeat_decode(&msg, &packet2);
71 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
72
73 memset(&packet2, 0, sizeof(packet2));
74 mavlink_msg_to_send_buffer(buffer, &msg);
75 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
76 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
77 }
78 mavlink_msg_heartbeat_decode(last_msg, &packet2);
79 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
80
81 memset(&packet2, 0, sizeof(packet2));
82 mavlink_msg_heartbeat_send(MAVLINK_COMM_1 , packet1.type , packet1.autopilot , packet1.base_mode , packet1.custom_mode , packet1.system_status );
83 mavlink_msg_heartbeat_decode(last_msg, &packet2);
84 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
85}
86
87static void mavlink_test_sys_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
88{
89#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
90 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
91 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SYS_STATUS >= 256) {
92 return;
93 }
94#endif
95 mavlink_message_t msg;
96 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
97 uint16_t i;
98 mavlink_sys_status_t packet_in = {
99 963497464,963497672,963497880,17859,17963,18067,18171,18275,18379,18483,18587,18691,223
100 };
101 mavlink_sys_status_t packet1, packet2;
102 memset(&packet1, 0, sizeof(packet1));
103 packet1.onboard_control_sensors_present = packet_in.onboard_control_sensors_present;
104 packet1.onboard_control_sensors_enabled = packet_in.onboard_control_sensors_enabled;
105 packet1.onboard_control_sensors_health = packet_in.onboard_control_sensors_health;
106 packet1.load = packet_in.load;
107 packet1.voltage_battery = packet_in.voltage_battery;
108 packet1.current_battery = packet_in.current_battery;
109 packet1.drop_rate_comm = packet_in.drop_rate_comm;
110 packet1.errors_comm = packet_in.errors_comm;
111 packet1.errors_count1 = packet_in.errors_count1;
112 packet1.errors_count2 = packet_in.errors_count2;
113 packet1.errors_count3 = packet_in.errors_count3;
114 packet1.errors_count4 = packet_in.errors_count4;
115 packet1.battery_remaining = packet_in.battery_remaining;
116
117
118#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
119 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
120 // cope with extensions
121 memset(MAVLINK_MSG_ID_SYS_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SYS_STATUS_MIN_LEN);
122 }
123#endif
124 memset(&packet2, 0, sizeof(packet2));
125 mavlink_msg_sys_status_encode(system_id, component_id, &msg, &packet1);
126 mavlink_msg_sys_status_decode(&msg, &packet2);
127 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
128
129 memset(&packet2, 0, sizeof(packet2));
130 mavlink_msg_sys_status_pack(system_id, component_id, &msg , packet1.onboard_control_sensors_present , packet1.onboard_control_sensors_enabled , packet1.onboard_control_sensors_health , packet1.load , packet1.voltage_battery , packet1.current_battery , packet1.battery_remaining , packet1.drop_rate_comm , packet1.errors_comm , packet1.errors_count1 , packet1.errors_count2 , packet1.errors_count3 , packet1.errors_count4 );
131 mavlink_msg_sys_status_decode(&msg, &packet2);
132 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
133
134 memset(&packet2, 0, sizeof(packet2));
135 mavlink_msg_sys_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.onboard_control_sensors_present , packet1.onboard_control_sensors_enabled , packet1.onboard_control_sensors_health , packet1.load , packet1.voltage_battery , packet1.current_battery , packet1.battery_remaining , packet1.drop_rate_comm , packet1.errors_comm , packet1.errors_count1 , packet1.errors_count2 , packet1.errors_count3 , packet1.errors_count4 );
136 mavlink_msg_sys_status_decode(&msg, &packet2);
137 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
138
139 memset(&packet2, 0, sizeof(packet2));
140 mavlink_msg_to_send_buffer(buffer, &msg);
141 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
142 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
143 }
144 mavlink_msg_sys_status_decode(last_msg, &packet2);
145 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
146
147 memset(&packet2, 0, sizeof(packet2));
148 mavlink_msg_sys_status_send(MAVLINK_COMM_1 , packet1.onboard_control_sensors_present , packet1.onboard_control_sensors_enabled , packet1.onboard_control_sensors_health , packet1.load , packet1.voltage_battery , packet1.current_battery , packet1.battery_remaining , packet1.drop_rate_comm , packet1.errors_comm , packet1.errors_count1 , packet1.errors_count2 , packet1.errors_count3 , packet1.errors_count4 );
149 mavlink_msg_sys_status_decode(last_msg, &packet2);
150 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
151}
152
153static void mavlink_test_system_time(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
154{
155#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
156 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
157 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SYSTEM_TIME >= 256) {
158 return;
159 }
160#endif
161 mavlink_message_t msg;
162 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
163 uint16_t i;
164 mavlink_system_time_t packet_in = {
165 93372036854775807ULL,963497880
166 };
167 mavlink_system_time_t packet1, packet2;
168 memset(&packet1, 0, sizeof(packet1));
169 packet1.time_unix_usec = packet_in.time_unix_usec;
170 packet1.time_boot_ms = packet_in.time_boot_ms;
171
172
173#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
174 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
175 // cope with extensions
176 memset(MAVLINK_MSG_ID_SYSTEM_TIME_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SYSTEM_TIME_MIN_LEN);
177 }
178#endif
179 memset(&packet2, 0, sizeof(packet2));
180 mavlink_msg_system_time_encode(system_id, component_id, &msg, &packet1);
181 mavlink_msg_system_time_decode(&msg, &packet2);
182 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
183
184 memset(&packet2, 0, sizeof(packet2));
185 mavlink_msg_system_time_pack(system_id, component_id, &msg , packet1.time_unix_usec , packet1.time_boot_ms );
186 mavlink_msg_system_time_decode(&msg, &packet2);
187 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
188
189 memset(&packet2, 0, sizeof(packet2));
190 mavlink_msg_system_time_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_unix_usec , packet1.time_boot_ms );
191 mavlink_msg_system_time_decode(&msg, &packet2);
192 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
193
194 memset(&packet2, 0, sizeof(packet2));
195 mavlink_msg_to_send_buffer(buffer, &msg);
196 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
197 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
198 }
199 mavlink_msg_system_time_decode(last_msg, &packet2);
200 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
201
202 memset(&packet2, 0, sizeof(packet2));
203 mavlink_msg_system_time_send(MAVLINK_COMM_1 , packet1.time_unix_usec , packet1.time_boot_ms );
204 mavlink_msg_system_time_decode(last_msg, &packet2);
205 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
206}
207
208static void mavlink_test_ping(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
209{
210#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
211 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
212 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PING >= 256) {
213 return;
214 }
215#endif
216 mavlink_message_t msg;
217 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
218 uint16_t i;
219 mavlink_ping_t packet_in = {
220 93372036854775807ULL,963497880,41,108
221 };
222 mavlink_ping_t packet1, packet2;
223 memset(&packet1, 0, sizeof(packet1));
224 packet1.time_usec = packet_in.time_usec;
225 packet1.seq = packet_in.seq;
226 packet1.target_system = packet_in.target_system;
227 packet1.target_component = packet_in.target_component;
228
229
230#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
231 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
232 // cope with extensions
233 memset(MAVLINK_MSG_ID_PING_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PING_MIN_LEN);
234 }
235#endif
236 memset(&packet2, 0, sizeof(packet2));
237 mavlink_msg_ping_encode(system_id, component_id, &msg, &packet1);
238 mavlink_msg_ping_decode(&msg, &packet2);
239 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
240
241 memset(&packet2, 0, sizeof(packet2));
242 mavlink_msg_ping_pack(system_id, component_id, &msg , packet1.time_usec , packet1.seq , packet1.target_system , packet1.target_component );
243 mavlink_msg_ping_decode(&msg, &packet2);
244 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
245
246 memset(&packet2, 0, sizeof(packet2));
247 mavlink_msg_ping_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.seq , packet1.target_system , packet1.target_component );
248 mavlink_msg_ping_decode(&msg, &packet2);
249 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
250
251 memset(&packet2, 0, sizeof(packet2));
252 mavlink_msg_to_send_buffer(buffer, &msg);
253 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
254 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
255 }
256 mavlink_msg_ping_decode(last_msg, &packet2);
257 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
258
259 memset(&packet2, 0, sizeof(packet2));
260 mavlink_msg_ping_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.seq , packet1.target_system , packet1.target_component );
261 mavlink_msg_ping_decode(last_msg, &packet2);
262 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
263}
264
265static void mavlink_test_change_operator_control(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
266{
267#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
268 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
269 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL >= 256) {
270 return;
271 }
272#endif
273 mavlink_message_t msg;
274 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
275 uint16_t i;
276 mavlink_change_operator_control_t packet_in = {
277 5,72,139,"DEFGHIJKLMNOPQRSTUVWXYZA"
278 };
279 mavlink_change_operator_control_t packet1, packet2;
280 memset(&packet1, 0, sizeof(packet1));
281 packet1.target_system = packet_in.target_system;
282 packet1.control_request = packet_in.control_request;
283 packet1.version = packet_in.version;
284
285 mav_array_memcpy(packet1.passkey, packet_in.passkey, sizeof(char)*25);
286
287#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
288 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
289 // cope with extensions
290 memset(MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_MIN_LEN);
291 }
292#endif
293 memset(&packet2, 0, sizeof(packet2));
294 mavlink_msg_change_operator_control_encode(system_id, component_id, &msg, &packet1);
295 mavlink_msg_change_operator_control_decode(&msg, &packet2);
296 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
297
298 memset(&packet2, 0, sizeof(packet2));
299 mavlink_msg_change_operator_control_pack(system_id, component_id, &msg , packet1.target_system , packet1.control_request , packet1.version , packet1.passkey );
300 mavlink_msg_change_operator_control_decode(&msg, &packet2);
301 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
302
303 memset(&packet2, 0, sizeof(packet2));
304 mavlink_msg_change_operator_control_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.control_request , packet1.version , packet1.passkey );
305 mavlink_msg_change_operator_control_decode(&msg, &packet2);
306 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
307
308 memset(&packet2, 0, sizeof(packet2));
309 mavlink_msg_to_send_buffer(buffer, &msg);
310 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
311 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
312 }
313 mavlink_msg_change_operator_control_decode(last_msg, &packet2);
314 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
315
316 memset(&packet2, 0, sizeof(packet2));
317 mavlink_msg_change_operator_control_send(MAVLINK_COMM_1 , packet1.target_system , packet1.control_request , packet1.version , packet1.passkey );
318 mavlink_msg_change_operator_control_decode(last_msg, &packet2);
319 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
320}
321
322static void mavlink_test_change_operator_control_ack(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
323{
324#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
325 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
326 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK >= 256) {
327 return;
328 }
329#endif
330 mavlink_message_t msg;
331 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
332 uint16_t i;
333 mavlink_change_operator_control_ack_t packet_in = {
334 5,72,139
335 };
336 mavlink_change_operator_control_ack_t packet1, packet2;
337 memset(&packet1, 0, sizeof(packet1));
338 packet1.gcs_system_id = packet_in.gcs_system_id;
339 packet1.control_request = packet_in.control_request;
340 packet1.ack = packet_in.ack;
341
342
343#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
344 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
345 // cope with extensions
346 memset(MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL_ACK_MIN_LEN);
347 }
348#endif
349 memset(&packet2, 0, sizeof(packet2));
350 mavlink_msg_change_operator_control_ack_encode(system_id, component_id, &msg, &packet1);
351 mavlink_msg_change_operator_control_ack_decode(&msg, &packet2);
352 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
353
354 memset(&packet2, 0, sizeof(packet2));
355 mavlink_msg_change_operator_control_ack_pack(system_id, component_id, &msg , packet1.gcs_system_id , packet1.control_request , packet1.ack );
356 mavlink_msg_change_operator_control_ack_decode(&msg, &packet2);
357 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
358
359 memset(&packet2, 0, sizeof(packet2));
360 mavlink_msg_change_operator_control_ack_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.gcs_system_id , packet1.control_request , packet1.ack );
361 mavlink_msg_change_operator_control_ack_decode(&msg, &packet2);
362 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
363
364 memset(&packet2, 0, sizeof(packet2));
365 mavlink_msg_to_send_buffer(buffer, &msg);
366 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
367 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
368 }
369 mavlink_msg_change_operator_control_ack_decode(last_msg, &packet2);
370 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
371
372 memset(&packet2, 0, sizeof(packet2));
373 mavlink_msg_change_operator_control_ack_send(MAVLINK_COMM_1 , packet1.gcs_system_id , packet1.control_request , packet1.ack );
374 mavlink_msg_change_operator_control_ack_decode(last_msg, &packet2);
375 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
376}
377
378static void mavlink_test_auth_key(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
379{
380#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
381 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
382 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_AUTH_KEY >= 256) {
383 return;
384 }
385#endif
386 mavlink_message_t msg;
387 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
388 uint16_t i;
389 mavlink_auth_key_t packet_in = {
390 "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDE"
391 };
392 mavlink_auth_key_t packet1, packet2;
393 memset(&packet1, 0, sizeof(packet1));
394
395 mav_array_memcpy(packet1.key, packet_in.key, sizeof(char)*32);
396
397#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
398 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
399 // cope with extensions
400 memset(MAVLINK_MSG_ID_AUTH_KEY_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_AUTH_KEY_MIN_LEN);
401 }
402#endif
403 memset(&packet2, 0, sizeof(packet2));
404 mavlink_msg_auth_key_encode(system_id, component_id, &msg, &packet1);
405 mavlink_msg_auth_key_decode(&msg, &packet2);
406 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
407
408 memset(&packet2, 0, sizeof(packet2));
409 mavlink_msg_auth_key_pack(system_id, component_id, &msg , packet1.key );
410 mavlink_msg_auth_key_decode(&msg, &packet2);
411 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
412
413 memset(&packet2, 0, sizeof(packet2));
414 mavlink_msg_auth_key_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.key );
415 mavlink_msg_auth_key_decode(&msg, &packet2);
416 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
417
418 memset(&packet2, 0, sizeof(packet2));
419 mavlink_msg_to_send_buffer(buffer, &msg);
420 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
421 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
422 }
423 mavlink_msg_auth_key_decode(last_msg, &packet2);
424 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
425
426 memset(&packet2, 0, sizeof(packet2));
427 mavlink_msg_auth_key_send(MAVLINK_COMM_1 , packet1.key );
428 mavlink_msg_auth_key_decode(last_msg, &packet2);
429 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
430}
431
432static void mavlink_test_set_mode(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
433{
434#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
435 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
436 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SET_MODE >= 256) {
437 return;
438 }
439#endif
440 mavlink_message_t msg;
441 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
442 uint16_t i;
443 mavlink_set_mode_t packet_in = {
444 963497464,17,84
445 };
446 mavlink_set_mode_t packet1, packet2;
447 memset(&packet1, 0, sizeof(packet1));
448 packet1.custom_mode = packet_in.custom_mode;
449 packet1.target_system = packet_in.target_system;
450 packet1.base_mode = packet_in.base_mode;
451
452
453#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
454 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
455 // cope with extensions
456 memset(MAVLINK_MSG_ID_SET_MODE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SET_MODE_MIN_LEN);
457 }
458#endif
459 memset(&packet2, 0, sizeof(packet2));
460 mavlink_msg_set_mode_encode(system_id, component_id, &msg, &packet1);
461 mavlink_msg_set_mode_decode(&msg, &packet2);
462 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
463
464 memset(&packet2, 0, sizeof(packet2));
465 mavlink_msg_set_mode_pack(system_id, component_id, &msg , packet1.target_system , packet1.base_mode , packet1.custom_mode );
466 mavlink_msg_set_mode_decode(&msg, &packet2);
467 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
468
469 memset(&packet2, 0, sizeof(packet2));
470 mavlink_msg_set_mode_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.base_mode , packet1.custom_mode );
471 mavlink_msg_set_mode_decode(&msg, &packet2);
472 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
473
474 memset(&packet2, 0, sizeof(packet2));
475 mavlink_msg_to_send_buffer(buffer, &msg);
476 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
477 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
478 }
479 mavlink_msg_set_mode_decode(last_msg, &packet2);
480 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
481
482 memset(&packet2, 0, sizeof(packet2));
483 mavlink_msg_set_mode_send(MAVLINK_COMM_1 , packet1.target_system , packet1.base_mode , packet1.custom_mode );
484 mavlink_msg_set_mode_decode(last_msg, &packet2);
485 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
486}
487
488static void mavlink_test_param_request_read(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
489{
490#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
491 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
492 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PARAM_REQUEST_READ >= 256) {
493 return;
494 }
495#endif
496 mavlink_message_t msg;
497 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
498 uint16_t i;
499 mavlink_param_request_read_t packet_in = {
500 17235,139,206,"EFGHIJKLMNOPQRS"
501 };
502 mavlink_param_request_read_t packet1, packet2;
503 memset(&packet1, 0, sizeof(packet1));
504 packet1.param_index = packet_in.param_index;
505 packet1.target_system = packet_in.target_system;
506 packet1.target_component = packet_in.target_component;
507
508 mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(char)*16);
509
510#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
511 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
512 // cope with extensions
513 memset(MAVLINK_MSG_ID_PARAM_REQUEST_READ_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PARAM_REQUEST_READ_MIN_LEN);
514 }
515#endif
516 memset(&packet2, 0, sizeof(packet2));
517 mavlink_msg_param_request_read_encode(system_id, component_id, &msg, &packet1);
518 mavlink_msg_param_request_read_decode(&msg, &packet2);
519 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
520
521 memset(&packet2, 0, sizeof(packet2));
522 mavlink_msg_param_request_read_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index );
523 mavlink_msg_param_request_read_decode(&msg, &packet2);
524 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
525
526 memset(&packet2, 0, sizeof(packet2));
527 mavlink_msg_param_request_read_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index );
528 mavlink_msg_param_request_read_decode(&msg, &packet2);
529 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
530
531 memset(&packet2, 0, sizeof(packet2));
532 mavlink_msg_to_send_buffer(buffer, &msg);
533 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
534 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
535 }
536 mavlink_msg_param_request_read_decode(last_msg, &packet2);
537 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
538
539 memset(&packet2, 0, sizeof(packet2));
540 mavlink_msg_param_request_read_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index );
541 mavlink_msg_param_request_read_decode(last_msg, &packet2);
542 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
543}
544
545static void mavlink_test_param_request_list(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
546{
547#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
548 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
549 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PARAM_REQUEST_LIST >= 256) {
550 return;
551 }
552#endif
553 mavlink_message_t msg;
554 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
555 uint16_t i;
556 mavlink_param_request_list_t packet_in = {
557 5,72
558 };
559 mavlink_param_request_list_t packet1, packet2;
560 memset(&packet1, 0, sizeof(packet1));
561 packet1.target_system = packet_in.target_system;
562 packet1.target_component = packet_in.target_component;
563
564
565#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
566 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
567 // cope with extensions
568 memset(MAVLINK_MSG_ID_PARAM_REQUEST_LIST_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PARAM_REQUEST_LIST_MIN_LEN);
569 }
570#endif
571 memset(&packet2, 0, sizeof(packet2));
572 mavlink_msg_param_request_list_encode(system_id, component_id, &msg, &packet1);
573 mavlink_msg_param_request_list_decode(&msg, &packet2);
574 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
575
576 memset(&packet2, 0, sizeof(packet2));
577 mavlink_msg_param_request_list_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component );
578 mavlink_msg_param_request_list_decode(&msg, &packet2);
579 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
580
581 memset(&packet2, 0, sizeof(packet2));
582 mavlink_msg_param_request_list_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component );
583 mavlink_msg_param_request_list_decode(&msg, &packet2);
584 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
585
586 memset(&packet2, 0, sizeof(packet2));
587 mavlink_msg_to_send_buffer(buffer, &msg);
588 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
589 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
590 }
591 mavlink_msg_param_request_list_decode(last_msg, &packet2);
592 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
593
594 memset(&packet2, 0, sizeof(packet2));
595 mavlink_msg_param_request_list_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component );
596 mavlink_msg_param_request_list_decode(last_msg, &packet2);
597 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
598}
599
600static void mavlink_test_param_value(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
601{
602#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
603 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
604 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PARAM_VALUE >= 256) {
605 return;
606 }
607#endif
608 mavlink_message_t msg;
609 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
610 uint16_t i;
611 mavlink_param_value_t packet_in = {
612 17.0,17443,17547,"IJKLMNOPQRSTUVW",77
613 };
614 mavlink_param_value_t packet1, packet2;
615 memset(&packet1, 0, sizeof(packet1));
616 packet1.param_value = packet_in.param_value;
617 packet1.param_count = packet_in.param_count;
618 packet1.param_index = packet_in.param_index;
619 packet1.param_type = packet_in.param_type;
620
621 mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(char)*16);
622
623#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
624 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
625 // cope with extensions
626 memset(MAVLINK_MSG_ID_PARAM_VALUE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PARAM_VALUE_MIN_LEN);
627 }
628#endif
629 memset(&packet2, 0, sizeof(packet2));
630 mavlink_msg_param_value_encode(system_id, component_id, &msg, &packet1);
631 mavlink_msg_param_value_decode(&msg, &packet2);
632 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
633
634 memset(&packet2, 0, sizeof(packet2));
635 mavlink_msg_param_value_pack(system_id, component_id, &msg , packet1.param_id , packet1.param_value , packet1.param_type , packet1.param_count , packet1.param_index );
636 mavlink_msg_param_value_decode(&msg, &packet2);
637 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
638
639 memset(&packet2, 0, sizeof(packet2));
640 mavlink_msg_param_value_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.param_id , packet1.param_value , packet1.param_type , packet1.param_count , packet1.param_index );
641 mavlink_msg_param_value_decode(&msg, &packet2);
642 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
643
644 memset(&packet2, 0, sizeof(packet2));
645 mavlink_msg_to_send_buffer(buffer, &msg);
646 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
647 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
648 }
649 mavlink_msg_param_value_decode(last_msg, &packet2);
650 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
651
652 memset(&packet2, 0, sizeof(packet2));
653 mavlink_msg_param_value_send(MAVLINK_COMM_1 , packet1.param_id , packet1.param_value , packet1.param_type , packet1.param_count , packet1.param_index );
654 mavlink_msg_param_value_decode(last_msg, &packet2);
655 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
656}
657
658static void mavlink_test_param_set(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
659{
660#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
661 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
662 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PARAM_SET >= 256) {
663 return;
664 }
665#endif
666 mavlink_message_t msg;
667 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
668 uint16_t i;
669 mavlink_param_set_t packet_in = {
670 17.0,17,84,"GHIJKLMNOPQRSTU",199
671 };
672 mavlink_param_set_t packet1, packet2;
673 memset(&packet1, 0, sizeof(packet1));
674 packet1.param_value = packet_in.param_value;
675 packet1.target_system = packet_in.target_system;
676 packet1.target_component = packet_in.target_component;
677 packet1.param_type = packet_in.param_type;
678
679 mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(char)*16);
680
681#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
682 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
683 // cope with extensions
684 memset(MAVLINK_MSG_ID_PARAM_SET_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PARAM_SET_MIN_LEN);
685 }
686#endif
687 memset(&packet2, 0, sizeof(packet2));
688 mavlink_msg_param_set_encode(system_id, component_id, &msg, &packet1);
689 mavlink_msg_param_set_decode(&msg, &packet2);
690 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
691
692 memset(&packet2, 0, sizeof(packet2));
693 mavlink_msg_param_set_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_value , packet1.param_type );
694 mavlink_msg_param_set_decode(&msg, &packet2);
695 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
696
697 memset(&packet2, 0, sizeof(packet2));
698 mavlink_msg_param_set_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_value , packet1.param_type );
699 mavlink_msg_param_set_decode(&msg, &packet2);
700 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
701
702 memset(&packet2, 0, sizeof(packet2));
703 mavlink_msg_to_send_buffer(buffer, &msg);
704 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
705 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
706 }
707 mavlink_msg_param_set_decode(last_msg, &packet2);
708 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
709
710 memset(&packet2, 0, sizeof(packet2));
711 mavlink_msg_param_set_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_value , packet1.param_type );
712 mavlink_msg_param_set_decode(last_msg, &packet2);
713 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
714}
715
716static void mavlink_test_gps_raw_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
717{
718#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
719 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
720 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GPS_RAW_INT >= 256) {
721 return;
722 }
723#endif
724 mavlink_message_t msg;
725 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
726 uint16_t i;
727 mavlink_gps_raw_int_t packet_in = {
728 93372036854775807ULL,963497880,963498088,963498296,18275,18379,18483,18587,89,156,963499024,963499232,963499440,963499648,963499856
729 };
730 mavlink_gps_raw_int_t packet1, packet2;
731 memset(&packet1, 0, sizeof(packet1));
732 packet1.time_usec = packet_in.time_usec;
733 packet1.lat = packet_in.lat;
734 packet1.lon = packet_in.lon;
735 packet1.alt = packet_in.alt;
736 packet1.eph = packet_in.eph;
737 packet1.epv = packet_in.epv;
738 packet1.vel = packet_in.vel;
739 packet1.cog = packet_in.cog;
740 packet1.fix_type = packet_in.fix_type;
741 packet1.satellites_visible = packet_in.satellites_visible;
742 packet1.alt_ellipsoid = packet_in.alt_ellipsoid;
743 packet1.h_acc = packet_in.h_acc;
744 packet1.v_acc = packet_in.v_acc;
745 packet1.vel_acc = packet_in.vel_acc;
746 packet1.hdg_acc = packet_in.hdg_acc;
747
748
749#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
750 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
751 // cope with extensions
752 memset(MAVLINK_MSG_ID_GPS_RAW_INT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GPS_RAW_INT_MIN_LEN);
753 }
754#endif
755 memset(&packet2, 0, sizeof(packet2));
756 mavlink_msg_gps_raw_int_encode(system_id, component_id, &msg, &packet1);
757 mavlink_msg_gps_raw_int_decode(&msg, &packet2);
758 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
759
760 memset(&packet2, 0, sizeof(packet2));
761 mavlink_msg_gps_raw_int_pack(system_id, component_id, &msg , packet1.time_usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.vel , packet1.cog , packet1.satellites_visible , packet1.alt_ellipsoid , packet1.h_acc , packet1.v_acc , packet1.vel_acc , packet1.hdg_acc );
762 mavlink_msg_gps_raw_int_decode(&msg, &packet2);
763 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
764
765 memset(&packet2, 0, sizeof(packet2));
766 mavlink_msg_gps_raw_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.vel , packet1.cog , packet1.satellites_visible , packet1.alt_ellipsoid , packet1.h_acc , packet1.v_acc , packet1.vel_acc , packet1.hdg_acc );
767 mavlink_msg_gps_raw_int_decode(&msg, &packet2);
768 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
769
770 memset(&packet2, 0, sizeof(packet2));
771 mavlink_msg_to_send_buffer(buffer, &msg);
772 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
773 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
774 }
775 mavlink_msg_gps_raw_int_decode(last_msg, &packet2);
776 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
777
778 memset(&packet2, 0, sizeof(packet2));
779 mavlink_msg_gps_raw_int_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.vel , packet1.cog , packet1.satellites_visible , packet1.alt_ellipsoid , packet1.h_acc , packet1.v_acc , packet1.vel_acc , packet1.hdg_acc );
780 mavlink_msg_gps_raw_int_decode(last_msg, &packet2);
781 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
782}
783
784static void mavlink_test_gps_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
785{
786#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
787 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
788 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GPS_STATUS >= 256) {
789 return;
790 }
791#endif
792 mavlink_message_t msg;
793 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
794 uint16_t i;
795 mavlink_gps_status_t packet_in = {
796 5,{ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91 },{ 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151 },{ 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211 },{ 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },{ 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 }
797 };
798 mavlink_gps_status_t packet1, packet2;
799 memset(&packet1, 0, sizeof(packet1));
800 packet1.satellites_visible = packet_in.satellites_visible;
801
802 mav_array_memcpy(packet1.satellite_prn, packet_in.satellite_prn, sizeof(uint8_t)*20);
803 mav_array_memcpy(packet1.satellite_used, packet_in.satellite_used, sizeof(uint8_t)*20);
804 mav_array_memcpy(packet1.satellite_elevation, packet_in.satellite_elevation, sizeof(uint8_t)*20);
805 mav_array_memcpy(packet1.satellite_azimuth, packet_in.satellite_azimuth, sizeof(uint8_t)*20);
806 mav_array_memcpy(packet1.satellite_snr, packet_in.satellite_snr, sizeof(uint8_t)*20);
807
808#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
809 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
810 // cope with extensions
811 memset(MAVLINK_MSG_ID_GPS_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GPS_STATUS_MIN_LEN);
812 }
813#endif
814 memset(&packet2, 0, sizeof(packet2));
815 mavlink_msg_gps_status_encode(system_id, component_id, &msg, &packet1);
816 mavlink_msg_gps_status_decode(&msg, &packet2);
817 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
818
819 memset(&packet2, 0, sizeof(packet2));
820 mavlink_msg_gps_status_pack(system_id, component_id, &msg , packet1.satellites_visible , packet1.satellite_prn , packet1.satellite_used , packet1.satellite_elevation , packet1.satellite_azimuth , packet1.satellite_snr );
821 mavlink_msg_gps_status_decode(&msg, &packet2);
822 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
823
824 memset(&packet2, 0, sizeof(packet2));
825 mavlink_msg_gps_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.satellites_visible , packet1.satellite_prn , packet1.satellite_used , packet1.satellite_elevation , packet1.satellite_azimuth , packet1.satellite_snr );
826 mavlink_msg_gps_status_decode(&msg, &packet2);
827 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
828
829 memset(&packet2, 0, sizeof(packet2));
830 mavlink_msg_to_send_buffer(buffer, &msg);
831 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
832 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
833 }
834 mavlink_msg_gps_status_decode(last_msg, &packet2);
835 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
836
837 memset(&packet2, 0, sizeof(packet2));
838 mavlink_msg_gps_status_send(MAVLINK_COMM_1 , packet1.satellites_visible , packet1.satellite_prn , packet1.satellite_used , packet1.satellite_elevation , packet1.satellite_azimuth , packet1.satellite_snr );
839 mavlink_msg_gps_status_decode(last_msg, &packet2);
840 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
841}
842
843static void mavlink_test_scaled_imu(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
844{
845#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
846 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
847 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SCALED_IMU >= 256) {
848 return;
849 }
850#endif
851 mavlink_message_t msg;
852 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
853 uint16_t i;
854 mavlink_scaled_imu_t packet_in = {
855 963497464,17443,17547,17651,17755,17859,17963,18067,18171,18275
856 };
857 mavlink_scaled_imu_t packet1, packet2;
858 memset(&packet1, 0, sizeof(packet1));
859 packet1.time_boot_ms = packet_in.time_boot_ms;
860 packet1.xacc = packet_in.xacc;
861 packet1.yacc = packet_in.yacc;
862 packet1.zacc = packet_in.zacc;
863 packet1.xgyro = packet_in.xgyro;
864 packet1.ygyro = packet_in.ygyro;
865 packet1.zgyro = packet_in.zgyro;
866 packet1.xmag = packet_in.xmag;
867 packet1.ymag = packet_in.ymag;
868 packet1.zmag = packet_in.zmag;
869
870
871#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
872 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
873 // cope with extensions
874 memset(MAVLINK_MSG_ID_SCALED_IMU_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SCALED_IMU_MIN_LEN);
875 }
876#endif
877 memset(&packet2, 0, sizeof(packet2));
878 mavlink_msg_scaled_imu_encode(system_id, component_id, &msg, &packet1);
879 mavlink_msg_scaled_imu_decode(&msg, &packet2);
880 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
881
882 memset(&packet2, 0, sizeof(packet2));
883 mavlink_msg_scaled_imu_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
884 mavlink_msg_scaled_imu_decode(&msg, &packet2);
885 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
886
887 memset(&packet2, 0, sizeof(packet2));
888 mavlink_msg_scaled_imu_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
889 mavlink_msg_scaled_imu_decode(&msg, &packet2);
890 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
891
892 memset(&packet2, 0, sizeof(packet2));
893 mavlink_msg_to_send_buffer(buffer, &msg);
894 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
895 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
896 }
897 mavlink_msg_scaled_imu_decode(last_msg, &packet2);
898 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
899
900 memset(&packet2, 0, sizeof(packet2));
901 mavlink_msg_scaled_imu_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
902 mavlink_msg_scaled_imu_decode(last_msg, &packet2);
903 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
904}
905
906static void mavlink_test_raw_imu(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
907{
908#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
909 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
910 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_RAW_IMU >= 256) {
911 return;
912 }
913#endif
914 mavlink_message_t msg;
915 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
916 uint16_t i;
917 mavlink_raw_imu_t packet_in = {
918 93372036854775807ULL,17651,17755,17859,17963,18067,18171,18275,18379,18483
919 };
920 mavlink_raw_imu_t packet1, packet2;
921 memset(&packet1, 0, sizeof(packet1));
922 packet1.time_usec = packet_in.time_usec;
923 packet1.xacc = packet_in.xacc;
924 packet1.yacc = packet_in.yacc;
925 packet1.zacc = packet_in.zacc;
926 packet1.xgyro = packet_in.xgyro;
927 packet1.ygyro = packet_in.ygyro;
928 packet1.zgyro = packet_in.zgyro;
929 packet1.xmag = packet_in.xmag;
930 packet1.ymag = packet_in.ymag;
931 packet1.zmag = packet_in.zmag;
932
933
934#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
935 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
936 // cope with extensions
937 memset(MAVLINK_MSG_ID_RAW_IMU_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_RAW_IMU_MIN_LEN);
938 }
939#endif
940 memset(&packet2, 0, sizeof(packet2));
941 mavlink_msg_raw_imu_encode(system_id, component_id, &msg, &packet1);
942 mavlink_msg_raw_imu_decode(&msg, &packet2);
943 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
944
945 memset(&packet2, 0, sizeof(packet2));
946 mavlink_msg_raw_imu_pack(system_id, component_id, &msg , packet1.time_usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
947 mavlink_msg_raw_imu_decode(&msg, &packet2);
948 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
949
950 memset(&packet2, 0, sizeof(packet2));
951 mavlink_msg_raw_imu_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
952 mavlink_msg_raw_imu_decode(&msg, &packet2);
953 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
954
955 memset(&packet2, 0, sizeof(packet2));
956 mavlink_msg_to_send_buffer(buffer, &msg);
957 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
958 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
959 }
960 mavlink_msg_raw_imu_decode(last_msg, &packet2);
961 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
962
963 memset(&packet2, 0, sizeof(packet2));
964 mavlink_msg_raw_imu_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
965 mavlink_msg_raw_imu_decode(last_msg, &packet2);
966 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
967}
968
969static void mavlink_test_raw_pressure(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
970{
971#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
972 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
973 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_RAW_PRESSURE >= 256) {
974 return;
975 }
976#endif
977 mavlink_message_t msg;
978 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
979 uint16_t i;
980 mavlink_raw_pressure_t packet_in = {
981 93372036854775807ULL,17651,17755,17859,17963
982 };
983 mavlink_raw_pressure_t packet1, packet2;
984 memset(&packet1, 0, sizeof(packet1));
985 packet1.time_usec = packet_in.time_usec;
986 packet1.press_abs = packet_in.press_abs;
987 packet1.press_diff1 = packet_in.press_diff1;
988 packet1.press_diff2 = packet_in.press_diff2;
989 packet1.temperature = packet_in.temperature;
990
991
992#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
993 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
994 // cope with extensions
995 memset(MAVLINK_MSG_ID_RAW_PRESSURE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_RAW_PRESSURE_MIN_LEN);
996 }
997#endif
998 memset(&packet2, 0, sizeof(packet2));
999 mavlink_msg_raw_pressure_encode(system_id, component_id, &msg, &packet1);
1000 mavlink_msg_raw_pressure_decode(&msg, &packet2);
1001 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1002
1003 memset(&packet2, 0, sizeof(packet2));
1004 mavlink_msg_raw_pressure_pack(system_id, component_id, &msg , packet1.time_usec , packet1.press_abs , packet1.press_diff1 , packet1.press_diff2 , packet1.temperature );
1005 mavlink_msg_raw_pressure_decode(&msg, &packet2);
1006 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1007
1008 memset(&packet2, 0, sizeof(packet2));
1009 mavlink_msg_raw_pressure_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.press_abs , packet1.press_diff1 , packet1.press_diff2 , packet1.temperature );
1010 mavlink_msg_raw_pressure_decode(&msg, &packet2);
1011 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1012
1013 memset(&packet2, 0, sizeof(packet2));
1014 mavlink_msg_to_send_buffer(buffer, &msg);
1015 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1016 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1017 }
1018 mavlink_msg_raw_pressure_decode(last_msg, &packet2);
1019 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1020
1021 memset(&packet2, 0, sizeof(packet2));
1022 mavlink_msg_raw_pressure_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.press_abs , packet1.press_diff1 , packet1.press_diff2 , packet1.temperature );
1023 mavlink_msg_raw_pressure_decode(last_msg, &packet2);
1024 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1025}
1026
1027static void mavlink_test_scaled_pressure(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1028{
1029#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1030 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1031 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SCALED_PRESSURE >= 256) {
1032 return;
1033 }
1034#endif
1035 mavlink_message_t msg;
1036 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1037 uint16_t i;
1038 mavlink_scaled_pressure_t packet_in = {
1039 963497464,45.0,73.0,17859
1040 };
1041 mavlink_scaled_pressure_t packet1, packet2;
1042 memset(&packet1, 0, sizeof(packet1));
1043 packet1.time_boot_ms = packet_in.time_boot_ms;
1044 packet1.press_abs = packet_in.press_abs;
1045 packet1.press_diff = packet_in.press_diff;
1046 packet1.temperature = packet_in.temperature;
1047
1048
1049#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1050 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1051 // cope with extensions
1052 memset(MAVLINK_MSG_ID_SCALED_PRESSURE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SCALED_PRESSURE_MIN_LEN);
1053 }
1054#endif
1055 memset(&packet2, 0, sizeof(packet2));
1056 mavlink_msg_scaled_pressure_encode(system_id, component_id, &msg, &packet1);
1057 mavlink_msg_scaled_pressure_decode(&msg, &packet2);
1058 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1059
1060 memset(&packet2, 0, sizeof(packet2));
1061 mavlink_msg_scaled_pressure_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.press_abs , packet1.press_diff , packet1.temperature );
1062 mavlink_msg_scaled_pressure_decode(&msg, &packet2);
1063 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1064
1065 memset(&packet2, 0, sizeof(packet2));
1066 mavlink_msg_scaled_pressure_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.press_abs , packet1.press_diff , packet1.temperature );
1067 mavlink_msg_scaled_pressure_decode(&msg, &packet2);
1068 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1069
1070 memset(&packet2, 0, sizeof(packet2));
1071 mavlink_msg_to_send_buffer(buffer, &msg);
1072 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1073 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1074 }
1075 mavlink_msg_scaled_pressure_decode(last_msg, &packet2);
1076 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1077
1078 memset(&packet2, 0, sizeof(packet2));
1079 mavlink_msg_scaled_pressure_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.press_abs , packet1.press_diff , packet1.temperature );
1080 mavlink_msg_scaled_pressure_decode(last_msg, &packet2);
1081 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1082}
1083
1084static void mavlink_test_attitude(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1085{
1086#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1087 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1088 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ATTITUDE >= 256) {
1089 return;
1090 }
1091#endif
1092 mavlink_message_t msg;
1093 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1094 uint16_t i;
1095 mavlink_attitude_t packet_in = {
1096 963497464,45.0,73.0,101.0,129.0,157.0,185.0
1097 };
1098 mavlink_attitude_t packet1, packet2;
1099 memset(&packet1, 0, sizeof(packet1));
1100 packet1.time_boot_ms = packet_in.time_boot_ms;
1101 packet1.roll = packet_in.roll;
1102 packet1.pitch = packet_in.pitch;
1103 packet1.yaw = packet_in.yaw;
1104 packet1.rollspeed = packet_in.rollspeed;
1105 packet1.pitchspeed = packet_in.pitchspeed;
1106 packet1.yawspeed = packet_in.yawspeed;
1107
1108
1109#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1110 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1111 // cope with extensions
1112 memset(MAVLINK_MSG_ID_ATTITUDE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ATTITUDE_MIN_LEN);
1113 }
1114#endif
1115 memset(&packet2, 0, sizeof(packet2));
1116 mavlink_msg_attitude_encode(system_id, component_id, &msg, &packet1);
1117 mavlink_msg_attitude_decode(&msg, &packet2);
1118 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1119
1120 memset(&packet2, 0, sizeof(packet2));
1121 mavlink_msg_attitude_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.roll , packet1.pitch , packet1.yaw , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed );
1122 mavlink_msg_attitude_decode(&msg, &packet2);
1123 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1124
1125 memset(&packet2, 0, sizeof(packet2));
1126 mavlink_msg_attitude_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.roll , packet1.pitch , packet1.yaw , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed );
1127 mavlink_msg_attitude_decode(&msg, &packet2);
1128 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1129
1130 memset(&packet2, 0, sizeof(packet2));
1131 mavlink_msg_to_send_buffer(buffer, &msg);
1132 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1133 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1134 }
1135 mavlink_msg_attitude_decode(last_msg, &packet2);
1136 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1137
1138 memset(&packet2, 0, sizeof(packet2));
1139 mavlink_msg_attitude_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.roll , packet1.pitch , packet1.yaw , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed );
1140 mavlink_msg_attitude_decode(last_msg, &packet2);
1141 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1142}
1143
1144static void mavlink_test_attitude_quaternion(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1145{
1146#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1147 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1148 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ATTITUDE_QUATERNION >= 256) {
1149 return;
1150 }
1151#endif
1152 mavlink_message_t msg;
1153 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1154 uint16_t i;
1155 mavlink_attitude_quaternion_t packet_in = {
1156 963497464,45.0,73.0,101.0,129.0,157.0,185.0,213.0
1157 };
1158 mavlink_attitude_quaternion_t packet1, packet2;
1159 memset(&packet1, 0, sizeof(packet1));
1160 packet1.time_boot_ms = packet_in.time_boot_ms;
1161 packet1.q1 = packet_in.q1;
1162 packet1.q2 = packet_in.q2;
1163 packet1.q3 = packet_in.q3;
1164 packet1.q4 = packet_in.q4;
1165 packet1.rollspeed = packet_in.rollspeed;
1166 packet1.pitchspeed = packet_in.pitchspeed;
1167 packet1.yawspeed = packet_in.yawspeed;
1168
1169
1170#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1171 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1172 // cope with extensions
1173 memset(MAVLINK_MSG_ID_ATTITUDE_QUATERNION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ATTITUDE_QUATERNION_MIN_LEN);
1174 }
1175#endif
1176 memset(&packet2, 0, sizeof(packet2));
1177 mavlink_msg_attitude_quaternion_encode(system_id, component_id, &msg, &packet1);
1178 mavlink_msg_attitude_quaternion_decode(&msg, &packet2);
1179 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1180
1181 memset(&packet2, 0, sizeof(packet2));
1182 mavlink_msg_attitude_quaternion_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.q1 , packet1.q2 , packet1.q3 , packet1.q4 , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed );
1183 mavlink_msg_attitude_quaternion_decode(&msg, &packet2);
1184 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1185
1186 memset(&packet2, 0, sizeof(packet2));
1187 mavlink_msg_attitude_quaternion_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.q1 , packet1.q2 , packet1.q3 , packet1.q4 , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed );
1188 mavlink_msg_attitude_quaternion_decode(&msg, &packet2);
1189 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1190
1191 memset(&packet2, 0, sizeof(packet2));
1192 mavlink_msg_to_send_buffer(buffer, &msg);
1193 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1194 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1195 }
1196 mavlink_msg_attitude_quaternion_decode(last_msg, &packet2);
1197 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1198
1199 memset(&packet2, 0, sizeof(packet2));
1200 mavlink_msg_attitude_quaternion_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.q1 , packet1.q2 , packet1.q3 , packet1.q4 , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed );
1201 mavlink_msg_attitude_quaternion_decode(last_msg, &packet2);
1202 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1203}
1204
1205static void mavlink_test_local_position_ned(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1206{
1207#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1208 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1209 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOCAL_POSITION_NED >= 256) {
1210 return;
1211 }
1212#endif
1213 mavlink_message_t msg;
1214 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1215 uint16_t i;
1216 mavlink_local_position_ned_t packet_in = {
1217 963497464,45.0,73.0,101.0,129.0,157.0,185.0
1218 };
1219 mavlink_local_position_ned_t packet1, packet2;
1220 memset(&packet1, 0, sizeof(packet1));
1221 packet1.time_boot_ms = packet_in.time_boot_ms;
1222 packet1.x = packet_in.x;
1223 packet1.y = packet_in.y;
1224 packet1.z = packet_in.z;
1225 packet1.vx = packet_in.vx;
1226 packet1.vy = packet_in.vy;
1227 packet1.vz = packet_in.vz;
1228
1229
1230#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1231 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1232 // cope with extensions
1233 memset(MAVLINK_MSG_ID_LOCAL_POSITION_NED_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOCAL_POSITION_NED_MIN_LEN);
1234 }
1235#endif
1236 memset(&packet2, 0, sizeof(packet2));
1237 mavlink_msg_local_position_ned_encode(system_id, component_id, &msg, &packet1);
1238 mavlink_msg_local_position_ned_decode(&msg, &packet2);
1239 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1240
1241 memset(&packet2, 0, sizeof(packet2));
1242 mavlink_msg_local_position_ned_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz );
1243 mavlink_msg_local_position_ned_decode(&msg, &packet2);
1244 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1245
1246 memset(&packet2, 0, sizeof(packet2));
1247 mavlink_msg_local_position_ned_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz );
1248 mavlink_msg_local_position_ned_decode(&msg, &packet2);
1249 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1250
1251 memset(&packet2, 0, sizeof(packet2));
1252 mavlink_msg_to_send_buffer(buffer, &msg);
1253 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1254 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1255 }
1256 mavlink_msg_local_position_ned_decode(last_msg, &packet2);
1257 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1258
1259 memset(&packet2, 0, sizeof(packet2));
1260 mavlink_msg_local_position_ned_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz );
1261 mavlink_msg_local_position_ned_decode(last_msg, &packet2);
1262 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1263}
1264
1265static void mavlink_test_global_position_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1266{
1267#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1268 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1269 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GLOBAL_POSITION_INT >= 256) {
1270 return;
1271 }
1272#endif
1273 mavlink_message_t msg;
1274 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1275 uint16_t i;
1276 mavlink_global_position_int_t packet_in = {
1277 963497464,963497672,963497880,963498088,963498296,18275,18379,18483,18587
1278 };
1279 mavlink_global_position_int_t packet1, packet2;
1280 memset(&packet1, 0, sizeof(packet1));
1281 packet1.time_boot_ms = packet_in.time_boot_ms;
1282 packet1.lat = packet_in.lat;
1283 packet1.lon = packet_in.lon;
1284 packet1.alt = packet_in.alt;
1285 packet1.relative_alt = packet_in.relative_alt;
1286 packet1.vx = packet_in.vx;
1287 packet1.vy = packet_in.vy;
1288 packet1.vz = packet_in.vz;
1289 packet1.hdg = packet_in.hdg;
1290
1291
1292#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1293 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1294 // cope with extensions
1295 memset(MAVLINK_MSG_ID_GLOBAL_POSITION_INT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GLOBAL_POSITION_INT_MIN_LEN);
1296 }
1297#endif
1298 memset(&packet2, 0, sizeof(packet2));
1299 mavlink_msg_global_position_int_encode(system_id, component_id, &msg, &packet1);
1300 mavlink_msg_global_position_int_decode(&msg, &packet2);
1301 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1302
1303 memset(&packet2, 0, sizeof(packet2));
1304 mavlink_msg_global_position_int_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.lat , packet1.lon , packet1.alt , packet1.relative_alt , packet1.vx , packet1.vy , packet1.vz , packet1.hdg );
1305 mavlink_msg_global_position_int_decode(&msg, &packet2);
1306 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1307
1308 memset(&packet2, 0, sizeof(packet2));
1309 mavlink_msg_global_position_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.lat , packet1.lon , packet1.alt , packet1.relative_alt , packet1.vx , packet1.vy , packet1.vz , packet1.hdg );
1310 mavlink_msg_global_position_int_decode(&msg, &packet2);
1311 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1312
1313 memset(&packet2, 0, sizeof(packet2));
1314 mavlink_msg_to_send_buffer(buffer, &msg);
1315 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1316 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1317 }
1318 mavlink_msg_global_position_int_decode(last_msg, &packet2);
1319 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1320
1321 memset(&packet2, 0, sizeof(packet2));
1322 mavlink_msg_global_position_int_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.lat , packet1.lon , packet1.alt , packet1.relative_alt , packet1.vx , packet1.vy , packet1.vz , packet1.hdg );
1323 mavlink_msg_global_position_int_decode(last_msg, &packet2);
1324 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1325}
1326
1327static void mavlink_test_rc_channels_scaled(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1328{
1329#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1330 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1331 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_RC_CHANNELS_SCALED >= 256) {
1332 return;
1333 }
1334#endif
1335 mavlink_message_t msg;
1336 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1337 uint16_t i;
1338 mavlink_rc_channels_scaled_t packet_in = {
1339 963497464,17443,17547,17651,17755,17859,17963,18067,18171,65,132
1340 };
1341 mavlink_rc_channels_scaled_t packet1, packet2;
1342 memset(&packet1, 0, sizeof(packet1));
1343 packet1.time_boot_ms = packet_in.time_boot_ms;
1344 packet1.chan1_scaled = packet_in.chan1_scaled;
1345 packet1.chan2_scaled = packet_in.chan2_scaled;
1346 packet1.chan3_scaled = packet_in.chan3_scaled;
1347 packet1.chan4_scaled = packet_in.chan4_scaled;
1348 packet1.chan5_scaled = packet_in.chan5_scaled;
1349 packet1.chan6_scaled = packet_in.chan6_scaled;
1350 packet1.chan7_scaled = packet_in.chan7_scaled;
1351 packet1.chan8_scaled = packet_in.chan8_scaled;
1352 packet1.port = packet_in.port;
1353 packet1.rssi = packet_in.rssi;
1354
1355
1356#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1357 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1358 // cope with extensions
1359 memset(MAVLINK_MSG_ID_RC_CHANNELS_SCALED_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_RC_CHANNELS_SCALED_MIN_LEN);
1360 }
1361#endif
1362 memset(&packet2, 0, sizeof(packet2));
1363 mavlink_msg_rc_channels_scaled_encode(system_id, component_id, &msg, &packet1);
1364 mavlink_msg_rc_channels_scaled_decode(&msg, &packet2);
1365 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1366
1367 memset(&packet2, 0, sizeof(packet2));
1368 mavlink_msg_rc_channels_scaled_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.port , packet1.chan1_scaled , packet1.chan2_scaled , packet1.chan3_scaled , packet1.chan4_scaled , packet1.chan5_scaled , packet1.chan6_scaled , packet1.chan7_scaled , packet1.chan8_scaled , packet1.rssi );
1369 mavlink_msg_rc_channels_scaled_decode(&msg, &packet2);
1370 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1371
1372 memset(&packet2, 0, sizeof(packet2));
1373 mavlink_msg_rc_channels_scaled_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.port , packet1.chan1_scaled , packet1.chan2_scaled , packet1.chan3_scaled , packet1.chan4_scaled , packet1.chan5_scaled , packet1.chan6_scaled , packet1.chan7_scaled , packet1.chan8_scaled , packet1.rssi );
1374 mavlink_msg_rc_channels_scaled_decode(&msg, &packet2);
1375 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1376
1377 memset(&packet2, 0, sizeof(packet2));
1378 mavlink_msg_to_send_buffer(buffer, &msg);
1379 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1380 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1381 }
1382 mavlink_msg_rc_channels_scaled_decode(last_msg, &packet2);
1383 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1384
1385 memset(&packet2, 0, sizeof(packet2));
1386 mavlink_msg_rc_channels_scaled_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.port , packet1.chan1_scaled , packet1.chan2_scaled , packet1.chan3_scaled , packet1.chan4_scaled , packet1.chan5_scaled , packet1.chan6_scaled , packet1.chan7_scaled , packet1.chan8_scaled , packet1.rssi );
1387 mavlink_msg_rc_channels_scaled_decode(last_msg, &packet2);
1388 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1389}
1390
1391static void mavlink_test_rc_channels_raw(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1392{
1393#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1394 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1395 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_RC_CHANNELS_RAW >= 256) {
1396 return;
1397 }
1398#endif
1399 mavlink_message_t msg;
1400 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1401 uint16_t i;
1402 mavlink_rc_channels_raw_t packet_in = {
1403 963497464,17443,17547,17651,17755,17859,17963,18067,18171,65,132
1404 };
1405 mavlink_rc_channels_raw_t packet1, packet2;
1406 memset(&packet1, 0, sizeof(packet1));
1407 packet1.time_boot_ms = packet_in.time_boot_ms;
1408 packet1.chan1_raw = packet_in.chan1_raw;
1409 packet1.chan2_raw = packet_in.chan2_raw;
1410 packet1.chan3_raw = packet_in.chan3_raw;
1411 packet1.chan4_raw = packet_in.chan4_raw;
1412 packet1.chan5_raw = packet_in.chan5_raw;
1413 packet1.chan6_raw = packet_in.chan6_raw;
1414 packet1.chan7_raw = packet_in.chan7_raw;
1415 packet1.chan8_raw = packet_in.chan8_raw;
1416 packet1.port = packet_in.port;
1417 packet1.rssi = packet_in.rssi;
1418
1419
1420#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1421 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1422 // cope with extensions
1423 memset(MAVLINK_MSG_ID_RC_CHANNELS_RAW_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_RC_CHANNELS_RAW_MIN_LEN);
1424 }
1425#endif
1426 memset(&packet2, 0, sizeof(packet2));
1427 mavlink_msg_rc_channels_raw_encode(system_id, component_id, &msg, &packet1);
1428 mavlink_msg_rc_channels_raw_decode(&msg, &packet2);
1429 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1430
1431 memset(&packet2, 0, sizeof(packet2));
1432 mavlink_msg_rc_channels_raw_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.port , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw , packet1.rssi );
1433 mavlink_msg_rc_channels_raw_decode(&msg, &packet2);
1434 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1435
1436 memset(&packet2, 0, sizeof(packet2));
1437 mavlink_msg_rc_channels_raw_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.port , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw , packet1.rssi );
1438 mavlink_msg_rc_channels_raw_decode(&msg, &packet2);
1439 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1440
1441 memset(&packet2, 0, sizeof(packet2));
1442 mavlink_msg_to_send_buffer(buffer, &msg);
1443 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1444 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1445 }
1446 mavlink_msg_rc_channels_raw_decode(last_msg, &packet2);
1447 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1448
1449 memset(&packet2, 0, sizeof(packet2));
1450 mavlink_msg_rc_channels_raw_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.port , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw , packet1.rssi );
1451 mavlink_msg_rc_channels_raw_decode(last_msg, &packet2);
1452 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1453}
1454
1455static void mavlink_test_servo_output_raw(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1456{
1457#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1458 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1459 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SERVO_OUTPUT_RAW >= 256) {
1460 return;
1461 }
1462#endif
1463 mavlink_message_t msg;
1464 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1465 uint16_t i;
1466 mavlink_servo_output_raw_t packet_in = {
1467 963497464,17443,17547,17651,17755,17859,17963,18067,18171,65,18327,18431,18535,18639,18743,18847,18951,19055
1468 };
1469 mavlink_servo_output_raw_t packet1, packet2;
1470 memset(&packet1, 0, sizeof(packet1));
1471 packet1.time_usec = packet_in.time_usec;
1472 packet1.servo1_raw = packet_in.servo1_raw;
1473 packet1.servo2_raw = packet_in.servo2_raw;
1474 packet1.servo3_raw = packet_in.servo3_raw;
1475 packet1.servo4_raw = packet_in.servo4_raw;
1476 packet1.servo5_raw = packet_in.servo5_raw;
1477 packet1.servo6_raw = packet_in.servo6_raw;
1478 packet1.servo7_raw = packet_in.servo7_raw;
1479 packet1.servo8_raw = packet_in.servo8_raw;
1480 packet1.port = packet_in.port;
1481 packet1.servo9_raw = packet_in.servo9_raw;
1482 packet1.servo10_raw = packet_in.servo10_raw;
1483 packet1.servo11_raw = packet_in.servo11_raw;
1484 packet1.servo12_raw = packet_in.servo12_raw;
1485 packet1.servo13_raw = packet_in.servo13_raw;
1486 packet1.servo14_raw = packet_in.servo14_raw;
1487 packet1.servo15_raw = packet_in.servo15_raw;
1488 packet1.servo16_raw = packet_in.servo16_raw;
1489
1490
1491#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1492 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1493 // cope with extensions
1494 memset(MAVLINK_MSG_ID_SERVO_OUTPUT_RAW_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SERVO_OUTPUT_RAW_MIN_LEN);
1495 }
1496#endif
1497 memset(&packet2, 0, sizeof(packet2));
1498 mavlink_msg_servo_output_raw_encode(system_id, component_id, &msg, &packet1);
1499 mavlink_msg_servo_output_raw_decode(&msg, &packet2);
1500 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1501
1502 memset(&packet2, 0, sizeof(packet2));
1503 mavlink_msg_servo_output_raw_pack(system_id, component_id, &msg , packet1.time_usec , packet1.port , packet1.servo1_raw , packet1.servo2_raw , packet1.servo3_raw , packet1.servo4_raw , packet1.servo5_raw , packet1.servo6_raw , packet1.servo7_raw , packet1.servo8_raw , packet1.servo9_raw , packet1.servo10_raw , packet1.servo11_raw , packet1.servo12_raw , packet1.servo13_raw , packet1.servo14_raw , packet1.servo15_raw , packet1.servo16_raw );
1504 mavlink_msg_servo_output_raw_decode(&msg, &packet2);
1505 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1506
1507 memset(&packet2, 0, sizeof(packet2));
1508 mavlink_msg_servo_output_raw_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.port , packet1.servo1_raw , packet1.servo2_raw , packet1.servo3_raw , packet1.servo4_raw , packet1.servo5_raw , packet1.servo6_raw , packet1.servo7_raw , packet1.servo8_raw , packet1.servo9_raw , packet1.servo10_raw , packet1.servo11_raw , packet1.servo12_raw , packet1.servo13_raw , packet1.servo14_raw , packet1.servo15_raw , packet1.servo16_raw );
1509 mavlink_msg_servo_output_raw_decode(&msg, &packet2);
1510 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1511
1512 memset(&packet2, 0, sizeof(packet2));
1513 mavlink_msg_to_send_buffer(buffer, &msg);
1514 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1515 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1516 }
1517 mavlink_msg_servo_output_raw_decode(last_msg, &packet2);
1518 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1519
1520 memset(&packet2, 0, sizeof(packet2));
1521 mavlink_msg_servo_output_raw_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.port , packet1.servo1_raw , packet1.servo2_raw , packet1.servo3_raw , packet1.servo4_raw , packet1.servo5_raw , packet1.servo6_raw , packet1.servo7_raw , packet1.servo8_raw , packet1.servo9_raw , packet1.servo10_raw , packet1.servo11_raw , packet1.servo12_raw , packet1.servo13_raw , packet1.servo14_raw , packet1.servo15_raw , packet1.servo16_raw );
1522 mavlink_msg_servo_output_raw_decode(last_msg, &packet2);
1523 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1524}
1525
1526static void mavlink_test_mission_request_partial_list(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1527{
1528#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1529 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1530 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_REQUEST_PARTIAL_LIST >= 256) {
1531 return;
1532 }
1533#endif
1534 mavlink_message_t msg;
1535 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1536 uint16_t i;
1537 mavlink_mission_request_partial_list_t packet_in = {
1538 17235,17339,17,84,151
1539 };
1540 mavlink_mission_request_partial_list_t packet1, packet2;
1541 memset(&packet1, 0, sizeof(packet1));
1542 packet1.start_index = packet_in.start_index;
1543 packet1.end_index = packet_in.end_index;
1544 packet1.target_system = packet_in.target_system;
1545 packet1.target_component = packet_in.target_component;
1546 packet1.mission_type = packet_in.mission_type;
1547
1548
1549#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1550 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1551 // cope with extensions
1552 memset(MAVLINK_MSG_ID_MISSION_REQUEST_PARTIAL_LIST_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_REQUEST_PARTIAL_LIST_MIN_LEN);
1553 }
1554#endif
1555 memset(&packet2, 0, sizeof(packet2));
1556 mavlink_msg_mission_request_partial_list_encode(system_id, component_id, &msg, &packet1);
1557 mavlink_msg_mission_request_partial_list_decode(&msg, &packet2);
1558 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1559
1560 memset(&packet2, 0, sizeof(packet2));
1561 mavlink_msg_mission_request_partial_list_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.start_index , packet1.end_index , packet1.mission_type );
1562 mavlink_msg_mission_request_partial_list_decode(&msg, &packet2);
1563 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1564
1565 memset(&packet2, 0, sizeof(packet2));
1566 mavlink_msg_mission_request_partial_list_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.start_index , packet1.end_index , packet1.mission_type );
1567 mavlink_msg_mission_request_partial_list_decode(&msg, &packet2);
1568 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1569
1570 memset(&packet2, 0, sizeof(packet2));
1571 mavlink_msg_to_send_buffer(buffer, &msg);
1572 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1573 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1574 }
1575 mavlink_msg_mission_request_partial_list_decode(last_msg, &packet2);
1576 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1577
1578 memset(&packet2, 0, sizeof(packet2));
1579 mavlink_msg_mission_request_partial_list_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.start_index , packet1.end_index , packet1.mission_type );
1580 mavlink_msg_mission_request_partial_list_decode(last_msg, &packet2);
1581 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1582}
1583
1584static void mavlink_test_mission_write_partial_list(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1585{
1586#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1587 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1588 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_WRITE_PARTIAL_LIST >= 256) {
1589 return;
1590 }
1591#endif
1592 mavlink_message_t msg;
1593 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1594 uint16_t i;
1595 mavlink_mission_write_partial_list_t packet_in = {
1596 17235,17339,17,84,151
1597 };
1598 mavlink_mission_write_partial_list_t packet1, packet2;
1599 memset(&packet1, 0, sizeof(packet1));
1600 packet1.start_index = packet_in.start_index;
1601 packet1.end_index = packet_in.end_index;
1602 packet1.target_system = packet_in.target_system;
1603 packet1.target_component = packet_in.target_component;
1604 packet1.mission_type = packet_in.mission_type;
1605
1606
1607#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1608 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1609 // cope with extensions
1610 memset(MAVLINK_MSG_ID_MISSION_WRITE_PARTIAL_LIST_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_WRITE_PARTIAL_LIST_MIN_LEN);
1611 }
1612#endif
1613 memset(&packet2, 0, sizeof(packet2));
1614 mavlink_msg_mission_write_partial_list_encode(system_id, component_id, &msg, &packet1);
1615 mavlink_msg_mission_write_partial_list_decode(&msg, &packet2);
1616 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1617
1618 memset(&packet2, 0, sizeof(packet2));
1619 mavlink_msg_mission_write_partial_list_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.start_index , packet1.end_index , packet1.mission_type );
1620 mavlink_msg_mission_write_partial_list_decode(&msg, &packet2);
1621 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1622
1623 memset(&packet2, 0, sizeof(packet2));
1624 mavlink_msg_mission_write_partial_list_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.start_index , packet1.end_index , packet1.mission_type );
1625 mavlink_msg_mission_write_partial_list_decode(&msg, &packet2);
1626 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1627
1628 memset(&packet2, 0, sizeof(packet2));
1629 mavlink_msg_to_send_buffer(buffer, &msg);
1630 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1631 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1632 }
1633 mavlink_msg_mission_write_partial_list_decode(last_msg, &packet2);
1634 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1635
1636 memset(&packet2, 0, sizeof(packet2));
1637 mavlink_msg_mission_write_partial_list_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.start_index , packet1.end_index , packet1.mission_type );
1638 mavlink_msg_mission_write_partial_list_decode(last_msg, &packet2);
1639 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1640}
1641
1642static void mavlink_test_mission_item(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1643{
1644#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1645 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1646 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_ITEM >= 256) {
1647 return;
1648 }
1649#endif
1650 mavlink_message_t msg;
1651 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1652 uint16_t i;
1653 mavlink_mission_item_t packet_in = {
1654 17.0,45.0,73.0,101.0,129.0,157.0,185.0,18691,18795,101,168,235,46,113,180
1655 };
1656 mavlink_mission_item_t packet1, packet2;
1657 memset(&packet1, 0, sizeof(packet1));
1658 packet1.param1 = packet_in.param1;
1659 packet1.param2 = packet_in.param2;
1660 packet1.param3 = packet_in.param3;
1661 packet1.param4 = packet_in.param4;
1662 packet1.x = packet_in.x;
1663 packet1.y = packet_in.y;
1664 packet1.z = packet_in.z;
1665 packet1.seq = packet_in.seq;
1666 packet1.command = packet_in.command;
1667 packet1.target_system = packet_in.target_system;
1668 packet1.target_component = packet_in.target_component;
1669 packet1.frame = packet_in.frame;
1670 packet1.current = packet_in.current;
1671 packet1.autocontinue = packet_in.autocontinue;
1672 packet1.mission_type = packet_in.mission_type;
1673
1674
1675#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1676 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1677 // cope with extensions
1678 memset(MAVLINK_MSG_ID_MISSION_ITEM_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_ITEM_MIN_LEN);
1679 }
1680#endif
1681 memset(&packet2, 0, sizeof(packet2));
1682 mavlink_msg_mission_item_encode(system_id, component_id, &msg, &packet1);
1683 mavlink_msg_mission_item_decode(&msg, &packet2);
1684 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1685
1686 memset(&packet2, 0, sizeof(packet2));
1687 mavlink_msg_mission_item_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.seq , packet1.frame , packet1.command , packet1.current , packet1.autocontinue , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.x , packet1.y , packet1.z , packet1.mission_type );
1688 mavlink_msg_mission_item_decode(&msg, &packet2);
1689 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1690
1691 memset(&packet2, 0, sizeof(packet2));
1692 mavlink_msg_mission_item_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.seq , packet1.frame , packet1.command , packet1.current , packet1.autocontinue , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.x , packet1.y , packet1.z , packet1.mission_type );
1693 mavlink_msg_mission_item_decode(&msg, &packet2);
1694 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1695
1696 memset(&packet2, 0, sizeof(packet2));
1697 mavlink_msg_to_send_buffer(buffer, &msg);
1698 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1699 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1700 }
1701 mavlink_msg_mission_item_decode(last_msg, &packet2);
1702 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1703
1704 memset(&packet2, 0, sizeof(packet2));
1705 mavlink_msg_mission_item_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.seq , packet1.frame , packet1.command , packet1.current , packet1.autocontinue , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.x , packet1.y , packet1.z , packet1.mission_type );
1706 mavlink_msg_mission_item_decode(last_msg, &packet2);
1707 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1708}
1709
1710static void mavlink_test_mission_request(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1711{
1712#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1713 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1714 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_REQUEST >= 256) {
1715 return;
1716 }
1717#endif
1718 mavlink_message_t msg;
1719 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1720 uint16_t i;
1721 mavlink_mission_request_t packet_in = {
1722 17235,139,206,17
1723 };
1724 mavlink_mission_request_t packet1, packet2;
1725 memset(&packet1, 0, sizeof(packet1));
1726 packet1.seq = packet_in.seq;
1727 packet1.target_system = packet_in.target_system;
1728 packet1.target_component = packet_in.target_component;
1729 packet1.mission_type = packet_in.mission_type;
1730
1731
1732#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1733 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1734 // cope with extensions
1735 memset(MAVLINK_MSG_ID_MISSION_REQUEST_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_REQUEST_MIN_LEN);
1736 }
1737#endif
1738 memset(&packet2, 0, sizeof(packet2));
1739 mavlink_msg_mission_request_encode(system_id, component_id, &msg, &packet1);
1740 mavlink_msg_mission_request_decode(&msg, &packet2);
1741 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1742
1743 memset(&packet2, 0, sizeof(packet2));
1744 mavlink_msg_mission_request_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.seq , packet1.mission_type );
1745 mavlink_msg_mission_request_decode(&msg, &packet2);
1746 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1747
1748 memset(&packet2, 0, sizeof(packet2));
1749 mavlink_msg_mission_request_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.seq , packet1.mission_type );
1750 mavlink_msg_mission_request_decode(&msg, &packet2);
1751 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1752
1753 memset(&packet2, 0, sizeof(packet2));
1754 mavlink_msg_to_send_buffer(buffer, &msg);
1755 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1756 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1757 }
1758 mavlink_msg_mission_request_decode(last_msg, &packet2);
1759 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1760
1761 memset(&packet2, 0, sizeof(packet2));
1762 mavlink_msg_mission_request_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.seq , packet1.mission_type );
1763 mavlink_msg_mission_request_decode(last_msg, &packet2);
1764 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1765}
1766
1767static void mavlink_test_mission_set_current(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1768{
1769#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1770 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1771 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_SET_CURRENT >= 256) {
1772 return;
1773 }
1774#endif
1775 mavlink_message_t msg;
1776 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1777 uint16_t i;
1778 mavlink_mission_set_current_t packet_in = {
1779 17235,139,206
1780 };
1781 mavlink_mission_set_current_t packet1, packet2;
1782 memset(&packet1, 0, sizeof(packet1));
1783 packet1.seq = packet_in.seq;
1784 packet1.target_system = packet_in.target_system;
1785 packet1.target_component = packet_in.target_component;
1786
1787
1788#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1789 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1790 // cope with extensions
1791 memset(MAVLINK_MSG_ID_MISSION_SET_CURRENT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_SET_CURRENT_MIN_LEN);
1792 }
1793#endif
1794 memset(&packet2, 0, sizeof(packet2));
1795 mavlink_msg_mission_set_current_encode(system_id, component_id, &msg, &packet1);
1796 mavlink_msg_mission_set_current_decode(&msg, &packet2);
1797 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1798
1799 memset(&packet2, 0, sizeof(packet2));
1800 mavlink_msg_mission_set_current_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.seq );
1801 mavlink_msg_mission_set_current_decode(&msg, &packet2);
1802 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1803
1804 memset(&packet2, 0, sizeof(packet2));
1805 mavlink_msg_mission_set_current_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.seq );
1806 mavlink_msg_mission_set_current_decode(&msg, &packet2);
1807 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1808
1809 memset(&packet2, 0, sizeof(packet2));
1810 mavlink_msg_to_send_buffer(buffer, &msg);
1811 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1812 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1813 }
1814 mavlink_msg_mission_set_current_decode(last_msg, &packet2);
1815 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1816
1817 memset(&packet2, 0, sizeof(packet2));
1818 mavlink_msg_mission_set_current_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.seq );
1819 mavlink_msg_mission_set_current_decode(last_msg, &packet2);
1820 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1821}
1822
1823static void mavlink_test_mission_current(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1824{
1825#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1826 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1827 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_CURRENT >= 256) {
1828 return;
1829 }
1830#endif
1831 mavlink_message_t msg;
1832 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1833 uint16_t i;
1834 mavlink_mission_current_t packet_in = {
1835 17235
1836 };
1837 mavlink_mission_current_t packet1, packet2;
1838 memset(&packet1, 0, sizeof(packet1));
1839 packet1.seq = packet_in.seq;
1840
1841
1842#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1843 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1844 // cope with extensions
1845 memset(MAVLINK_MSG_ID_MISSION_CURRENT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_CURRENT_MIN_LEN);
1846 }
1847#endif
1848 memset(&packet2, 0, sizeof(packet2));
1849 mavlink_msg_mission_current_encode(system_id, component_id, &msg, &packet1);
1850 mavlink_msg_mission_current_decode(&msg, &packet2);
1851 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1852
1853 memset(&packet2, 0, sizeof(packet2));
1854 mavlink_msg_mission_current_pack(system_id, component_id, &msg , packet1.seq );
1855 mavlink_msg_mission_current_decode(&msg, &packet2);
1856 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1857
1858 memset(&packet2, 0, sizeof(packet2));
1859 mavlink_msg_mission_current_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.seq );
1860 mavlink_msg_mission_current_decode(&msg, &packet2);
1861 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1862
1863 memset(&packet2, 0, sizeof(packet2));
1864 mavlink_msg_to_send_buffer(buffer, &msg);
1865 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1866 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1867 }
1868 mavlink_msg_mission_current_decode(last_msg, &packet2);
1869 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1870
1871 memset(&packet2, 0, sizeof(packet2));
1872 mavlink_msg_mission_current_send(MAVLINK_COMM_1 , packet1.seq );
1873 mavlink_msg_mission_current_decode(last_msg, &packet2);
1874 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1875}
1876
1877static void mavlink_test_mission_request_list(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1878{
1879#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1880 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1881 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_REQUEST_LIST >= 256) {
1882 return;
1883 }
1884#endif
1885 mavlink_message_t msg;
1886 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1887 uint16_t i;
1888 mavlink_mission_request_list_t packet_in = {
1889 5,72,139
1890 };
1891 mavlink_mission_request_list_t packet1, packet2;
1892 memset(&packet1, 0, sizeof(packet1));
1893 packet1.target_system = packet_in.target_system;
1894 packet1.target_component = packet_in.target_component;
1895 packet1.mission_type = packet_in.mission_type;
1896
1897
1898#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1899 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1900 // cope with extensions
1901 memset(MAVLINK_MSG_ID_MISSION_REQUEST_LIST_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_REQUEST_LIST_MIN_LEN);
1902 }
1903#endif
1904 memset(&packet2, 0, sizeof(packet2));
1905 mavlink_msg_mission_request_list_encode(system_id, component_id, &msg, &packet1);
1906 mavlink_msg_mission_request_list_decode(&msg, &packet2);
1907 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1908
1909 memset(&packet2, 0, sizeof(packet2));
1910 mavlink_msg_mission_request_list_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.mission_type );
1911 mavlink_msg_mission_request_list_decode(&msg, &packet2);
1912 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1913
1914 memset(&packet2, 0, sizeof(packet2));
1915 mavlink_msg_mission_request_list_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.mission_type );
1916 mavlink_msg_mission_request_list_decode(&msg, &packet2);
1917 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1918
1919 memset(&packet2, 0, sizeof(packet2));
1920 mavlink_msg_to_send_buffer(buffer, &msg);
1921 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1922 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1923 }
1924 mavlink_msg_mission_request_list_decode(last_msg, &packet2);
1925 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1926
1927 memset(&packet2, 0, sizeof(packet2));
1928 mavlink_msg_mission_request_list_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.mission_type );
1929 mavlink_msg_mission_request_list_decode(last_msg, &packet2);
1930 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1931}
1932
1933static void mavlink_test_mission_count(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1934{
1935#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1936 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1937 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_COUNT >= 256) {
1938 return;
1939 }
1940#endif
1941 mavlink_message_t msg;
1942 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1943 uint16_t i;
1944 mavlink_mission_count_t packet_in = {
1945 17235,139,206,17
1946 };
1947 mavlink_mission_count_t packet1, packet2;
1948 memset(&packet1, 0, sizeof(packet1));
1949 packet1.count = packet_in.count;
1950 packet1.target_system = packet_in.target_system;
1951 packet1.target_component = packet_in.target_component;
1952 packet1.mission_type = packet_in.mission_type;
1953
1954
1955#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1956 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1957 // cope with extensions
1958 memset(MAVLINK_MSG_ID_MISSION_COUNT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_COUNT_MIN_LEN);
1959 }
1960#endif
1961 memset(&packet2, 0, sizeof(packet2));
1962 mavlink_msg_mission_count_encode(system_id, component_id, &msg, &packet1);
1963 mavlink_msg_mission_count_decode(&msg, &packet2);
1964 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1965
1966 memset(&packet2, 0, sizeof(packet2));
1967 mavlink_msg_mission_count_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.count , packet1.mission_type );
1968 mavlink_msg_mission_count_decode(&msg, &packet2);
1969 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1970
1971 memset(&packet2, 0, sizeof(packet2));
1972 mavlink_msg_mission_count_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.count , packet1.mission_type );
1973 mavlink_msg_mission_count_decode(&msg, &packet2);
1974 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1975
1976 memset(&packet2, 0, sizeof(packet2));
1977 mavlink_msg_to_send_buffer(buffer, &msg);
1978 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1979 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1980 }
1981 mavlink_msg_mission_count_decode(last_msg, &packet2);
1982 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1983
1984 memset(&packet2, 0, sizeof(packet2));
1985 mavlink_msg_mission_count_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.count , packet1.mission_type );
1986 mavlink_msg_mission_count_decode(last_msg, &packet2);
1987 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1988}
1989
1990static void mavlink_test_mission_clear_all(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1991{
1992#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1993 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1994 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_CLEAR_ALL >= 256) {
1995 return;
1996 }
1997#endif
1998 mavlink_message_t msg;
1999 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2000 uint16_t i;
2001 mavlink_mission_clear_all_t packet_in = {
2002 5,72,139
2003 };
2004 mavlink_mission_clear_all_t packet1, packet2;
2005 memset(&packet1, 0, sizeof(packet1));
2006 packet1.target_system = packet_in.target_system;
2007 packet1.target_component = packet_in.target_component;
2008 packet1.mission_type = packet_in.mission_type;
2009
2010
2011#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2012 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2013 // cope with extensions
2014 memset(MAVLINK_MSG_ID_MISSION_CLEAR_ALL_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_CLEAR_ALL_MIN_LEN);
2015 }
2016#endif
2017 memset(&packet2, 0, sizeof(packet2));
2018 mavlink_msg_mission_clear_all_encode(system_id, component_id, &msg, &packet1);
2019 mavlink_msg_mission_clear_all_decode(&msg, &packet2);
2020 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2021
2022 memset(&packet2, 0, sizeof(packet2));
2023 mavlink_msg_mission_clear_all_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.mission_type );
2024 mavlink_msg_mission_clear_all_decode(&msg, &packet2);
2025 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2026
2027 memset(&packet2, 0, sizeof(packet2));
2028 mavlink_msg_mission_clear_all_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.mission_type );
2029 mavlink_msg_mission_clear_all_decode(&msg, &packet2);
2030 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2031
2032 memset(&packet2, 0, sizeof(packet2));
2033 mavlink_msg_to_send_buffer(buffer, &msg);
2034 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2035 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2036 }
2037 mavlink_msg_mission_clear_all_decode(last_msg, &packet2);
2038 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2039
2040 memset(&packet2, 0, sizeof(packet2));
2041 mavlink_msg_mission_clear_all_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.mission_type );
2042 mavlink_msg_mission_clear_all_decode(last_msg, &packet2);
2043 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2044}
2045
2046static void mavlink_test_mission_item_reached(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2047{
2048#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2049 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2050 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_ITEM_REACHED >= 256) {
2051 return;
2052 }
2053#endif
2054 mavlink_message_t msg;
2055 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2056 uint16_t i;
2057 mavlink_mission_item_reached_t packet_in = {
2058 17235
2059 };
2060 mavlink_mission_item_reached_t packet1, packet2;
2061 memset(&packet1, 0, sizeof(packet1));
2062 packet1.seq = packet_in.seq;
2063
2064
2065#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2066 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2067 // cope with extensions
2068 memset(MAVLINK_MSG_ID_MISSION_ITEM_REACHED_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_ITEM_REACHED_MIN_LEN);
2069 }
2070#endif
2071 memset(&packet2, 0, sizeof(packet2));
2072 mavlink_msg_mission_item_reached_encode(system_id, component_id, &msg, &packet1);
2073 mavlink_msg_mission_item_reached_decode(&msg, &packet2);
2074 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2075
2076 memset(&packet2, 0, sizeof(packet2));
2077 mavlink_msg_mission_item_reached_pack(system_id, component_id, &msg , packet1.seq );
2078 mavlink_msg_mission_item_reached_decode(&msg, &packet2);
2079 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2080
2081 memset(&packet2, 0, sizeof(packet2));
2082 mavlink_msg_mission_item_reached_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.seq );
2083 mavlink_msg_mission_item_reached_decode(&msg, &packet2);
2084 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2085
2086 memset(&packet2, 0, sizeof(packet2));
2087 mavlink_msg_to_send_buffer(buffer, &msg);
2088 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2089 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2090 }
2091 mavlink_msg_mission_item_reached_decode(last_msg, &packet2);
2092 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2093
2094 memset(&packet2, 0, sizeof(packet2));
2095 mavlink_msg_mission_item_reached_send(MAVLINK_COMM_1 , packet1.seq );
2096 mavlink_msg_mission_item_reached_decode(last_msg, &packet2);
2097 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2098}
2099
2100static void mavlink_test_mission_ack(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2101{
2102#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2103 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2104 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_ACK >= 256) {
2105 return;
2106 }
2107#endif
2108 mavlink_message_t msg;
2109 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2110 uint16_t i;
2111 mavlink_mission_ack_t packet_in = {
2112 5,72,139,206
2113 };
2114 mavlink_mission_ack_t packet1, packet2;
2115 memset(&packet1, 0, sizeof(packet1));
2116 packet1.target_system = packet_in.target_system;
2117 packet1.target_component = packet_in.target_component;
2118 packet1.type = packet_in.type;
2119 packet1.mission_type = packet_in.mission_type;
2120
2121
2122#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2123 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2124 // cope with extensions
2125 memset(MAVLINK_MSG_ID_MISSION_ACK_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_ACK_MIN_LEN);
2126 }
2127#endif
2128 memset(&packet2, 0, sizeof(packet2));
2129 mavlink_msg_mission_ack_encode(system_id, component_id, &msg, &packet1);
2130 mavlink_msg_mission_ack_decode(&msg, &packet2);
2131 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2132
2133 memset(&packet2, 0, sizeof(packet2));
2134 mavlink_msg_mission_ack_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.type , packet1.mission_type );
2135 mavlink_msg_mission_ack_decode(&msg, &packet2);
2136 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2137
2138 memset(&packet2, 0, sizeof(packet2));
2139 mavlink_msg_mission_ack_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.type , packet1.mission_type );
2140 mavlink_msg_mission_ack_decode(&msg, &packet2);
2141 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2142
2143 memset(&packet2, 0, sizeof(packet2));
2144 mavlink_msg_to_send_buffer(buffer, &msg);
2145 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2146 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2147 }
2148 mavlink_msg_mission_ack_decode(last_msg, &packet2);
2149 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2150
2151 memset(&packet2, 0, sizeof(packet2));
2152 mavlink_msg_mission_ack_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.type , packet1.mission_type );
2153 mavlink_msg_mission_ack_decode(last_msg, &packet2);
2154 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2155}
2156
2157static void mavlink_test_set_gps_global_origin(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2158{
2159#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2160 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2161 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SET_GPS_GLOBAL_ORIGIN >= 256) {
2162 return;
2163 }
2164#endif
2165 mavlink_message_t msg;
2166 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2167 uint16_t i;
2168 mavlink_set_gps_global_origin_t packet_in = {
2169 963497464,963497672,963497880,41,93372036854776626ULL
2170 };
2171 mavlink_set_gps_global_origin_t packet1, packet2;
2172 memset(&packet1, 0, sizeof(packet1));
2173 packet1.latitude = packet_in.latitude;
2174 packet1.longitude = packet_in.longitude;
2175 packet1.altitude = packet_in.altitude;
2176 packet1.target_system = packet_in.target_system;
2177 packet1.time_usec = packet_in.time_usec;
2178
2179
2180#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2181 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2182 // cope with extensions
2183 memset(MAVLINK_MSG_ID_SET_GPS_GLOBAL_ORIGIN_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SET_GPS_GLOBAL_ORIGIN_MIN_LEN);
2184 }
2185#endif
2186 memset(&packet2, 0, sizeof(packet2));
2187 mavlink_msg_set_gps_global_origin_encode(system_id, component_id, &msg, &packet1);
2188 mavlink_msg_set_gps_global_origin_decode(&msg, &packet2);
2189 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2190
2191 memset(&packet2, 0, sizeof(packet2));
2192 mavlink_msg_set_gps_global_origin_pack(system_id, component_id, &msg , packet1.target_system , packet1.latitude , packet1.longitude , packet1.altitude , packet1.time_usec );
2193 mavlink_msg_set_gps_global_origin_decode(&msg, &packet2);
2194 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2195
2196 memset(&packet2, 0, sizeof(packet2));
2197 mavlink_msg_set_gps_global_origin_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.latitude , packet1.longitude , packet1.altitude , packet1.time_usec );
2198 mavlink_msg_set_gps_global_origin_decode(&msg, &packet2);
2199 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2200
2201 memset(&packet2, 0, sizeof(packet2));
2202 mavlink_msg_to_send_buffer(buffer, &msg);
2203 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2204 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2205 }
2206 mavlink_msg_set_gps_global_origin_decode(last_msg, &packet2);
2207 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2208
2209 memset(&packet2, 0, sizeof(packet2));
2210 mavlink_msg_set_gps_global_origin_send(MAVLINK_COMM_1 , packet1.target_system , packet1.latitude , packet1.longitude , packet1.altitude , packet1.time_usec );
2211 mavlink_msg_set_gps_global_origin_decode(last_msg, &packet2);
2212 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2213}
2214
2215static void mavlink_test_gps_global_origin(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2216{
2217#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2218 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2219 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GPS_GLOBAL_ORIGIN >= 256) {
2220 return;
2221 }
2222#endif
2223 mavlink_message_t msg;
2224 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2225 uint16_t i;
2226 mavlink_gps_global_origin_t packet_in = {
2227 963497464,963497672,963497880,93372036854776563ULL
2228 };
2229 mavlink_gps_global_origin_t packet1, packet2;
2230 memset(&packet1, 0, sizeof(packet1));
2231 packet1.latitude = packet_in.latitude;
2232 packet1.longitude = packet_in.longitude;
2233 packet1.altitude = packet_in.altitude;
2234 packet1.time_usec = packet_in.time_usec;
2235
2236
2237#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2238 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2239 // cope with extensions
2240 memset(MAVLINK_MSG_ID_GPS_GLOBAL_ORIGIN_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GPS_GLOBAL_ORIGIN_MIN_LEN);
2241 }
2242#endif
2243 memset(&packet2, 0, sizeof(packet2));
2244 mavlink_msg_gps_global_origin_encode(system_id, component_id, &msg, &packet1);
2245 mavlink_msg_gps_global_origin_decode(&msg, &packet2);
2246 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2247
2248 memset(&packet2, 0, sizeof(packet2));
2249 mavlink_msg_gps_global_origin_pack(system_id, component_id, &msg , packet1.latitude , packet1.longitude , packet1.altitude , packet1.time_usec );
2250 mavlink_msg_gps_global_origin_decode(&msg, &packet2);
2251 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2252
2253 memset(&packet2, 0, sizeof(packet2));
2254 mavlink_msg_gps_global_origin_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.latitude , packet1.longitude , packet1.altitude , packet1.time_usec );
2255 mavlink_msg_gps_global_origin_decode(&msg, &packet2);
2256 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2257
2258 memset(&packet2, 0, sizeof(packet2));
2259 mavlink_msg_to_send_buffer(buffer, &msg);
2260 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2261 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2262 }
2263 mavlink_msg_gps_global_origin_decode(last_msg, &packet2);
2264 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2265
2266 memset(&packet2, 0, sizeof(packet2));
2267 mavlink_msg_gps_global_origin_send(MAVLINK_COMM_1 , packet1.latitude , packet1.longitude , packet1.altitude , packet1.time_usec );
2268 mavlink_msg_gps_global_origin_decode(last_msg, &packet2);
2269 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2270}
2271
2272static void mavlink_test_param_map_rc(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2273{
2274#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2275 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2276 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PARAM_MAP_RC >= 256) {
2277 return;
2278 }
2279#endif
2280 mavlink_message_t msg;
2281 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2282 uint16_t i;
2283 mavlink_param_map_rc_t packet_in = {
2284 17.0,45.0,73.0,101.0,18067,187,254,"UVWXYZABCDEFGHI",113
2285 };
2286 mavlink_param_map_rc_t packet1, packet2;
2287 memset(&packet1, 0, sizeof(packet1));
2288 packet1.param_value0 = packet_in.param_value0;
2289 packet1.scale = packet_in.scale;
2290 packet1.param_value_min = packet_in.param_value_min;
2291 packet1.param_value_max = packet_in.param_value_max;
2292 packet1.param_index = packet_in.param_index;
2293 packet1.target_system = packet_in.target_system;
2294 packet1.target_component = packet_in.target_component;
2295 packet1.parameter_rc_channel_index = packet_in.parameter_rc_channel_index;
2296
2297 mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(char)*16);
2298
2299#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2300 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2301 // cope with extensions
2302 memset(MAVLINK_MSG_ID_PARAM_MAP_RC_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PARAM_MAP_RC_MIN_LEN);
2303 }
2304#endif
2305 memset(&packet2, 0, sizeof(packet2));
2306 mavlink_msg_param_map_rc_encode(system_id, component_id, &msg, &packet1);
2307 mavlink_msg_param_map_rc_decode(&msg, &packet2);
2308 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2309
2310 memset(&packet2, 0, sizeof(packet2));
2311 mavlink_msg_param_map_rc_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index , packet1.parameter_rc_channel_index , packet1.param_value0 , packet1.scale , packet1.param_value_min , packet1.param_value_max );
2312 mavlink_msg_param_map_rc_decode(&msg, &packet2);
2313 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2314
2315 memset(&packet2, 0, sizeof(packet2));
2316 mavlink_msg_param_map_rc_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index , packet1.parameter_rc_channel_index , packet1.param_value0 , packet1.scale , packet1.param_value_min , packet1.param_value_max );
2317 mavlink_msg_param_map_rc_decode(&msg, &packet2);
2318 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2319
2320 memset(&packet2, 0, sizeof(packet2));
2321 mavlink_msg_to_send_buffer(buffer, &msg);
2322 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2323 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2324 }
2325 mavlink_msg_param_map_rc_decode(last_msg, &packet2);
2326 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2327
2328 memset(&packet2, 0, sizeof(packet2));
2329 mavlink_msg_param_map_rc_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index , packet1.parameter_rc_channel_index , packet1.param_value0 , packet1.scale , packet1.param_value_min , packet1.param_value_max );
2330 mavlink_msg_param_map_rc_decode(last_msg, &packet2);
2331 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2332}
2333
2334static void mavlink_test_mission_request_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2335{
2336#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2337 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2338 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_REQUEST_INT >= 256) {
2339 return;
2340 }
2341#endif
2342 mavlink_message_t msg;
2343 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2344 uint16_t i;
2345 mavlink_mission_request_int_t packet_in = {
2346 17235,139,206,17
2347 };
2348 mavlink_mission_request_int_t packet1, packet2;
2349 memset(&packet1, 0, sizeof(packet1));
2350 packet1.seq = packet_in.seq;
2351 packet1.target_system = packet_in.target_system;
2352 packet1.target_component = packet_in.target_component;
2353 packet1.mission_type = packet_in.mission_type;
2354
2355
2356#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2357 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2358 // cope with extensions
2359 memset(MAVLINK_MSG_ID_MISSION_REQUEST_INT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_REQUEST_INT_MIN_LEN);
2360 }
2361#endif
2362 memset(&packet2, 0, sizeof(packet2));
2363 mavlink_msg_mission_request_int_encode(system_id, component_id, &msg, &packet1);
2364 mavlink_msg_mission_request_int_decode(&msg, &packet2);
2365 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2366
2367 memset(&packet2, 0, sizeof(packet2));
2368 mavlink_msg_mission_request_int_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.seq , packet1.mission_type );
2369 mavlink_msg_mission_request_int_decode(&msg, &packet2);
2370 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2371
2372 memset(&packet2, 0, sizeof(packet2));
2373 mavlink_msg_mission_request_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.seq , packet1.mission_type );
2374 mavlink_msg_mission_request_int_decode(&msg, &packet2);
2375 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2376
2377 memset(&packet2, 0, sizeof(packet2));
2378 mavlink_msg_to_send_buffer(buffer, &msg);
2379 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2380 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2381 }
2382 mavlink_msg_mission_request_int_decode(last_msg, &packet2);
2383 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2384
2385 memset(&packet2, 0, sizeof(packet2));
2386 mavlink_msg_mission_request_int_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.seq , packet1.mission_type );
2387 mavlink_msg_mission_request_int_decode(last_msg, &packet2);
2388 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2389}
2390
2391static void mavlink_test_safety_set_allowed_area(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2392{
2393#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2394 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2395 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA >= 256) {
2396 return;
2397 }
2398#endif
2399 mavlink_message_t msg;
2400 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2401 uint16_t i;
2402 mavlink_safety_set_allowed_area_t packet_in = {
2403 17.0,45.0,73.0,101.0,129.0,157.0,77,144,211
2404 };
2405 mavlink_safety_set_allowed_area_t packet1, packet2;
2406 memset(&packet1, 0, sizeof(packet1));
2407 packet1.p1x = packet_in.p1x;
2408 packet1.p1y = packet_in.p1y;
2409 packet1.p1z = packet_in.p1z;
2410 packet1.p2x = packet_in.p2x;
2411 packet1.p2y = packet_in.p2y;
2412 packet1.p2z = packet_in.p2z;
2413 packet1.target_system = packet_in.target_system;
2414 packet1.target_component = packet_in.target_component;
2415 packet1.frame = packet_in.frame;
2416
2417
2418#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2419 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2420 // cope with extensions
2421 memset(MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA_MIN_LEN);
2422 }
2423#endif
2424 memset(&packet2, 0, sizeof(packet2));
2425 mavlink_msg_safety_set_allowed_area_encode(system_id, component_id, &msg, &packet1);
2426 mavlink_msg_safety_set_allowed_area_decode(&msg, &packet2);
2427 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2428
2429 memset(&packet2, 0, sizeof(packet2));
2430 mavlink_msg_safety_set_allowed_area_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.frame , packet1.p1x , packet1.p1y , packet1.p1z , packet1.p2x , packet1.p2y , packet1.p2z );
2431 mavlink_msg_safety_set_allowed_area_decode(&msg, &packet2);
2432 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2433
2434 memset(&packet2, 0, sizeof(packet2));
2435 mavlink_msg_safety_set_allowed_area_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.frame , packet1.p1x , packet1.p1y , packet1.p1z , packet1.p2x , packet1.p2y , packet1.p2z );
2436 mavlink_msg_safety_set_allowed_area_decode(&msg, &packet2);
2437 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2438
2439 memset(&packet2, 0, sizeof(packet2));
2440 mavlink_msg_to_send_buffer(buffer, &msg);
2441 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2442 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2443 }
2444 mavlink_msg_safety_set_allowed_area_decode(last_msg, &packet2);
2445 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2446
2447 memset(&packet2, 0, sizeof(packet2));
2448 mavlink_msg_safety_set_allowed_area_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.frame , packet1.p1x , packet1.p1y , packet1.p1z , packet1.p2x , packet1.p2y , packet1.p2z );
2449 mavlink_msg_safety_set_allowed_area_decode(last_msg, &packet2);
2450 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2451}
2452
2453static void mavlink_test_safety_allowed_area(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2454{
2455#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2456 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2457 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA >= 256) {
2458 return;
2459 }
2460#endif
2461 mavlink_message_t msg;
2462 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2463 uint16_t i;
2464 mavlink_safety_allowed_area_t packet_in = {
2465 17.0,45.0,73.0,101.0,129.0,157.0,77
2466 };
2467 mavlink_safety_allowed_area_t packet1, packet2;
2468 memset(&packet1, 0, sizeof(packet1));
2469 packet1.p1x = packet_in.p1x;
2470 packet1.p1y = packet_in.p1y;
2471 packet1.p1z = packet_in.p1z;
2472 packet1.p2x = packet_in.p2x;
2473 packet1.p2y = packet_in.p2y;
2474 packet1.p2z = packet_in.p2z;
2475 packet1.frame = packet_in.frame;
2476
2477
2478#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2479 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2480 // cope with extensions
2481 memset(MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SAFETY_ALLOWED_AREA_MIN_LEN);
2482 }
2483#endif
2484 memset(&packet2, 0, sizeof(packet2));
2485 mavlink_msg_safety_allowed_area_encode(system_id, component_id, &msg, &packet1);
2486 mavlink_msg_safety_allowed_area_decode(&msg, &packet2);
2487 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2488
2489 memset(&packet2, 0, sizeof(packet2));
2490 mavlink_msg_safety_allowed_area_pack(system_id, component_id, &msg , packet1.frame , packet1.p1x , packet1.p1y , packet1.p1z , packet1.p2x , packet1.p2y , packet1.p2z );
2491 mavlink_msg_safety_allowed_area_decode(&msg, &packet2);
2492 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2493
2494 memset(&packet2, 0, sizeof(packet2));
2495 mavlink_msg_safety_allowed_area_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.frame , packet1.p1x , packet1.p1y , packet1.p1z , packet1.p2x , packet1.p2y , packet1.p2z );
2496 mavlink_msg_safety_allowed_area_decode(&msg, &packet2);
2497 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2498
2499 memset(&packet2, 0, sizeof(packet2));
2500 mavlink_msg_to_send_buffer(buffer, &msg);
2501 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2502 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2503 }
2504 mavlink_msg_safety_allowed_area_decode(last_msg, &packet2);
2505 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2506
2507 memset(&packet2, 0, sizeof(packet2));
2508 mavlink_msg_safety_allowed_area_send(MAVLINK_COMM_1 , packet1.frame , packet1.p1x , packet1.p1y , packet1.p1z , packet1.p2x , packet1.p2y , packet1.p2z );
2509 mavlink_msg_safety_allowed_area_decode(last_msg, &packet2);
2510 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2511}
2512
2513static void mavlink_test_attitude_quaternion_cov(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2514{
2515#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2516 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2517 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV >= 256) {
2518 return;
2519 }
2520#endif
2521 mavlink_message_t msg;
2522 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2523 uint16_t i;
2524 mavlink_attitude_quaternion_cov_t packet_in = {
2525 93372036854775807ULL,{ 73.0, 74.0, 75.0, 76.0 },185.0,213.0,241.0,{ 269.0, 270.0, 271.0, 272.0, 273.0, 274.0, 275.0, 276.0, 277.0 }
2526 };
2527 mavlink_attitude_quaternion_cov_t packet1, packet2;
2528 memset(&packet1, 0, sizeof(packet1));
2529 packet1.time_usec = packet_in.time_usec;
2530 packet1.rollspeed = packet_in.rollspeed;
2531 packet1.pitchspeed = packet_in.pitchspeed;
2532 packet1.yawspeed = packet_in.yawspeed;
2533
2534 mav_array_memcpy(packet1.q, packet_in.q, sizeof(float)*4);
2535 mav_array_memcpy(packet1.covariance, packet_in.covariance, sizeof(float)*9);
2536
2537#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2538 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2539 // cope with extensions
2540 memset(MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ATTITUDE_QUATERNION_COV_MIN_LEN);
2541 }
2542#endif
2543 memset(&packet2, 0, sizeof(packet2));
2544 mavlink_msg_attitude_quaternion_cov_encode(system_id, component_id, &msg, &packet1);
2545 mavlink_msg_attitude_quaternion_cov_decode(&msg, &packet2);
2546 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2547
2548 memset(&packet2, 0, sizeof(packet2));
2549 mavlink_msg_attitude_quaternion_cov_pack(system_id, component_id, &msg , packet1.time_usec , packet1.q , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed , packet1.covariance );
2550 mavlink_msg_attitude_quaternion_cov_decode(&msg, &packet2);
2551 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2552
2553 memset(&packet2, 0, sizeof(packet2));
2554 mavlink_msg_attitude_quaternion_cov_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.q , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed , packet1.covariance );
2555 mavlink_msg_attitude_quaternion_cov_decode(&msg, &packet2);
2556 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2557
2558 memset(&packet2, 0, sizeof(packet2));
2559 mavlink_msg_to_send_buffer(buffer, &msg);
2560 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2561 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2562 }
2563 mavlink_msg_attitude_quaternion_cov_decode(last_msg, &packet2);
2564 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2565
2566 memset(&packet2, 0, sizeof(packet2));
2567 mavlink_msg_attitude_quaternion_cov_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.q , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed , packet1.covariance );
2568 mavlink_msg_attitude_quaternion_cov_decode(last_msg, &packet2);
2569 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2570}
2571
2572static void mavlink_test_nav_controller_output(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2573{
2574#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2575 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2576 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT >= 256) {
2577 return;
2578 }
2579#endif
2580 mavlink_message_t msg;
2581 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2582 uint16_t i;
2583 mavlink_nav_controller_output_t packet_in = {
2584 17.0,45.0,73.0,101.0,129.0,18275,18379,18483
2585 };
2586 mavlink_nav_controller_output_t packet1, packet2;
2587 memset(&packet1, 0, sizeof(packet1));
2588 packet1.nav_roll = packet_in.nav_roll;
2589 packet1.nav_pitch = packet_in.nav_pitch;
2590 packet1.alt_error = packet_in.alt_error;
2591 packet1.aspd_error = packet_in.aspd_error;
2592 packet1.xtrack_error = packet_in.xtrack_error;
2593 packet1.nav_bearing = packet_in.nav_bearing;
2594 packet1.target_bearing = packet_in.target_bearing;
2595 packet1.wp_dist = packet_in.wp_dist;
2596
2597
2598#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2599 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2600 // cope with extensions
2601 memset(MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_NAV_CONTROLLER_OUTPUT_MIN_LEN);
2602 }
2603#endif
2604 memset(&packet2, 0, sizeof(packet2));
2605 mavlink_msg_nav_controller_output_encode(system_id, component_id, &msg, &packet1);
2606 mavlink_msg_nav_controller_output_decode(&msg, &packet2);
2607 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2608
2609 memset(&packet2, 0, sizeof(packet2));
2610 mavlink_msg_nav_controller_output_pack(system_id, component_id, &msg , packet1.nav_roll , packet1.nav_pitch , packet1.nav_bearing , packet1.target_bearing , packet1.wp_dist , packet1.alt_error , packet1.aspd_error , packet1.xtrack_error );
2611 mavlink_msg_nav_controller_output_decode(&msg, &packet2);
2612 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2613
2614 memset(&packet2, 0, sizeof(packet2));
2615 mavlink_msg_nav_controller_output_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.nav_roll , packet1.nav_pitch , packet1.nav_bearing , packet1.target_bearing , packet1.wp_dist , packet1.alt_error , packet1.aspd_error , packet1.xtrack_error );
2616 mavlink_msg_nav_controller_output_decode(&msg, &packet2);
2617 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2618
2619 memset(&packet2, 0, sizeof(packet2));
2620 mavlink_msg_to_send_buffer(buffer, &msg);
2621 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2622 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2623 }
2624 mavlink_msg_nav_controller_output_decode(last_msg, &packet2);
2625 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2626
2627 memset(&packet2, 0, sizeof(packet2));
2628 mavlink_msg_nav_controller_output_send(MAVLINK_COMM_1 , packet1.nav_roll , packet1.nav_pitch , packet1.nav_bearing , packet1.target_bearing , packet1.wp_dist , packet1.alt_error , packet1.aspd_error , packet1.xtrack_error );
2629 mavlink_msg_nav_controller_output_decode(last_msg, &packet2);
2630 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2631}
2632
2633static void mavlink_test_global_position_int_cov(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2634{
2635#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2636 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2637 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV >= 256) {
2638 return;
2639 }
2640#endif
2641 mavlink_message_t msg;
2642 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2643 uint16_t i;
2644 mavlink_global_position_int_cov_t packet_in = {
2645 93372036854775807ULL,963497880,963498088,963498296,963498504,185.0,213.0,241.0,{ 269.0, 270.0, 271.0, 272.0, 273.0, 274.0, 275.0, 276.0, 277.0, 278.0, 279.0, 280.0, 281.0, 282.0, 283.0, 284.0, 285.0, 286.0, 287.0, 288.0, 289.0, 290.0, 291.0, 292.0, 293.0, 294.0, 295.0, 296.0, 297.0, 298.0, 299.0, 300.0, 301.0, 302.0, 303.0, 304.0 },33
2646 };
2647 mavlink_global_position_int_cov_t packet1, packet2;
2648 memset(&packet1, 0, sizeof(packet1));
2649 packet1.time_usec = packet_in.time_usec;
2650 packet1.lat = packet_in.lat;
2651 packet1.lon = packet_in.lon;
2652 packet1.alt = packet_in.alt;
2653 packet1.relative_alt = packet_in.relative_alt;
2654 packet1.vx = packet_in.vx;
2655 packet1.vy = packet_in.vy;
2656 packet1.vz = packet_in.vz;
2657 packet1.estimator_type = packet_in.estimator_type;
2658
2659 mav_array_memcpy(packet1.covariance, packet_in.covariance, sizeof(float)*36);
2660
2661#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2662 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2663 // cope with extensions
2664 memset(MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GLOBAL_POSITION_INT_COV_MIN_LEN);
2665 }
2666#endif
2667 memset(&packet2, 0, sizeof(packet2));
2668 mavlink_msg_global_position_int_cov_encode(system_id, component_id, &msg, &packet1);
2669 mavlink_msg_global_position_int_cov_decode(&msg, &packet2);
2670 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2671
2672 memset(&packet2, 0, sizeof(packet2));
2673 mavlink_msg_global_position_int_cov_pack(system_id, component_id, &msg , packet1.time_usec , packet1.estimator_type , packet1.lat , packet1.lon , packet1.alt , packet1.relative_alt , packet1.vx , packet1.vy , packet1.vz , packet1.covariance );
2674 mavlink_msg_global_position_int_cov_decode(&msg, &packet2);
2675 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2676
2677 memset(&packet2, 0, sizeof(packet2));
2678 mavlink_msg_global_position_int_cov_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.estimator_type , packet1.lat , packet1.lon , packet1.alt , packet1.relative_alt , packet1.vx , packet1.vy , packet1.vz , packet1.covariance );
2679 mavlink_msg_global_position_int_cov_decode(&msg, &packet2);
2680 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2681
2682 memset(&packet2, 0, sizeof(packet2));
2683 mavlink_msg_to_send_buffer(buffer, &msg);
2684 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2685 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2686 }
2687 mavlink_msg_global_position_int_cov_decode(last_msg, &packet2);
2688 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2689
2690 memset(&packet2, 0, sizeof(packet2));
2691 mavlink_msg_global_position_int_cov_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.estimator_type , packet1.lat , packet1.lon , packet1.alt , packet1.relative_alt , packet1.vx , packet1.vy , packet1.vz , packet1.covariance );
2692 mavlink_msg_global_position_int_cov_decode(last_msg, &packet2);
2693 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2694}
2695
2696static void mavlink_test_local_position_ned_cov(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2697{
2698#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2699 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2700 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOCAL_POSITION_NED_COV >= 256) {
2701 return;
2702 }
2703#endif
2704 mavlink_message_t msg;
2705 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2706 uint16_t i;
2707 mavlink_local_position_ned_cov_t packet_in = {
2708 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,{ 325.0, 326.0, 327.0, 328.0, 329.0, 330.0, 331.0, 332.0, 333.0, 334.0, 335.0, 336.0, 337.0, 338.0, 339.0, 340.0, 341.0, 342.0, 343.0, 344.0, 345.0, 346.0, 347.0, 348.0, 349.0, 350.0, 351.0, 352.0, 353.0, 354.0, 355.0, 356.0, 357.0, 358.0, 359.0, 360.0, 361.0, 362.0, 363.0, 364.0, 365.0, 366.0, 367.0, 368.0, 369.0 },165
2709 };
2710 mavlink_local_position_ned_cov_t packet1, packet2;
2711 memset(&packet1, 0, sizeof(packet1));
2712 packet1.time_usec = packet_in.time_usec;
2713 packet1.x = packet_in.x;
2714 packet1.y = packet_in.y;
2715 packet1.z = packet_in.z;
2716 packet1.vx = packet_in.vx;
2717 packet1.vy = packet_in.vy;
2718 packet1.vz = packet_in.vz;
2719 packet1.ax = packet_in.ax;
2720 packet1.ay = packet_in.ay;
2721 packet1.az = packet_in.az;
2722 packet1.estimator_type = packet_in.estimator_type;
2723
2724 mav_array_memcpy(packet1.covariance, packet_in.covariance, sizeof(float)*45);
2725
2726#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2727 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2728 // cope with extensions
2729 memset(MAVLINK_MSG_ID_LOCAL_POSITION_NED_COV_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOCAL_POSITION_NED_COV_MIN_LEN);
2730 }
2731#endif
2732 memset(&packet2, 0, sizeof(packet2));
2733 mavlink_msg_local_position_ned_cov_encode(system_id, component_id, &msg, &packet1);
2734 mavlink_msg_local_position_ned_cov_decode(&msg, &packet2);
2735 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2736
2737 memset(&packet2, 0, sizeof(packet2));
2738 mavlink_msg_local_position_ned_cov_pack(system_id, component_id, &msg , packet1.time_usec , packet1.estimator_type , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz , packet1.ax , packet1.ay , packet1.az , packet1.covariance );
2739 mavlink_msg_local_position_ned_cov_decode(&msg, &packet2);
2740 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2741
2742 memset(&packet2, 0, sizeof(packet2));
2743 mavlink_msg_local_position_ned_cov_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.estimator_type , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz , packet1.ax , packet1.ay , packet1.az , packet1.covariance );
2744 mavlink_msg_local_position_ned_cov_decode(&msg, &packet2);
2745 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2746
2747 memset(&packet2, 0, sizeof(packet2));
2748 mavlink_msg_to_send_buffer(buffer, &msg);
2749 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2750 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2751 }
2752 mavlink_msg_local_position_ned_cov_decode(last_msg, &packet2);
2753 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2754
2755 memset(&packet2, 0, sizeof(packet2));
2756 mavlink_msg_local_position_ned_cov_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.estimator_type , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz , packet1.ax , packet1.ay , packet1.az , packet1.covariance );
2757 mavlink_msg_local_position_ned_cov_decode(last_msg, &packet2);
2758 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2759}
2760
2761static void mavlink_test_rc_channels(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2762{
2763#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2764 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2765 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_RC_CHANNELS >= 256) {
2766 return;
2767 }
2768#endif
2769 mavlink_message_t msg;
2770 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2771 uint16_t i;
2772 mavlink_rc_channels_t packet_in = {
2773 963497464,17443,17547,17651,17755,17859,17963,18067,18171,18275,18379,18483,18587,18691,18795,18899,19003,19107,19211,125,192
2774 };
2775 mavlink_rc_channels_t packet1, packet2;
2776 memset(&packet1, 0, sizeof(packet1));
2777 packet1.time_boot_ms = packet_in.time_boot_ms;
2778 packet1.chan1_raw = packet_in.chan1_raw;
2779 packet1.chan2_raw = packet_in.chan2_raw;
2780 packet1.chan3_raw = packet_in.chan3_raw;
2781 packet1.chan4_raw = packet_in.chan4_raw;
2782 packet1.chan5_raw = packet_in.chan5_raw;
2783 packet1.chan6_raw = packet_in.chan6_raw;
2784 packet1.chan7_raw = packet_in.chan7_raw;
2785 packet1.chan8_raw = packet_in.chan8_raw;
2786 packet1.chan9_raw = packet_in.chan9_raw;
2787 packet1.chan10_raw = packet_in.chan10_raw;
2788 packet1.chan11_raw = packet_in.chan11_raw;
2789 packet1.chan12_raw = packet_in.chan12_raw;
2790 packet1.chan13_raw = packet_in.chan13_raw;
2791 packet1.chan14_raw = packet_in.chan14_raw;
2792 packet1.chan15_raw = packet_in.chan15_raw;
2793 packet1.chan16_raw = packet_in.chan16_raw;
2794 packet1.chan17_raw = packet_in.chan17_raw;
2795 packet1.chan18_raw = packet_in.chan18_raw;
2796 packet1.chancount = packet_in.chancount;
2797 packet1.rssi = packet_in.rssi;
2798
2799
2800#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2801 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2802 // cope with extensions
2803 memset(MAVLINK_MSG_ID_RC_CHANNELS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_RC_CHANNELS_MIN_LEN);
2804 }
2805#endif
2806 memset(&packet2, 0, sizeof(packet2));
2807 mavlink_msg_rc_channels_encode(system_id, component_id, &msg, &packet1);
2808 mavlink_msg_rc_channels_decode(&msg, &packet2);
2809 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2810
2811 memset(&packet2, 0, sizeof(packet2));
2812 mavlink_msg_rc_channels_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.chancount , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw , packet1.chan9_raw , packet1.chan10_raw , packet1.chan11_raw , packet1.chan12_raw , packet1.chan13_raw , packet1.chan14_raw , packet1.chan15_raw , packet1.chan16_raw , packet1.chan17_raw , packet1.chan18_raw , packet1.rssi );
2813 mavlink_msg_rc_channels_decode(&msg, &packet2);
2814 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2815
2816 memset(&packet2, 0, sizeof(packet2));
2817 mavlink_msg_rc_channels_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.chancount , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw , packet1.chan9_raw , packet1.chan10_raw , packet1.chan11_raw , packet1.chan12_raw , packet1.chan13_raw , packet1.chan14_raw , packet1.chan15_raw , packet1.chan16_raw , packet1.chan17_raw , packet1.chan18_raw , packet1.rssi );
2818 mavlink_msg_rc_channels_decode(&msg, &packet2);
2819 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2820
2821 memset(&packet2, 0, sizeof(packet2));
2822 mavlink_msg_to_send_buffer(buffer, &msg);
2823 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2824 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2825 }
2826 mavlink_msg_rc_channels_decode(last_msg, &packet2);
2827 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2828
2829 memset(&packet2, 0, sizeof(packet2));
2830 mavlink_msg_rc_channels_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.chancount , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw , packet1.chan9_raw , packet1.chan10_raw , packet1.chan11_raw , packet1.chan12_raw , packet1.chan13_raw , packet1.chan14_raw , packet1.chan15_raw , packet1.chan16_raw , packet1.chan17_raw , packet1.chan18_raw , packet1.rssi );
2831 mavlink_msg_rc_channels_decode(last_msg, &packet2);
2832 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2833}
2834
2835static void mavlink_test_request_data_stream(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2836{
2837#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2838 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2839 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_REQUEST_DATA_STREAM >= 256) {
2840 return;
2841 }
2842#endif
2843 mavlink_message_t msg;
2844 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2845 uint16_t i;
2846 mavlink_request_data_stream_t packet_in = {
2847 17235,139,206,17,84
2848 };
2849 mavlink_request_data_stream_t packet1, packet2;
2850 memset(&packet1, 0, sizeof(packet1));
2851 packet1.req_message_rate = packet_in.req_message_rate;
2852 packet1.target_system = packet_in.target_system;
2853 packet1.target_component = packet_in.target_component;
2854 packet1.req_stream_id = packet_in.req_stream_id;
2855 packet1.start_stop = packet_in.start_stop;
2856
2857
2858#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2859 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2860 // cope with extensions
2861 memset(MAVLINK_MSG_ID_REQUEST_DATA_STREAM_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_REQUEST_DATA_STREAM_MIN_LEN);
2862 }
2863#endif
2864 memset(&packet2, 0, sizeof(packet2));
2865 mavlink_msg_request_data_stream_encode(system_id, component_id, &msg, &packet1);
2866 mavlink_msg_request_data_stream_decode(&msg, &packet2);
2867 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2868
2869 memset(&packet2, 0, sizeof(packet2));
2870 mavlink_msg_request_data_stream_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.req_stream_id , packet1.req_message_rate , packet1.start_stop );
2871 mavlink_msg_request_data_stream_decode(&msg, &packet2);
2872 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2873
2874 memset(&packet2, 0, sizeof(packet2));
2875 mavlink_msg_request_data_stream_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.req_stream_id , packet1.req_message_rate , packet1.start_stop );
2876 mavlink_msg_request_data_stream_decode(&msg, &packet2);
2877 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2878
2879 memset(&packet2, 0, sizeof(packet2));
2880 mavlink_msg_to_send_buffer(buffer, &msg);
2881 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2882 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2883 }
2884 mavlink_msg_request_data_stream_decode(last_msg, &packet2);
2885 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2886
2887 memset(&packet2, 0, sizeof(packet2));
2888 mavlink_msg_request_data_stream_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.req_stream_id , packet1.req_message_rate , packet1.start_stop );
2889 mavlink_msg_request_data_stream_decode(last_msg, &packet2);
2890 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2891}
2892
2893static void mavlink_test_data_stream(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2894{
2895#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2896 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2897 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_DATA_STREAM >= 256) {
2898 return;
2899 }
2900#endif
2901 mavlink_message_t msg;
2902 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2903 uint16_t i;
2904 mavlink_data_stream_t packet_in = {
2905 17235,139,206
2906 };
2907 mavlink_data_stream_t packet1, packet2;
2908 memset(&packet1, 0, sizeof(packet1));
2909 packet1.message_rate = packet_in.message_rate;
2910 packet1.stream_id = packet_in.stream_id;
2911 packet1.on_off = packet_in.on_off;
2912
2913
2914#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2915 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2916 // cope with extensions
2917 memset(MAVLINK_MSG_ID_DATA_STREAM_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_DATA_STREAM_MIN_LEN);
2918 }
2919#endif
2920 memset(&packet2, 0, sizeof(packet2));
2921 mavlink_msg_data_stream_encode(system_id, component_id, &msg, &packet1);
2922 mavlink_msg_data_stream_decode(&msg, &packet2);
2923 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2924
2925 memset(&packet2, 0, sizeof(packet2));
2926 mavlink_msg_data_stream_pack(system_id, component_id, &msg , packet1.stream_id , packet1.message_rate , packet1.on_off );
2927 mavlink_msg_data_stream_decode(&msg, &packet2);
2928 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2929
2930 memset(&packet2, 0, sizeof(packet2));
2931 mavlink_msg_data_stream_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.stream_id , packet1.message_rate , packet1.on_off );
2932 mavlink_msg_data_stream_decode(&msg, &packet2);
2933 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2934
2935 memset(&packet2, 0, sizeof(packet2));
2936 mavlink_msg_to_send_buffer(buffer, &msg);
2937 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2938 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2939 }
2940 mavlink_msg_data_stream_decode(last_msg, &packet2);
2941 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2942
2943 memset(&packet2, 0, sizeof(packet2));
2944 mavlink_msg_data_stream_send(MAVLINK_COMM_1 , packet1.stream_id , packet1.message_rate , packet1.on_off );
2945 mavlink_msg_data_stream_decode(last_msg, &packet2);
2946 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2947}
2948
2949static void mavlink_test_manual_control(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
2950{
2951#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2952 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
2953 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MANUAL_CONTROL >= 256) {
2954 return;
2955 }
2956#endif
2957 mavlink_message_t msg;
2958 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
2959 uint16_t i;
2960 mavlink_manual_control_t packet_in = {
2961 17235,17339,17443,17547,17651,163
2962 };
2963 mavlink_manual_control_t packet1, packet2;
2964 memset(&packet1, 0, sizeof(packet1));
2965 packet1.x = packet_in.x;
2966 packet1.y = packet_in.y;
2967 packet1.z = packet_in.z;
2968 packet1.r = packet_in.r;
2969 packet1.buttons = packet_in.buttons;
2970 packet1.target = packet_in.target;
2971
2972
2973#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
2974 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
2975 // cope with extensions
2976 memset(MAVLINK_MSG_ID_MANUAL_CONTROL_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MANUAL_CONTROL_MIN_LEN);
2977 }
2978#endif
2979 memset(&packet2, 0, sizeof(packet2));
2980 mavlink_msg_manual_control_encode(system_id, component_id, &msg, &packet1);
2981 mavlink_msg_manual_control_decode(&msg, &packet2);
2982 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2983
2984 memset(&packet2, 0, sizeof(packet2));
2985 mavlink_msg_manual_control_pack(system_id, component_id, &msg , packet1.target , packet1.x , packet1.y , packet1.z , packet1.r , packet1.buttons );
2986 mavlink_msg_manual_control_decode(&msg, &packet2);
2987 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2988
2989 memset(&packet2, 0, sizeof(packet2));
2990 mavlink_msg_manual_control_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.x , packet1.y , packet1.z , packet1.r , packet1.buttons );
2991 mavlink_msg_manual_control_decode(&msg, &packet2);
2992 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
2993
2994 memset(&packet2, 0, sizeof(packet2));
2995 mavlink_msg_to_send_buffer(buffer, &msg);
2996 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
2997 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
2998 }
2999 mavlink_msg_manual_control_decode(last_msg, &packet2);
3000 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3001
3002 memset(&packet2, 0, sizeof(packet2));
3003 mavlink_msg_manual_control_send(MAVLINK_COMM_1 , packet1.target , packet1.x , packet1.y , packet1.z , packet1.r , packet1.buttons );
3004 mavlink_msg_manual_control_decode(last_msg, &packet2);
3005 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3006}
3007
3008static void mavlink_test_rc_channels_override(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3009{
3010#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3011 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3012 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE >= 256) {
3013 return;
3014 }
3015#endif
3016 mavlink_message_t msg;
3017 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3018 uint16_t i;
3019 mavlink_rc_channels_override_t packet_in = {
3020 17235,17339,17443,17547,17651,17755,17859,17963,53,120
3021 };
3022 mavlink_rc_channels_override_t packet1, packet2;
3023 memset(&packet1, 0, sizeof(packet1));
3024 packet1.chan1_raw = packet_in.chan1_raw;
3025 packet1.chan2_raw = packet_in.chan2_raw;
3026 packet1.chan3_raw = packet_in.chan3_raw;
3027 packet1.chan4_raw = packet_in.chan4_raw;
3028 packet1.chan5_raw = packet_in.chan5_raw;
3029 packet1.chan6_raw = packet_in.chan6_raw;
3030 packet1.chan7_raw = packet_in.chan7_raw;
3031 packet1.chan8_raw = packet_in.chan8_raw;
3032 packet1.target_system = packet_in.target_system;
3033 packet1.target_component = packet_in.target_component;
3034
3035
3036#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3037 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3038 // cope with extensions
3039 memset(MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE_MIN_LEN);
3040 }
3041#endif
3042 memset(&packet2, 0, sizeof(packet2));
3043 mavlink_msg_rc_channels_override_encode(system_id, component_id, &msg, &packet1);
3044 mavlink_msg_rc_channels_override_decode(&msg, &packet2);
3045 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3046
3047 memset(&packet2, 0, sizeof(packet2));
3048 mavlink_msg_rc_channels_override_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw );
3049 mavlink_msg_rc_channels_override_decode(&msg, &packet2);
3050 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3051
3052 memset(&packet2, 0, sizeof(packet2));
3053 mavlink_msg_rc_channels_override_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw );
3054 mavlink_msg_rc_channels_override_decode(&msg, &packet2);
3055 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3056
3057 memset(&packet2, 0, sizeof(packet2));
3058 mavlink_msg_to_send_buffer(buffer, &msg);
3059 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3060 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3061 }
3062 mavlink_msg_rc_channels_override_decode(last_msg, &packet2);
3063 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3064
3065 memset(&packet2, 0, sizeof(packet2));
3066 mavlink_msg_rc_channels_override_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw );
3067 mavlink_msg_rc_channels_override_decode(last_msg, &packet2);
3068 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3069}
3070
3071static void mavlink_test_mission_item_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3072{
3073#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3074 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3075 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MISSION_ITEM_INT >= 256) {
3076 return;
3077 }
3078#endif
3079 mavlink_message_t msg;
3080 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3081 uint16_t i;
3082 mavlink_mission_item_int_t packet_in = {
3083 17.0,45.0,73.0,101.0,963498296,963498504,185.0,18691,18795,101,168,235,46,113,180
3084 };
3085 mavlink_mission_item_int_t packet1, packet2;
3086 memset(&packet1, 0, sizeof(packet1));
3087 packet1.param1 = packet_in.param1;
3088 packet1.param2 = packet_in.param2;
3089 packet1.param3 = packet_in.param3;
3090 packet1.param4 = packet_in.param4;
3091 packet1.x = packet_in.x;
3092 packet1.y = packet_in.y;
3093 packet1.z = packet_in.z;
3094 packet1.seq = packet_in.seq;
3095 packet1.command = packet_in.command;
3096 packet1.target_system = packet_in.target_system;
3097 packet1.target_component = packet_in.target_component;
3098 packet1.frame = packet_in.frame;
3099 packet1.current = packet_in.current;
3100 packet1.autocontinue = packet_in.autocontinue;
3101 packet1.mission_type = packet_in.mission_type;
3102
3103
3104#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3105 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3106 // cope with extensions
3107 memset(MAVLINK_MSG_ID_MISSION_ITEM_INT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MISSION_ITEM_INT_MIN_LEN);
3108 }
3109#endif
3110 memset(&packet2, 0, sizeof(packet2));
3111 mavlink_msg_mission_item_int_encode(system_id, component_id, &msg, &packet1);
3112 mavlink_msg_mission_item_int_decode(&msg, &packet2);
3113 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3114
3115 memset(&packet2, 0, sizeof(packet2));
3116 mavlink_msg_mission_item_int_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.seq , packet1.frame , packet1.command , packet1.current , packet1.autocontinue , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.x , packet1.y , packet1.z , packet1.mission_type );
3117 mavlink_msg_mission_item_int_decode(&msg, &packet2);
3118 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3119
3120 memset(&packet2, 0, sizeof(packet2));
3121 mavlink_msg_mission_item_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.seq , packet1.frame , packet1.command , packet1.current , packet1.autocontinue , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.x , packet1.y , packet1.z , packet1.mission_type );
3122 mavlink_msg_mission_item_int_decode(&msg, &packet2);
3123 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3124
3125 memset(&packet2, 0, sizeof(packet2));
3126 mavlink_msg_to_send_buffer(buffer, &msg);
3127 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3128 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3129 }
3130 mavlink_msg_mission_item_int_decode(last_msg, &packet2);
3131 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3132
3133 memset(&packet2, 0, sizeof(packet2));
3134 mavlink_msg_mission_item_int_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.seq , packet1.frame , packet1.command , packet1.current , packet1.autocontinue , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.x , packet1.y , packet1.z , packet1.mission_type );
3135 mavlink_msg_mission_item_int_decode(last_msg, &packet2);
3136 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3137}
3138
3139static void mavlink_test_vfr_hud(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3140{
3141#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3142 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3143 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_VFR_HUD >= 256) {
3144 return;
3145 }
3146#endif
3147 mavlink_message_t msg;
3148 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3149 uint16_t i;
3150 mavlink_vfr_hud_t packet_in = {
3151 17.0,45.0,73.0,101.0,18067,18171
3152 };
3153 mavlink_vfr_hud_t packet1, packet2;
3154 memset(&packet1, 0, sizeof(packet1));
3155 packet1.airspeed = packet_in.airspeed;
3156 packet1.groundspeed = packet_in.groundspeed;
3157 packet1.alt = packet_in.alt;
3158 packet1.climb = packet_in.climb;
3159 packet1.heading = packet_in.heading;
3160 packet1.throttle = packet_in.throttle;
3161
3162
3163#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3164 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3165 // cope with extensions
3166 memset(MAVLINK_MSG_ID_VFR_HUD_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_VFR_HUD_MIN_LEN);
3167 }
3168#endif
3169 memset(&packet2, 0, sizeof(packet2));
3170 mavlink_msg_vfr_hud_encode(system_id, component_id, &msg, &packet1);
3171 mavlink_msg_vfr_hud_decode(&msg, &packet2);
3172 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3173
3174 memset(&packet2, 0, sizeof(packet2));
3175 mavlink_msg_vfr_hud_pack(system_id, component_id, &msg , packet1.airspeed , packet1.groundspeed , packet1.heading , packet1.throttle , packet1.alt , packet1.climb );
3176 mavlink_msg_vfr_hud_decode(&msg, &packet2);
3177 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3178
3179 memset(&packet2, 0, sizeof(packet2));
3180 mavlink_msg_vfr_hud_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.airspeed , packet1.groundspeed , packet1.heading , packet1.throttle , packet1.alt , packet1.climb );
3181 mavlink_msg_vfr_hud_decode(&msg, &packet2);
3182 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3183
3184 memset(&packet2, 0, sizeof(packet2));
3185 mavlink_msg_to_send_buffer(buffer, &msg);
3186 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3187 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3188 }
3189 mavlink_msg_vfr_hud_decode(last_msg, &packet2);
3190 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3191
3192 memset(&packet2, 0, sizeof(packet2));
3193 mavlink_msg_vfr_hud_send(MAVLINK_COMM_1 , packet1.airspeed , packet1.groundspeed , packet1.heading , packet1.throttle , packet1.alt , packet1.climb );
3194 mavlink_msg_vfr_hud_decode(last_msg, &packet2);
3195 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3196}
3197
3198static void mavlink_test_command_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3199{
3200#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3201 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3202 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_COMMAND_INT >= 256) {
3203 return;
3204 }
3205#endif
3206 mavlink_message_t msg;
3207 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3208 uint16_t i;
3209 mavlink_command_int_t packet_in = {
3210 17.0,45.0,73.0,101.0,963498296,963498504,185.0,18691,223,34,101,168,235
3211 };
3212 mavlink_command_int_t packet1, packet2;
3213 memset(&packet1, 0, sizeof(packet1));
3214 packet1.param1 = packet_in.param1;
3215 packet1.param2 = packet_in.param2;
3216 packet1.param3 = packet_in.param3;
3217 packet1.param4 = packet_in.param4;
3218 packet1.x = packet_in.x;
3219 packet1.y = packet_in.y;
3220 packet1.z = packet_in.z;
3221 packet1.command = packet_in.command;
3222 packet1.target_system = packet_in.target_system;
3223 packet1.target_component = packet_in.target_component;
3224 packet1.frame = packet_in.frame;
3225 packet1.current = packet_in.current;
3226 packet1.autocontinue = packet_in.autocontinue;
3227
3228
3229#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3230 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3231 // cope with extensions
3232 memset(MAVLINK_MSG_ID_COMMAND_INT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_COMMAND_INT_MIN_LEN);
3233 }
3234#endif
3235 memset(&packet2, 0, sizeof(packet2));
3236 mavlink_msg_command_int_encode(system_id, component_id, &msg, &packet1);
3237 mavlink_msg_command_int_decode(&msg, &packet2);
3238 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3239
3240 memset(&packet2, 0, sizeof(packet2));
3241 mavlink_msg_command_int_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.frame , packet1.command , packet1.current , packet1.autocontinue , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.x , packet1.y , packet1.z );
3242 mavlink_msg_command_int_decode(&msg, &packet2);
3243 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3244
3245 memset(&packet2, 0, sizeof(packet2));
3246 mavlink_msg_command_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.frame , packet1.command , packet1.current , packet1.autocontinue , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.x , packet1.y , packet1.z );
3247 mavlink_msg_command_int_decode(&msg, &packet2);
3248 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3249
3250 memset(&packet2, 0, sizeof(packet2));
3251 mavlink_msg_to_send_buffer(buffer, &msg);
3252 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3253 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3254 }
3255 mavlink_msg_command_int_decode(last_msg, &packet2);
3256 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3257
3258 memset(&packet2, 0, sizeof(packet2));
3259 mavlink_msg_command_int_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.frame , packet1.command , packet1.current , packet1.autocontinue , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.x , packet1.y , packet1.z );
3260 mavlink_msg_command_int_decode(last_msg, &packet2);
3261 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3262}
3263
3264static void mavlink_test_command_long(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3265{
3266#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3267 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3268 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_COMMAND_LONG >= 256) {
3269 return;
3270 }
3271#endif
3272 mavlink_message_t msg;
3273 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3274 uint16_t i;
3275 mavlink_command_long_t packet_in = {
3276 17.0,45.0,73.0,101.0,129.0,157.0,185.0,18691,223,34,101
3277 };
3278 mavlink_command_long_t packet1, packet2;
3279 memset(&packet1, 0, sizeof(packet1));
3280 packet1.param1 = packet_in.param1;
3281 packet1.param2 = packet_in.param2;
3282 packet1.param3 = packet_in.param3;
3283 packet1.param4 = packet_in.param4;
3284 packet1.param5 = packet_in.param5;
3285 packet1.param6 = packet_in.param6;
3286 packet1.param7 = packet_in.param7;
3287 packet1.command = packet_in.command;
3288 packet1.target_system = packet_in.target_system;
3289 packet1.target_component = packet_in.target_component;
3290 packet1.confirmation = packet_in.confirmation;
3291
3292
3293#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3294 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3295 // cope with extensions
3296 memset(MAVLINK_MSG_ID_COMMAND_LONG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_COMMAND_LONG_MIN_LEN);
3297 }
3298#endif
3299 memset(&packet2, 0, sizeof(packet2));
3300 mavlink_msg_command_long_encode(system_id, component_id, &msg, &packet1);
3301 mavlink_msg_command_long_decode(&msg, &packet2);
3302 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3303
3304 memset(&packet2, 0, sizeof(packet2));
3305 mavlink_msg_command_long_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.command , packet1.confirmation , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.param5 , packet1.param6 , packet1.param7 );
3306 mavlink_msg_command_long_decode(&msg, &packet2);
3307 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3308
3309 memset(&packet2, 0, sizeof(packet2));
3310 mavlink_msg_command_long_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.command , packet1.confirmation , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.param5 , packet1.param6 , packet1.param7 );
3311 mavlink_msg_command_long_decode(&msg, &packet2);
3312 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3313
3314 memset(&packet2, 0, sizeof(packet2));
3315 mavlink_msg_to_send_buffer(buffer, &msg);
3316 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3317 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3318 }
3319 mavlink_msg_command_long_decode(last_msg, &packet2);
3320 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3321
3322 memset(&packet2, 0, sizeof(packet2));
3323 mavlink_msg_command_long_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.command , packet1.confirmation , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 , packet1.param5 , packet1.param6 , packet1.param7 );
3324 mavlink_msg_command_long_decode(last_msg, &packet2);
3325 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3326}
3327
3328static void mavlink_test_command_ack(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3329{
3330#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3331 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3332 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_COMMAND_ACK >= 256) {
3333 return;
3334 }
3335#endif
3336 mavlink_message_t msg;
3337 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3338 uint16_t i;
3339 mavlink_command_ack_t packet_in = {
3340 17235,139,206,963497672,29,96
3341 };
3342 mavlink_command_ack_t packet1, packet2;
3343 memset(&packet1, 0, sizeof(packet1));
3344 packet1.command = packet_in.command;
3345 packet1.result = packet_in.result;
3346 packet1.progress = packet_in.progress;
3347 packet1.result_param2 = packet_in.result_param2;
3348 packet1.target_system = packet_in.target_system;
3349 packet1.target_component = packet_in.target_component;
3350
3351
3352#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3353 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3354 // cope with extensions
3355 memset(MAVLINK_MSG_ID_COMMAND_ACK_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_COMMAND_ACK_MIN_LEN);
3356 }
3357#endif
3358 memset(&packet2, 0, sizeof(packet2));
3359 mavlink_msg_command_ack_encode(system_id, component_id, &msg, &packet1);
3360 mavlink_msg_command_ack_decode(&msg, &packet2);
3361 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3362
3363 memset(&packet2, 0, sizeof(packet2));
3364 mavlink_msg_command_ack_pack(system_id, component_id, &msg , packet1.command , packet1.result , packet1.progress , packet1.result_param2 , packet1.target_system , packet1.target_component );
3365 mavlink_msg_command_ack_decode(&msg, &packet2);
3366 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3367
3368 memset(&packet2, 0, sizeof(packet2));
3369 mavlink_msg_command_ack_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.command , packet1.result , packet1.progress , packet1.result_param2 , packet1.target_system , packet1.target_component );
3370 mavlink_msg_command_ack_decode(&msg, &packet2);
3371 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3372
3373 memset(&packet2, 0, sizeof(packet2));
3374 mavlink_msg_to_send_buffer(buffer, &msg);
3375 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3376 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3377 }
3378 mavlink_msg_command_ack_decode(last_msg, &packet2);
3379 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3380
3381 memset(&packet2, 0, sizeof(packet2));
3382 mavlink_msg_command_ack_send(MAVLINK_COMM_1 , packet1.command , packet1.result , packet1.progress , packet1.result_param2 , packet1.target_system , packet1.target_component );
3383 mavlink_msg_command_ack_decode(last_msg, &packet2);
3384 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3385}
3386
3387static void mavlink_test_manual_setpoint(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3388{
3389#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3390 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3391 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MANUAL_SETPOINT >= 256) {
3392 return;
3393 }
3394#endif
3395 mavlink_message_t msg;
3396 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3397 uint16_t i;
3398 mavlink_manual_setpoint_t packet_in = {
3399 963497464,45.0,73.0,101.0,129.0,65,132
3400 };
3401 mavlink_manual_setpoint_t packet1, packet2;
3402 memset(&packet1, 0, sizeof(packet1));
3403 packet1.time_boot_ms = packet_in.time_boot_ms;
3404 packet1.roll = packet_in.roll;
3405 packet1.pitch = packet_in.pitch;
3406 packet1.yaw = packet_in.yaw;
3407 packet1.thrust = packet_in.thrust;
3408 packet1.mode_switch = packet_in.mode_switch;
3409 packet1.manual_override_switch = packet_in.manual_override_switch;
3410
3411
3412#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3413 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3414 // cope with extensions
3415 memset(MAVLINK_MSG_ID_MANUAL_SETPOINT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MANUAL_SETPOINT_MIN_LEN);
3416 }
3417#endif
3418 memset(&packet2, 0, sizeof(packet2));
3419 mavlink_msg_manual_setpoint_encode(system_id, component_id, &msg, &packet1);
3420 mavlink_msg_manual_setpoint_decode(&msg, &packet2);
3421 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3422
3423 memset(&packet2, 0, sizeof(packet2));
3424 mavlink_msg_manual_setpoint_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust , packet1.mode_switch , packet1.manual_override_switch );
3425 mavlink_msg_manual_setpoint_decode(&msg, &packet2);
3426 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3427
3428 memset(&packet2, 0, sizeof(packet2));
3429 mavlink_msg_manual_setpoint_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust , packet1.mode_switch , packet1.manual_override_switch );
3430 mavlink_msg_manual_setpoint_decode(&msg, &packet2);
3431 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3432
3433 memset(&packet2, 0, sizeof(packet2));
3434 mavlink_msg_to_send_buffer(buffer, &msg);
3435 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3436 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3437 }
3438 mavlink_msg_manual_setpoint_decode(last_msg, &packet2);
3439 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3440
3441 memset(&packet2, 0, sizeof(packet2));
3442 mavlink_msg_manual_setpoint_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust , packet1.mode_switch , packet1.manual_override_switch );
3443 mavlink_msg_manual_setpoint_decode(last_msg, &packet2);
3444 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3445}
3446
3447static void mavlink_test_set_attitude_target(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3448{
3449#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3450 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3451 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SET_ATTITUDE_TARGET >= 256) {
3452 return;
3453 }
3454#endif
3455 mavlink_message_t msg;
3456 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3457 uint16_t i;
3458 mavlink_set_attitude_target_t packet_in = {
3459 963497464,{ 45.0, 46.0, 47.0, 48.0 },157.0,185.0,213.0,241.0,113,180,247
3460 };
3461 mavlink_set_attitude_target_t packet1, packet2;
3462 memset(&packet1, 0, sizeof(packet1));
3463 packet1.time_boot_ms = packet_in.time_boot_ms;
3464 packet1.body_roll_rate = packet_in.body_roll_rate;
3465 packet1.body_pitch_rate = packet_in.body_pitch_rate;
3466 packet1.body_yaw_rate = packet_in.body_yaw_rate;
3467 packet1.thrust = packet_in.thrust;
3468 packet1.target_system = packet_in.target_system;
3469 packet1.target_component = packet_in.target_component;
3470 packet1.type_mask = packet_in.type_mask;
3471
3472 mav_array_memcpy(packet1.q, packet_in.q, sizeof(float)*4);
3473
3474#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3475 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3476 // cope with extensions
3477 memset(MAVLINK_MSG_ID_SET_ATTITUDE_TARGET_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SET_ATTITUDE_TARGET_MIN_LEN);
3478 }
3479#endif
3480 memset(&packet2, 0, sizeof(packet2));
3481 mavlink_msg_set_attitude_target_encode(system_id, component_id, &msg, &packet1);
3482 mavlink_msg_set_attitude_target_decode(&msg, &packet2);
3483 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3484
3485 memset(&packet2, 0, sizeof(packet2));
3486 mavlink_msg_set_attitude_target_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.target_system , packet1.target_component , packet1.type_mask , packet1.q , packet1.body_roll_rate , packet1.body_pitch_rate , packet1.body_yaw_rate , packet1.thrust );
3487 mavlink_msg_set_attitude_target_decode(&msg, &packet2);
3488 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3489
3490 memset(&packet2, 0, sizeof(packet2));
3491 mavlink_msg_set_attitude_target_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.target_system , packet1.target_component , packet1.type_mask , packet1.q , packet1.body_roll_rate , packet1.body_pitch_rate , packet1.body_yaw_rate , packet1.thrust );
3492 mavlink_msg_set_attitude_target_decode(&msg, &packet2);
3493 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3494
3495 memset(&packet2, 0, sizeof(packet2));
3496 mavlink_msg_to_send_buffer(buffer, &msg);
3497 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3498 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3499 }
3500 mavlink_msg_set_attitude_target_decode(last_msg, &packet2);
3501 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3502
3503 memset(&packet2, 0, sizeof(packet2));
3504 mavlink_msg_set_attitude_target_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.target_system , packet1.target_component , packet1.type_mask , packet1.q , packet1.body_roll_rate , packet1.body_pitch_rate , packet1.body_yaw_rate , packet1.thrust );
3505 mavlink_msg_set_attitude_target_decode(last_msg, &packet2);
3506 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3507}
3508
3509static void mavlink_test_attitude_target(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3510{
3511#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3512 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3513 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ATTITUDE_TARGET >= 256) {
3514 return;
3515 }
3516#endif
3517 mavlink_message_t msg;
3518 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3519 uint16_t i;
3520 mavlink_attitude_target_t packet_in = {
3521 963497464,{ 45.0, 46.0, 47.0, 48.0 },157.0,185.0,213.0,241.0,113
3522 };
3523 mavlink_attitude_target_t packet1, packet2;
3524 memset(&packet1, 0, sizeof(packet1));
3525 packet1.time_boot_ms = packet_in.time_boot_ms;
3526 packet1.body_roll_rate = packet_in.body_roll_rate;
3527 packet1.body_pitch_rate = packet_in.body_pitch_rate;
3528 packet1.body_yaw_rate = packet_in.body_yaw_rate;
3529 packet1.thrust = packet_in.thrust;
3530 packet1.type_mask = packet_in.type_mask;
3531
3532 mav_array_memcpy(packet1.q, packet_in.q, sizeof(float)*4);
3533
3534#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3535 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3536 // cope with extensions
3537 memset(MAVLINK_MSG_ID_ATTITUDE_TARGET_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ATTITUDE_TARGET_MIN_LEN);
3538 }
3539#endif
3540 memset(&packet2, 0, sizeof(packet2));
3541 mavlink_msg_attitude_target_encode(system_id, component_id, &msg, &packet1);
3542 mavlink_msg_attitude_target_decode(&msg, &packet2);
3543 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3544
3545 memset(&packet2, 0, sizeof(packet2));
3546 mavlink_msg_attitude_target_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.type_mask , packet1.q , packet1.body_roll_rate , packet1.body_pitch_rate , packet1.body_yaw_rate , packet1.thrust );
3547 mavlink_msg_attitude_target_decode(&msg, &packet2);
3548 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3549
3550 memset(&packet2, 0, sizeof(packet2));
3551 mavlink_msg_attitude_target_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.type_mask , packet1.q , packet1.body_roll_rate , packet1.body_pitch_rate , packet1.body_yaw_rate , packet1.thrust );
3552 mavlink_msg_attitude_target_decode(&msg, &packet2);
3553 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3554
3555 memset(&packet2, 0, sizeof(packet2));
3556 mavlink_msg_to_send_buffer(buffer, &msg);
3557 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3558 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3559 }
3560 mavlink_msg_attitude_target_decode(last_msg, &packet2);
3561 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3562
3563 memset(&packet2, 0, sizeof(packet2));
3564 mavlink_msg_attitude_target_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.type_mask , packet1.q , packet1.body_roll_rate , packet1.body_pitch_rate , packet1.body_yaw_rate , packet1.thrust );
3565 mavlink_msg_attitude_target_decode(last_msg, &packet2);
3566 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3567}
3568
3569static void mavlink_test_set_position_target_local_ned(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3570{
3571#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3572 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3573 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SET_POSITION_TARGET_LOCAL_NED >= 256) {
3574 return;
3575 }
3576#endif
3577 mavlink_message_t msg;
3578 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3579 uint16_t i;
3580 mavlink_set_position_target_local_ned_t packet_in = {
3581 963497464,45.0,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,325.0,19731,27,94,161
3582 };
3583 mavlink_set_position_target_local_ned_t packet1, packet2;
3584 memset(&packet1, 0, sizeof(packet1));
3585 packet1.time_boot_ms = packet_in.time_boot_ms;
3586 packet1.x = packet_in.x;
3587 packet1.y = packet_in.y;
3588 packet1.z = packet_in.z;
3589 packet1.vx = packet_in.vx;
3590 packet1.vy = packet_in.vy;
3591 packet1.vz = packet_in.vz;
3592 packet1.afx = packet_in.afx;
3593 packet1.afy = packet_in.afy;
3594 packet1.afz = packet_in.afz;
3595 packet1.yaw = packet_in.yaw;
3596 packet1.yaw_rate = packet_in.yaw_rate;
3597 packet1.type_mask = packet_in.type_mask;
3598 packet1.target_system = packet_in.target_system;
3599 packet1.target_component = packet_in.target_component;
3600 packet1.coordinate_frame = packet_in.coordinate_frame;
3601
3602
3603#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3604 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3605 // cope with extensions
3606 memset(MAVLINK_MSG_ID_SET_POSITION_TARGET_LOCAL_NED_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SET_POSITION_TARGET_LOCAL_NED_MIN_LEN);
3607 }
3608#endif
3609 memset(&packet2, 0, sizeof(packet2));
3610 mavlink_msg_set_position_target_local_ned_encode(system_id, component_id, &msg, &packet1);
3611 mavlink_msg_set_position_target_local_ned_decode(&msg, &packet2);
3612 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3613
3614 memset(&packet2, 0, sizeof(packet2));
3615 mavlink_msg_set_position_target_local_ned_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.target_system , packet1.target_component , packet1.coordinate_frame , packet1.type_mask , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3616 mavlink_msg_set_position_target_local_ned_decode(&msg, &packet2);
3617 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3618
3619 memset(&packet2, 0, sizeof(packet2));
3620 mavlink_msg_set_position_target_local_ned_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.target_system , packet1.target_component , packet1.coordinate_frame , packet1.type_mask , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3621 mavlink_msg_set_position_target_local_ned_decode(&msg, &packet2);
3622 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3623
3624 memset(&packet2, 0, sizeof(packet2));
3625 mavlink_msg_to_send_buffer(buffer, &msg);
3626 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3627 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3628 }
3629 mavlink_msg_set_position_target_local_ned_decode(last_msg, &packet2);
3630 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3631
3632 memset(&packet2, 0, sizeof(packet2));
3633 mavlink_msg_set_position_target_local_ned_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.target_system , packet1.target_component , packet1.coordinate_frame , packet1.type_mask , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3634 mavlink_msg_set_position_target_local_ned_decode(last_msg, &packet2);
3635 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3636}
3637
3638static void mavlink_test_position_target_local_ned(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3639{
3640#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3641 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3642 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_POSITION_TARGET_LOCAL_NED >= 256) {
3643 return;
3644 }
3645#endif
3646 mavlink_message_t msg;
3647 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3648 uint16_t i;
3649 mavlink_position_target_local_ned_t packet_in = {
3650 963497464,45.0,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,325.0,19731,27
3651 };
3652 mavlink_position_target_local_ned_t packet1, packet2;
3653 memset(&packet1, 0, sizeof(packet1));
3654 packet1.time_boot_ms = packet_in.time_boot_ms;
3655 packet1.x = packet_in.x;
3656 packet1.y = packet_in.y;
3657 packet1.z = packet_in.z;
3658 packet1.vx = packet_in.vx;
3659 packet1.vy = packet_in.vy;
3660 packet1.vz = packet_in.vz;
3661 packet1.afx = packet_in.afx;
3662 packet1.afy = packet_in.afy;
3663 packet1.afz = packet_in.afz;
3664 packet1.yaw = packet_in.yaw;
3665 packet1.yaw_rate = packet_in.yaw_rate;
3666 packet1.type_mask = packet_in.type_mask;
3667 packet1.coordinate_frame = packet_in.coordinate_frame;
3668
3669
3670#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3671 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3672 // cope with extensions
3673 memset(MAVLINK_MSG_ID_POSITION_TARGET_LOCAL_NED_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_POSITION_TARGET_LOCAL_NED_MIN_LEN);
3674 }
3675#endif
3676 memset(&packet2, 0, sizeof(packet2));
3677 mavlink_msg_position_target_local_ned_encode(system_id, component_id, &msg, &packet1);
3678 mavlink_msg_position_target_local_ned_decode(&msg, &packet2);
3679 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3680
3681 memset(&packet2, 0, sizeof(packet2));
3682 mavlink_msg_position_target_local_ned_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.coordinate_frame , packet1.type_mask , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3683 mavlink_msg_position_target_local_ned_decode(&msg, &packet2);
3684 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3685
3686 memset(&packet2, 0, sizeof(packet2));
3687 mavlink_msg_position_target_local_ned_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.coordinate_frame , packet1.type_mask , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3688 mavlink_msg_position_target_local_ned_decode(&msg, &packet2);
3689 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3690
3691 memset(&packet2, 0, sizeof(packet2));
3692 mavlink_msg_to_send_buffer(buffer, &msg);
3693 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3694 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3695 }
3696 mavlink_msg_position_target_local_ned_decode(last_msg, &packet2);
3697 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3698
3699 memset(&packet2, 0, sizeof(packet2));
3700 mavlink_msg_position_target_local_ned_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.coordinate_frame , packet1.type_mask , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3701 mavlink_msg_position_target_local_ned_decode(last_msg, &packet2);
3702 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3703}
3704
3705static void mavlink_test_set_position_target_global_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3706{
3707#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3708 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3709 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SET_POSITION_TARGET_GLOBAL_INT >= 256) {
3710 return;
3711 }
3712#endif
3713 mavlink_message_t msg;
3714 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3715 uint16_t i;
3716 mavlink_set_position_target_global_int_t packet_in = {
3717 963497464,963497672,963497880,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,325.0,19731,27,94,161
3718 };
3719 mavlink_set_position_target_global_int_t packet1, packet2;
3720 memset(&packet1, 0, sizeof(packet1));
3721 packet1.time_boot_ms = packet_in.time_boot_ms;
3722 packet1.lat_int = packet_in.lat_int;
3723 packet1.lon_int = packet_in.lon_int;
3724 packet1.alt = packet_in.alt;
3725 packet1.vx = packet_in.vx;
3726 packet1.vy = packet_in.vy;
3727 packet1.vz = packet_in.vz;
3728 packet1.afx = packet_in.afx;
3729 packet1.afy = packet_in.afy;
3730 packet1.afz = packet_in.afz;
3731 packet1.yaw = packet_in.yaw;
3732 packet1.yaw_rate = packet_in.yaw_rate;
3733 packet1.type_mask = packet_in.type_mask;
3734 packet1.target_system = packet_in.target_system;
3735 packet1.target_component = packet_in.target_component;
3736 packet1.coordinate_frame = packet_in.coordinate_frame;
3737
3738
3739#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3740 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3741 // cope with extensions
3742 memset(MAVLINK_MSG_ID_SET_POSITION_TARGET_GLOBAL_INT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SET_POSITION_TARGET_GLOBAL_INT_MIN_LEN);
3743 }
3744#endif
3745 memset(&packet2, 0, sizeof(packet2));
3746 mavlink_msg_set_position_target_global_int_encode(system_id, component_id, &msg, &packet1);
3747 mavlink_msg_set_position_target_global_int_decode(&msg, &packet2);
3748 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3749
3750 memset(&packet2, 0, sizeof(packet2));
3751 mavlink_msg_set_position_target_global_int_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.target_system , packet1.target_component , packet1.coordinate_frame , packet1.type_mask , packet1.lat_int , packet1.lon_int , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3752 mavlink_msg_set_position_target_global_int_decode(&msg, &packet2);
3753 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3754
3755 memset(&packet2, 0, sizeof(packet2));
3756 mavlink_msg_set_position_target_global_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.target_system , packet1.target_component , packet1.coordinate_frame , packet1.type_mask , packet1.lat_int , packet1.lon_int , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3757 mavlink_msg_set_position_target_global_int_decode(&msg, &packet2);
3758 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3759
3760 memset(&packet2, 0, sizeof(packet2));
3761 mavlink_msg_to_send_buffer(buffer, &msg);
3762 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3763 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3764 }
3765 mavlink_msg_set_position_target_global_int_decode(last_msg, &packet2);
3766 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3767
3768 memset(&packet2, 0, sizeof(packet2));
3769 mavlink_msg_set_position_target_global_int_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.target_system , packet1.target_component , packet1.coordinate_frame , packet1.type_mask , packet1.lat_int , packet1.lon_int , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3770 mavlink_msg_set_position_target_global_int_decode(last_msg, &packet2);
3771 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3772}
3773
3774static void mavlink_test_position_target_global_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3775{
3776#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3777 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3778 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_POSITION_TARGET_GLOBAL_INT >= 256) {
3779 return;
3780 }
3781#endif
3782 mavlink_message_t msg;
3783 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3784 uint16_t i;
3785 mavlink_position_target_global_int_t packet_in = {
3786 963497464,963497672,963497880,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,325.0,19731,27
3787 };
3788 mavlink_position_target_global_int_t packet1, packet2;
3789 memset(&packet1, 0, sizeof(packet1));
3790 packet1.time_boot_ms = packet_in.time_boot_ms;
3791 packet1.lat_int = packet_in.lat_int;
3792 packet1.lon_int = packet_in.lon_int;
3793 packet1.alt = packet_in.alt;
3794 packet1.vx = packet_in.vx;
3795 packet1.vy = packet_in.vy;
3796 packet1.vz = packet_in.vz;
3797 packet1.afx = packet_in.afx;
3798 packet1.afy = packet_in.afy;
3799 packet1.afz = packet_in.afz;
3800 packet1.yaw = packet_in.yaw;
3801 packet1.yaw_rate = packet_in.yaw_rate;
3802 packet1.type_mask = packet_in.type_mask;
3803 packet1.coordinate_frame = packet_in.coordinate_frame;
3804
3805
3806#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3807 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3808 // cope with extensions
3809 memset(MAVLINK_MSG_ID_POSITION_TARGET_GLOBAL_INT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_POSITION_TARGET_GLOBAL_INT_MIN_LEN);
3810 }
3811#endif
3812 memset(&packet2, 0, sizeof(packet2));
3813 mavlink_msg_position_target_global_int_encode(system_id, component_id, &msg, &packet1);
3814 mavlink_msg_position_target_global_int_decode(&msg, &packet2);
3815 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3816
3817 memset(&packet2, 0, sizeof(packet2));
3818 mavlink_msg_position_target_global_int_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.coordinate_frame , packet1.type_mask , packet1.lat_int , packet1.lon_int , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3819 mavlink_msg_position_target_global_int_decode(&msg, &packet2);
3820 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3821
3822 memset(&packet2, 0, sizeof(packet2));
3823 mavlink_msg_position_target_global_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.coordinate_frame , packet1.type_mask , packet1.lat_int , packet1.lon_int , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3824 mavlink_msg_position_target_global_int_decode(&msg, &packet2);
3825 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3826
3827 memset(&packet2, 0, sizeof(packet2));
3828 mavlink_msg_to_send_buffer(buffer, &msg);
3829 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3830 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3831 }
3832 mavlink_msg_position_target_global_int_decode(last_msg, &packet2);
3833 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3834
3835 memset(&packet2, 0, sizeof(packet2));
3836 mavlink_msg_position_target_global_int_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.coordinate_frame , packet1.type_mask , packet1.lat_int , packet1.lon_int , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.afx , packet1.afy , packet1.afz , packet1.yaw , packet1.yaw_rate );
3837 mavlink_msg_position_target_global_int_decode(last_msg, &packet2);
3838 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3839}
3840
3841static void mavlink_test_local_position_ned_system_global_offset(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3842{
3843#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3844 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3845 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOCAL_POSITION_NED_SYSTEM_GLOBAL_OFFSET >= 256) {
3846 return;
3847 }
3848#endif
3849 mavlink_message_t msg;
3850 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3851 uint16_t i;
3852 mavlink_local_position_ned_system_global_offset_t packet_in = {
3853 963497464,45.0,73.0,101.0,129.0,157.0,185.0
3854 };
3855 mavlink_local_position_ned_system_global_offset_t packet1, packet2;
3856 memset(&packet1, 0, sizeof(packet1));
3857 packet1.time_boot_ms = packet_in.time_boot_ms;
3858 packet1.x = packet_in.x;
3859 packet1.y = packet_in.y;
3860 packet1.z = packet_in.z;
3861 packet1.roll = packet_in.roll;
3862 packet1.pitch = packet_in.pitch;
3863 packet1.yaw = packet_in.yaw;
3864
3865
3866#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3867 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3868 // cope with extensions
3869 memset(MAVLINK_MSG_ID_LOCAL_POSITION_NED_SYSTEM_GLOBAL_OFFSET_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOCAL_POSITION_NED_SYSTEM_GLOBAL_OFFSET_MIN_LEN);
3870 }
3871#endif
3872 memset(&packet2, 0, sizeof(packet2));
3873 mavlink_msg_local_position_ned_system_global_offset_encode(system_id, component_id, &msg, &packet1);
3874 mavlink_msg_local_position_ned_system_global_offset_decode(&msg, &packet2);
3875 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3876
3877 memset(&packet2, 0, sizeof(packet2));
3878 mavlink_msg_local_position_ned_system_global_offset_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
3879 mavlink_msg_local_position_ned_system_global_offset_decode(&msg, &packet2);
3880 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3881
3882 memset(&packet2, 0, sizeof(packet2));
3883 mavlink_msg_local_position_ned_system_global_offset_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
3884 mavlink_msg_local_position_ned_system_global_offset_decode(&msg, &packet2);
3885 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3886
3887 memset(&packet2, 0, sizeof(packet2));
3888 mavlink_msg_to_send_buffer(buffer, &msg);
3889 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3890 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3891 }
3892 mavlink_msg_local_position_ned_system_global_offset_decode(last_msg, &packet2);
3893 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3894
3895 memset(&packet2, 0, sizeof(packet2));
3896 mavlink_msg_local_position_ned_system_global_offset_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
3897 mavlink_msg_local_position_ned_system_global_offset_decode(last_msg, &packet2);
3898 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3899}
3900
3901static void mavlink_test_hil_state(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3902{
3903#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3904 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3905 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HIL_STATE >= 256) {
3906 return;
3907 }
3908#endif
3909 mavlink_message_t msg;
3910 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3911 uint16_t i;
3912 mavlink_hil_state_t packet_in = {
3913 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0,963499128,963499336,963499544,19523,19627,19731,19835,19939,20043
3914 };
3915 mavlink_hil_state_t packet1, packet2;
3916 memset(&packet1, 0, sizeof(packet1));
3917 packet1.time_usec = packet_in.time_usec;
3918 packet1.roll = packet_in.roll;
3919 packet1.pitch = packet_in.pitch;
3920 packet1.yaw = packet_in.yaw;
3921 packet1.rollspeed = packet_in.rollspeed;
3922 packet1.pitchspeed = packet_in.pitchspeed;
3923 packet1.yawspeed = packet_in.yawspeed;
3924 packet1.lat = packet_in.lat;
3925 packet1.lon = packet_in.lon;
3926 packet1.alt = packet_in.alt;
3927 packet1.vx = packet_in.vx;
3928 packet1.vy = packet_in.vy;
3929 packet1.vz = packet_in.vz;
3930 packet1.xacc = packet_in.xacc;
3931 packet1.yacc = packet_in.yacc;
3932 packet1.zacc = packet_in.zacc;
3933
3934
3935#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3936 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
3937 // cope with extensions
3938 memset(MAVLINK_MSG_ID_HIL_STATE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HIL_STATE_MIN_LEN);
3939 }
3940#endif
3941 memset(&packet2, 0, sizeof(packet2));
3942 mavlink_msg_hil_state_encode(system_id, component_id, &msg, &packet1);
3943 mavlink_msg_hil_state_decode(&msg, &packet2);
3944 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3945
3946 memset(&packet2, 0, sizeof(packet2));
3947 mavlink_msg_hil_state_pack(system_id, component_id, &msg , packet1.time_usec , packet1.roll , packet1.pitch , packet1.yaw , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.xacc , packet1.yacc , packet1.zacc );
3948 mavlink_msg_hil_state_decode(&msg, &packet2);
3949 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3950
3951 memset(&packet2, 0, sizeof(packet2));
3952 mavlink_msg_hil_state_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.roll , packet1.pitch , packet1.yaw , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.xacc , packet1.yacc , packet1.zacc );
3953 mavlink_msg_hil_state_decode(&msg, &packet2);
3954 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3955
3956 memset(&packet2, 0, sizeof(packet2));
3957 mavlink_msg_to_send_buffer(buffer, &msg);
3958 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
3959 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
3960 }
3961 mavlink_msg_hil_state_decode(last_msg, &packet2);
3962 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3963
3964 memset(&packet2, 0, sizeof(packet2));
3965 mavlink_msg_hil_state_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.roll , packet1.pitch , packet1.yaw , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.xacc , packet1.yacc , packet1.zacc );
3966 mavlink_msg_hil_state_decode(last_msg, &packet2);
3967 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
3968}
3969
3970static void mavlink_test_hil_controls(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
3971{
3972#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
3973 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
3974 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HIL_CONTROLS >= 256) {
3975 return;
3976 }
3977#endif
3978 mavlink_message_t msg;
3979 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
3980 uint16_t i;
3981 mavlink_hil_controls_t packet_in = {
3982 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,125,192
3983 };
3984 mavlink_hil_controls_t packet1, packet2;
3985 memset(&packet1, 0, sizeof(packet1));
3986 packet1.time_usec = packet_in.time_usec;
3987 packet1.roll_ailerons = packet_in.roll_ailerons;
3988 packet1.pitch_elevator = packet_in.pitch_elevator;
3989 packet1.yaw_rudder = packet_in.yaw_rudder;
3990 packet1.throttle = packet_in.throttle;
3991 packet1.aux1 = packet_in.aux1;
3992 packet1.aux2 = packet_in.aux2;
3993 packet1.aux3 = packet_in.aux3;
3994 packet1.aux4 = packet_in.aux4;
3995 packet1.mode = packet_in.mode;
3996 packet1.nav_mode = packet_in.nav_mode;
3997
3998
3999#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4000 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4001 // cope with extensions
4002 memset(MAVLINK_MSG_ID_HIL_CONTROLS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HIL_CONTROLS_MIN_LEN);
4003 }
4004#endif
4005 memset(&packet2, 0, sizeof(packet2));
4006 mavlink_msg_hil_controls_encode(system_id, component_id, &msg, &packet1);
4007 mavlink_msg_hil_controls_decode(&msg, &packet2);
4008 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4009
4010 memset(&packet2, 0, sizeof(packet2));
4011 mavlink_msg_hil_controls_pack(system_id, component_id, &msg , packet1.time_usec , packet1.roll_ailerons , packet1.pitch_elevator , packet1.yaw_rudder , packet1.throttle , packet1.aux1 , packet1.aux2 , packet1.aux3 , packet1.aux4 , packet1.mode , packet1.nav_mode );
4012 mavlink_msg_hil_controls_decode(&msg, &packet2);
4013 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4014
4015 memset(&packet2, 0, sizeof(packet2));
4016 mavlink_msg_hil_controls_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.roll_ailerons , packet1.pitch_elevator , packet1.yaw_rudder , packet1.throttle , packet1.aux1 , packet1.aux2 , packet1.aux3 , packet1.aux4 , packet1.mode , packet1.nav_mode );
4017 mavlink_msg_hil_controls_decode(&msg, &packet2);
4018 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4019
4020 memset(&packet2, 0, sizeof(packet2));
4021 mavlink_msg_to_send_buffer(buffer, &msg);
4022 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4023 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4024 }
4025 mavlink_msg_hil_controls_decode(last_msg, &packet2);
4026 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4027
4028 memset(&packet2, 0, sizeof(packet2));
4029 mavlink_msg_hil_controls_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.roll_ailerons , packet1.pitch_elevator , packet1.yaw_rudder , packet1.throttle , packet1.aux1 , packet1.aux2 , packet1.aux3 , packet1.aux4 , packet1.mode , packet1.nav_mode );
4030 mavlink_msg_hil_controls_decode(last_msg, &packet2);
4031 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4032}
4033
4034static void mavlink_test_hil_rc_inputs_raw(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4035{
4036#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4037 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4038 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HIL_RC_INPUTS_RAW >= 256) {
4039 return;
4040 }
4041#endif
4042 mavlink_message_t msg;
4043 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4044 uint16_t i;
4045 mavlink_hil_rc_inputs_raw_t packet_in = {
4046 93372036854775807ULL,17651,17755,17859,17963,18067,18171,18275,18379,18483,18587,18691,18795,101
4047 };
4048 mavlink_hil_rc_inputs_raw_t packet1, packet2;
4049 memset(&packet1, 0, sizeof(packet1));
4050 packet1.time_usec = packet_in.time_usec;
4051 packet1.chan1_raw = packet_in.chan1_raw;
4052 packet1.chan2_raw = packet_in.chan2_raw;
4053 packet1.chan3_raw = packet_in.chan3_raw;
4054 packet1.chan4_raw = packet_in.chan4_raw;
4055 packet1.chan5_raw = packet_in.chan5_raw;
4056 packet1.chan6_raw = packet_in.chan6_raw;
4057 packet1.chan7_raw = packet_in.chan7_raw;
4058 packet1.chan8_raw = packet_in.chan8_raw;
4059 packet1.chan9_raw = packet_in.chan9_raw;
4060 packet1.chan10_raw = packet_in.chan10_raw;
4061 packet1.chan11_raw = packet_in.chan11_raw;
4062 packet1.chan12_raw = packet_in.chan12_raw;
4063 packet1.rssi = packet_in.rssi;
4064
4065
4066#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4067 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4068 // cope with extensions
4069 memset(MAVLINK_MSG_ID_HIL_RC_INPUTS_RAW_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HIL_RC_INPUTS_RAW_MIN_LEN);
4070 }
4071#endif
4072 memset(&packet2, 0, sizeof(packet2));
4073 mavlink_msg_hil_rc_inputs_raw_encode(system_id, component_id, &msg, &packet1);
4074 mavlink_msg_hil_rc_inputs_raw_decode(&msg, &packet2);
4075 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4076
4077 memset(&packet2, 0, sizeof(packet2));
4078 mavlink_msg_hil_rc_inputs_raw_pack(system_id, component_id, &msg , packet1.time_usec , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw , packet1.chan9_raw , packet1.chan10_raw , packet1.chan11_raw , packet1.chan12_raw , packet1.rssi );
4079 mavlink_msg_hil_rc_inputs_raw_decode(&msg, &packet2);
4080 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4081
4082 memset(&packet2, 0, sizeof(packet2));
4083 mavlink_msg_hil_rc_inputs_raw_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw , packet1.chan9_raw , packet1.chan10_raw , packet1.chan11_raw , packet1.chan12_raw , packet1.rssi );
4084 mavlink_msg_hil_rc_inputs_raw_decode(&msg, &packet2);
4085 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4086
4087 memset(&packet2, 0, sizeof(packet2));
4088 mavlink_msg_to_send_buffer(buffer, &msg);
4089 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4090 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4091 }
4092 mavlink_msg_hil_rc_inputs_raw_decode(last_msg, &packet2);
4093 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4094
4095 memset(&packet2, 0, sizeof(packet2));
4096 mavlink_msg_hil_rc_inputs_raw_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.chan1_raw , packet1.chan2_raw , packet1.chan3_raw , packet1.chan4_raw , packet1.chan5_raw , packet1.chan6_raw , packet1.chan7_raw , packet1.chan8_raw , packet1.chan9_raw , packet1.chan10_raw , packet1.chan11_raw , packet1.chan12_raw , packet1.rssi );
4097 mavlink_msg_hil_rc_inputs_raw_decode(last_msg, &packet2);
4098 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4099}
4100
4101static void mavlink_test_hil_actuator_controls(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4102{
4103#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4104 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4105 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HIL_ACTUATOR_CONTROLS >= 256) {
4106 return;
4107 }
4108#endif
4109 mavlink_message_t msg;
4110 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4111 uint16_t i;
4112 mavlink_hil_actuator_controls_t packet_in = {
4113 93372036854775807ULL,93372036854776311ULL,{ 129.0, 130.0, 131.0, 132.0, 133.0, 134.0, 135.0, 136.0, 137.0, 138.0, 139.0, 140.0, 141.0, 142.0, 143.0, 144.0 },245
4114 };
4115 mavlink_hil_actuator_controls_t packet1, packet2;
4116 memset(&packet1, 0, sizeof(packet1));
4117 packet1.time_usec = packet_in.time_usec;
4118 packet1.flags = packet_in.flags;
4119 packet1.mode = packet_in.mode;
4120
4121 mav_array_memcpy(packet1.controls, packet_in.controls, sizeof(float)*16);
4122
4123#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4124 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4125 // cope with extensions
4126 memset(MAVLINK_MSG_ID_HIL_ACTUATOR_CONTROLS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HIL_ACTUATOR_CONTROLS_MIN_LEN);
4127 }
4128#endif
4129 memset(&packet2, 0, sizeof(packet2));
4130 mavlink_msg_hil_actuator_controls_encode(system_id, component_id, &msg, &packet1);
4131 mavlink_msg_hil_actuator_controls_decode(&msg, &packet2);
4132 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4133
4134 memset(&packet2, 0, sizeof(packet2));
4135 mavlink_msg_hil_actuator_controls_pack(system_id, component_id, &msg , packet1.time_usec , packet1.controls , packet1.mode , packet1.flags );
4136 mavlink_msg_hil_actuator_controls_decode(&msg, &packet2);
4137 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4138
4139 memset(&packet2, 0, sizeof(packet2));
4140 mavlink_msg_hil_actuator_controls_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.controls , packet1.mode , packet1.flags );
4141 mavlink_msg_hil_actuator_controls_decode(&msg, &packet2);
4142 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4143
4144 memset(&packet2, 0, sizeof(packet2));
4145 mavlink_msg_to_send_buffer(buffer, &msg);
4146 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4147 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4148 }
4149 mavlink_msg_hil_actuator_controls_decode(last_msg, &packet2);
4150 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4151
4152 memset(&packet2, 0, sizeof(packet2));
4153 mavlink_msg_hil_actuator_controls_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.controls , packet1.mode , packet1.flags );
4154 mavlink_msg_hil_actuator_controls_decode(last_msg, &packet2);
4155 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4156}
4157
4158static void mavlink_test_optical_flow(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4159{
4160#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4161 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4162 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_OPTICAL_FLOW >= 256) {
4163 return;
4164 }
4165#endif
4166 mavlink_message_t msg;
4167 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4168 uint16_t i;
4169 mavlink_optical_flow_t packet_in = {
4170 93372036854775807ULL,73.0,101.0,129.0,18275,18379,77,144,199.0,227.0
4171 };
4172 mavlink_optical_flow_t packet1, packet2;
4173 memset(&packet1, 0, sizeof(packet1));
4174 packet1.time_usec = packet_in.time_usec;
4175 packet1.flow_comp_m_x = packet_in.flow_comp_m_x;
4176 packet1.flow_comp_m_y = packet_in.flow_comp_m_y;
4177 packet1.ground_distance = packet_in.ground_distance;
4178 packet1.flow_x = packet_in.flow_x;
4179 packet1.flow_y = packet_in.flow_y;
4180 packet1.sensor_id = packet_in.sensor_id;
4181 packet1.quality = packet_in.quality;
4182 packet1.flow_rate_x = packet_in.flow_rate_x;
4183 packet1.flow_rate_y = packet_in.flow_rate_y;
4184
4185
4186#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4187 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4188 // cope with extensions
4189 memset(MAVLINK_MSG_ID_OPTICAL_FLOW_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_OPTICAL_FLOW_MIN_LEN);
4190 }
4191#endif
4192 memset(&packet2, 0, sizeof(packet2));
4193 mavlink_msg_optical_flow_encode(system_id, component_id, &msg, &packet1);
4194 mavlink_msg_optical_flow_decode(&msg, &packet2);
4195 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4196
4197 memset(&packet2, 0, sizeof(packet2));
4198 mavlink_msg_optical_flow_pack(system_id, component_id, &msg , packet1.time_usec , packet1.sensor_id , packet1.flow_x , packet1.flow_y , packet1.flow_comp_m_x , packet1.flow_comp_m_y , packet1.quality , packet1.ground_distance , packet1.flow_rate_x , packet1.flow_rate_y );
4199 mavlink_msg_optical_flow_decode(&msg, &packet2);
4200 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4201
4202 memset(&packet2, 0, sizeof(packet2));
4203 mavlink_msg_optical_flow_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.sensor_id , packet1.flow_x , packet1.flow_y , packet1.flow_comp_m_x , packet1.flow_comp_m_y , packet1.quality , packet1.ground_distance , packet1.flow_rate_x , packet1.flow_rate_y );
4204 mavlink_msg_optical_flow_decode(&msg, &packet2);
4205 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4206
4207 memset(&packet2, 0, sizeof(packet2));
4208 mavlink_msg_to_send_buffer(buffer, &msg);
4209 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4210 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4211 }
4212 mavlink_msg_optical_flow_decode(last_msg, &packet2);
4213 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4214
4215 memset(&packet2, 0, sizeof(packet2));
4216 mavlink_msg_optical_flow_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.sensor_id , packet1.flow_x , packet1.flow_y , packet1.flow_comp_m_x , packet1.flow_comp_m_y , packet1.quality , packet1.ground_distance , packet1.flow_rate_x , packet1.flow_rate_y );
4217 mavlink_msg_optical_flow_decode(last_msg, &packet2);
4218 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4219}
4220
4221static void mavlink_test_global_vision_position_estimate(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4222{
4223#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4224 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4225 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GLOBAL_VISION_POSITION_ESTIMATE >= 256) {
4226 return;
4227 }
4228#endif
4229 mavlink_message_t msg;
4230 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4231 uint16_t i;
4232 mavlink_global_vision_position_estimate_t packet_in = {
4233 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0
4234 };
4235 mavlink_global_vision_position_estimate_t packet1, packet2;
4236 memset(&packet1, 0, sizeof(packet1));
4237 packet1.usec = packet_in.usec;
4238 packet1.x = packet_in.x;
4239 packet1.y = packet_in.y;
4240 packet1.z = packet_in.z;
4241 packet1.roll = packet_in.roll;
4242 packet1.pitch = packet_in.pitch;
4243 packet1.yaw = packet_in.yaw;
4244
4245
4246#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4247 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4248 // cope with extensions
4249 memset(MAVLINK_MSG_ID_GLOBAL_VISION_POSITION_ESTIMATE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GLOBAL_VISION_POSITION_ESTIMATE_MIN_LEN);
4250 }
4251#endif
4252 memset(&packet2, 0, sizeof(packet2));
4253 mavlink_msg_global_vision_position_estimate_encode(system_id, component_id, &msg, &packet1);
4254 mavlink_msg_global_vision_position_estimate_decode(&msg, &packet2);
4255 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4256
4257 memset(&packet2, 0, sizeof(packet2));
4258 mavlink_msg_global_vision_position_estimate_pack(system_id, component_id, &msg , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
4259 mavlink_msg_global_vision_position_estimate_decode(&msg, &packet2);
4260 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4261
4262 memset(&packet2, 0, sizeof(packet2));
4263 mavlink_msg_global_vision_position_estimate_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
4264 mavlink_msg_global_vision_position_estimate_decode(&msg, &packet2);
4265 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4266
4267 memset(&packet2, 0, sizeof(packet2));
4268 mavlink_msg_to_send_buffer(buffer, &msg);
4269 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4270 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4271 }
4272 mavlink_msg_global_vision_position_estimate_decode(last_msg, &packet2);
4273 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4274
4275 memset(&packet2, 0, sizeof(packet2));
4276 mavlink_msg_global_vision_position_estimate_send(MAVLINK_COMM_1 , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
4277 mavlink_msg_global_vision_position_estimate_decode(last_msg, &packet2);
4278 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4279}
4280
4281static void mavlink_test_vision_position_estimate(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4282{
4283#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4284 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4285 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_VISION_POSITION_ESTIMATE >= 256) {
4286 return;
4287 }
4288#endif
4289 mavlink_message_t msg;
4290 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4291 uint16_t i;
4292 mavlink_vision_position_estimate_t packet_in = {
4293 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0
4294 };
4295 mavlink_vision_position_estimate_t packet1, packet2;
4296 memset(&packet1, 0, sizeof(packet1));
4297 packet1.usec = packet_in.usec;
4298 packet1.x = packet_in.x;
4299 packet1.y = packet_in.y;
4300 packet1.z = packet_in.z;
4301 packet1.roll = packet_in.roll;
4302 packet1.pitch = packet_in.pitch;
4303 packet1.yaw = packet_in.yaw;
4304
4305
4306#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4307 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4308 // cope with extensions
4309 memset(MAVLINK_MSG_ID_VISION_POSITION_ESTIMATE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_VISION_POSITION_ESTIMATE_MIN_LEN);
4310 }
4311#endif
4312 memset(&packet2, 0, sizeof(packet2));
4313 mavlink_msg_vision_position_estimate_encode(system_id, component_id, &msg, &packet1);
4314 mavlink_msg_vision_position_estimate_decode(&msg, &packet2);
4315 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4316
4317 memset(&packet2, 0, sizeof(packet2));
4318 mavlink_msg_vision_position_estimate_pack(system_id, component_id, &msg , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
4319 mavlink_msg_vision_position_estimate_decode(&msg, &packet2);
4320 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4321
4322 memset(&packet2, 0, sizeof(packet2));
4323 mavlink_msg_vision_position_estimate_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
4324 mavlink_msg_vision_position_estimate_decode(&msg, &packet2);
4325 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4326
4327 memset(&packet2, 0, sizeof(packet2));
4328 mavlink_msg_to_send_buffer(buffer, &msg);
4329 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4330 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4331 }
4332 mavlink_msg_vision_position_estimate_decode(last_msg, &packet2);
4333 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4334
4335 memset(&packet2, 0, sizeof(packet2));
4336 mavlink_msg_vision_position_estimate_send(MAVLINK_COMM_1 , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
4337 mavlink_msg_vision_position_estimate_decode(last_msg, &packet2);
4338 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4339}
4340
4341static void mavlink_test_vision_speed_estimate(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4342{
4343#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4344 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4345 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_VISION_SPEED_ESTIMATE >= 256) {
4346 return;
4347 }
4348#endif
4349 mavlink_message_t msg;
4350 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4351 uint16_t i;
4352 mavlink_vision_speed_estimate_t packet_in = {
4353 93372036854775807ULL,73.0,101.0,129.0
4354 };
4355 mavlink_vision_speed_estimate_t packet1, packet2;
4356 memset(&packet1, 0, sizeof(packet1));
4357 packet1.usec = packet_in.usec;
4358 packet1.x = packet_in.x;
4359 packet1.y = packet_in.y;
4360 packet1.z = packet_in.z;
4361
4362
4363#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4364 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4365 // cope with extensions
4366 memset(MAVLINK_MSG_ID_VISION_SPEED_ESTIMATE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_VISION_SPEED_ESTIMATE_MIN_LEN);
4367 }
4368#endif
4369 memset(&packet2, 0, sizeof(packet2));
4370 mavlink_msg_vision_speed_estimate_encode(system_id, component_id, &msg, &packet1);
4371 mavlink_msg_vision_speed_estimate_decode(&msg, &packet2);
4372 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4373
4374 memset(&packet2, 0, sizeof(packet2));
4375 mavlink_msg_vision_speed_estimate_pack(system_id, component_id, &msg , packet1.usec , packet1.x , packet1.y , packet1.z );
4376 mavlink_msg_vision_speed_estimate_decode(&msg, &packet2);
4377 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4378
4379 memset(&packet2, 0, sizeof(packet2));
4380 mavlink_msg_vision_speed_estimate_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.x , packet1.y , packet1.z );
4381 mavlink_msg_vision_speed_estimate_decode(&msg, &packet2);
4382 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4383
4384 memset(&packet2, 0, sizeof(packet2));
4385 mavlink_msg_to_send_buffer(buffer, &msg);
4386 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4387 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4388 }
4389 mavlink_msg_vision_speed_estimate_decode(last_msg, &packet2);
4390 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4391
4392 memset(&packet2, 0, sizeof(packet2));
4393 mavlink_msg_vision_speed_estimate_send(MAVLINK_COMM_1 , packet1.usec , packet1.x , packet1.y , packet1.z );
4394 mavlink_msg_vision_speed_estimate_decode(last_msg, &packet2);
4395 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4396}
4397
4398static void mavlink_test_vicon_position_estimate(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4399{
4400#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4401 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4402 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_VICON_POSITION_ESTIMATE >= 256) {
4403 return;
4404 }
4405#endif
4406 mavlink_message_t msg;
4407 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4408 uint16_t i;
4409 mavlink_vicon_position_estimate_t packet_in = {
4410 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0
4411 };
4412 mavlink_vicon_position_estimate_t packet1, packet2;
4413 memset(&packet1, 0, sizeof(packet1));
4414 packet1.usec = packet_in.usec;
4415 packet1.x = packet_in.x;
4416 packet1.y = packet_in.y;
4417 packet1.z = packet_in.z;
4418 packet1.roll = packet_in.roll;
4419 packet1.pitch = packet_in.pitch;
4420 packet1.yaw = packet_in.yaw;
4421
4422
4423#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4424 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4425 // cope with extensions
4426 memset(MAVLINK_MSG_ID_VICON_POSITION_ESTIMATE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_VICON_POSITION_ESTIMATE_MIN_LEN);
4427 }
4428#endif
4429 memset(&packet2, 0, sizeof(packet2));
4430 mavlink_msg_vicon_position_estimate_encode(system_id, component_id, &msg, &packet1);
4431 mavlink_msg_vicon_position_estimate_decode(&msg, &packet2);
4432 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4433
4434 memset(&packet2, 0, sizeof(packet2));
4435 mavlink_msg_vicon_position_estimate_pack(system_id, component_id, &msg , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
4436 mavlink_msg_vicon_position_estimate_decode(&msg, &packet2);
4437 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4438
4439 memset(&packet2, 0, sizeof(packet2));
4440 mavlink_msg_vicon_position_estimate_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
4441 mavlink_msg_vicon_position_estimate_decode(&msg, &packet2);
4442 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4443
4444 memset(&packet2, 0, sizeof(packet2));
4445 mavlink_msg_to_send_buffer(buffer, &msg);
4446 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4447 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4448 }
4449 mavlink_msg_vicon_position_estimate_decode(last_msg, &packet2);
4450 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4451
4452 memset(&packet2, 0, sizeof(packet2));
4453 mavlink_msg_vicon_position_estimate_send(MAVLINK_COMM_1 , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.roll , packet1.pitch , packet1.yaw );
4454 mavlink_msg_vicon_position_estimate_decode(last_msg, &packet2);
4455 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4456}
4457
4458static void mavlink_test_highres_imu(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4459{
4460#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4461 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4462 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HIGHRES_IMU >= 256) {
4463 return;
4464 }
4465#endif
4466 mavlink_message_t msg;
4467 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4468 uint16_t i;
4469 mavlink_highres_imu_t packet_in = {
4470 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,325.0,353.0,381.0,409.0,20355
4471 };
4472 mavlink_highres_imu_t packet1, packet2;
4473 memset(&packet1, 0, sizeof(packet1));
4474 packet1.time_usec = packet_in.time_usec;
4475 packet1.xacc = packet_in.xacc;
4476 packet1.yacc = packet_in.yacc;
4477 packet1.zacc = packet_in.zacc;
4478 packet1.xgyro = packet_in.xgyro;
4479 packet1.ygyro = packet_in.ygyro;
4480 packet1.zgyro = packet_in.zgyro;
4481 packet1.xmag = packet_in.xmag;
4482 packet1.ymag = packet_in.ymag;
4483 packet1.zmag = packet_in.zmag;
4484 packet1.abs_pressure = packet_in.abs_pressure;
4485 packet1.diff_pressure = packet_in.diff_pressure;
4486 packet1.pressure_alt = packet_in.pressure_alt;
4487 packet1.temperature = packet_in.temperature;
4488 packet1.fields_updated = packet_in.fields_updated;
4489
4490
4491#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4492 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4493 // cope with extensions
4494 memset(MAVLINK_MSG_ID_HIGHRES_IMU_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HIGHRES_IMU_MIN_LEN);
4495 }
4496#endif
4497 memset(&packet2, 0, sizeof(packet2));
4498 mavlink_msg_highres_imu_encode(system_id, component_id, &msg, &packet1);
4499 mavlink_msg_highres_imu_decode(&msg, &packet2);
4500 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4501
4502 memset(&packet2, 0, sizeof(packet2));
4503 mavlink_msg_highres_imu_pack(system_id, component_id, &msg , packet1.time_usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag , packet1.abs_pressure , packet1.diff_pressure , packet1.pressure_alt , packet1.temperature , packet1.fields_updated );
4504 mavlink_msg_highres_imu_decode(&msg, &packet2);
4505 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4506
4507 memset(&packet2, 0, sizeof(packet2));
4508 mavlink_msg_highres_imu_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag , packet1.abs_pressure , packet1.diff_pressure , packet1.pressure_alt , packet1.temperature , packet1.fields_updated );
4509 mavlink_msg_highres_imu_decode(&msg, &packet2);
4510 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4511
4512 memset(&packet2, 0, sizeof(packet2));
4513 mavlink_msg_to_send_buffer(buffer, &msg);
4514 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4515 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4516 }
4517 mavlink_msg_highres_imu_decode(last_msg, &packet2);
4518 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4519
4520 memset(&packet2, 0, sizeof(packet2));
4521 mavlink_msg_highres_imu_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag , packet1.abs_pressure , packet1.diff_pressure , packet1.pressure_alt , packet1.temperature , packet1.fields_updated );
4522 mavlink_msg_highres_imu_decode(last_msg, &packet2);
4523 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4524}
4525
4526static void mavlink_test_optical_flow_rad(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4527{
4528#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4529 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4530 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_OPTICAL_FLOW_RAD >= 256) {
4531 return;
4532 }
4533#endif
4534 mavlink_message_t msg;
4535 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4536 uint16_t i;
4537 mavlink_optical_flow_rad_t packet_in = {
4538 93372036854775807ULL,963497880,101.0,129.0,157.0,185.0,213.0,963499128,269.0,19315,3,70
4539 };
4540 mavlink_optical_flow_rad_t packet1, packet2;
4541 memset(&packet1, 0, sizeof(packet1));
4542 packet1.time_usec = packet_in.time_usec;
4543 packet1.integration_time_us = packet_in.integration_time_us;
4544 packet1.integrated_x = packet_in.integrated_x;
4545 packet1.integrated_y = packet_in.integrated_y;
4546 packet1.integrated_xgyro = packet_in.integrated_xgyro;
4547 packet1.integrated_ygyro = packet_in.integrated_ygyro;
4548 packet1.integrated_zgyro = packet_in.integrated_zgyro;
4549 packet1.time_delta_distance_us = packet_in.time_delta_distance_us;
4550 packet1.distance = packet_in.distance;
4551 packet1.temperature = packet_in.temperature;
4552 packet1.sensor_id = packet_in.sensor_id;
4553 packet1.quality = packet_in.quality;
4554
4555
4556#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4557 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4558 // cope with extensions
4559 memset(MAVLINK_MSG_ID_OPTICAL_FLOW_RAD_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_OPTICAL_FLOW_RAD_MIN_LEN);
4560 }
4561#endif
4562 memset(&packet2, 0, sizeof(packet2));
4563 mavlink_msg_optical_flow_rad_encode(system_id, component_id, &msg, &packet1);
4564 mavlink_msg_optical_flow_rad_decode(&msg, &packet2);
4565 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4566
4567 memset(&packet2, 0, sizeof(packet2));
4568 mavlink_msg_optical_flow_rad_pack(system_id, component_id, &msg , packet1.time_usec , packet1.sensor_id , packet1.integration_time_us , packet1.integrated_x , packet1.integrated_y , packet1.integrated_xgyro , packet1.integrated_ygyro , packet1.integrated_zgyro , packet1.temperature , packet1.quality , packet1.time_delta_distance_us , packet1.distance );
4569 mavlink_msg_optical_flow_rad_decode(&msg, &packet2);
4570 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4571
4572 memset(&packet2, 0, sizeof(packet2));
4573 mavlink_msg_optical_flow_rad_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.sensor_id , packet1.integration_time_us , packet1.integrated_x , packet1.integrated_y , packet1.integrated_xgyro , packet1.integrated_ygyro , packet1.integrated_zgyro , packet1.temperature , packet1.quality , packet1.time_delta_distance_us , packet1.distance );
4574 mavlink_msg_optical_flow_rad_decode(&msg, &packet2);
4575 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4576
4577 memset(&packet2, 0, sizeof(packet2));
4578 mavlink_msg_to_send_buffer(buffer, &msg);
4579 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4580 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4581 }
4582 mavlink_msg_optical_flow_rad_decode(last_msg, &packet2);
4583 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4584
4585 memset(&packet2, 0, sizeof(packet2));
4586 mavlink_msg_optical_flow_rad_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.sensor_id , packet1.integration_time_us , packet1.integrated_x , packet1.integrated_y , packet1.integrated_xgyro , packet1.integrated_ygyro , packet1.integrated_zgyro , packet1.temperature , packet1.quality , packet1.time_delta_distance_us , packet1.distance );
4587 mavlink_msg_optical_flow_rad_decode(last_msg, &packet2);
4588 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4589}
4590
4591static void mavlink_test_hil_sensor(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4592{
4593#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4594 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4595 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HIL_SENSOR >= 256) {
4596 return;
4597 }
4598#endif
4599 mavlink_message_t msg;
4600 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4601 uint16_t i;
4602 mavlink_hil_sensor_t packet_in = {
4603 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,325.0,353.0,381.0,409.0,963500584
4604 };
4605 mavlink_hil_sensor_t packet1, packet2;
4606 memset(&packet1, 0, sizeof(packet1));
4607 packet1.time_usec = packet_in.time_usec;
4608 packet1.xacc = packet_in.xacc;
4609 packet1.yacc = packet_in.yacc;
4610 packet1.zacc = packet_in.zacc;
4611 packet1.xgyro = packet_in.xgyro;
4612 packet1.ygyro = packet_in.ygyro;
4613 packet1.zgyro = packet_in.zgyro;
4614 packet1.xmag = packet_in.xmag;
4615 packet1.ymag = packet_in.ymag;
4616 packet1.zmag = packet_in.zmag;
4617 packet1.abs_pressure = packet_in.abs_pressure;
4618 packet1.diff_pressure = packet_in.diff_pressure;
4619 packet1.pressure_alt = packet_in.pressure_alt;
4620 packet1.temperature = packet_in.temperature;
4621 packet1.fields_updated = packet_in.fields_updated;
4622
4623
4624#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4625 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4626 // cope with extensions
4627 memset(MAVLINK_MSG_ID_HIL_SENSOR_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HIL_SENSOR_MIN_LEN);
4628 }
4629#endif
4630 memset(&packet2, 0, sizeof(packet2));
4631 mavlink_msg_hil_sensor_encode(system_id, component_id, &msg, &packet1);
4632 mavlink_msg_hil_sensor_decode(&msg, &packet2);
4633 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4634
4635 memset(&packet2, 0, sizeof(packet2));
4636 mavlink_msg_hil_sensor_pack(system_id, component_id, &msg , packet1.time_usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag , packet1.abs_pressure , packet1.diff_pressure , packet1.pressure_alt , packet1.temperature , packet1.fields_updated );
4637 mavlink_msg_hil_sensor_decode(&msg, &packet2);
4638 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4639
4640 memset(&packet2, 0, sizeof(packet2));
4641 mavlink_msg_hil_sensor_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag , packet1.abs_pressure , packet1.diff_pressure , packet1.pressure_alt , packet1.temperature , packet1.fields_updated );
4642 mavlink_msg_hil_sensor_decode(&msg, &packet2);
4643 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4644
4645 memset(&packet2, 0, sizeof(packet2));
4646 mavlink_msg_to_send_buffer(buffer, &msg);
4647 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4648 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4649 }
4650 mavlink_msg_hil_sensor_decode(last_msg, &packet2);
4651 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4652
4653 memset(&packet2, 0, sizeof(packet2));
4654 mavlink_msg_hil_sensor_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag , packet1.abs_pressure , packet1.diff_pressure , packet1.pressure_alt , packet1.temperature , packet1.fields_updated );
4655 mavlink_msg_hil_sensor_decode(last_msg, &packet2);
4656 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4657}
4658
4659static void mavlink_test_sim_state(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4660{
4661#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4662 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4663 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SIM_STATE >= 256) {
4664 return;
4665 }
4666#endif
4667 mavlink_message_t msg;
4668 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4669 uint16_t i;
4670 mavlink_sim_state_t packet_in = {
4671 17.0,45.0,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,325.0,353.0,381.0,409.0,437.0,465.0,493.0,521.0,549.0,577.0
4672 };
4673 mavlink_sim_state_t packet1, packet2;
4674 memset(&packet1, 0, sizeof(packet1));
4675 packet1.q1 = packet_in.q1;
4676 packet1.q2 = packet_in.q2;
4677 packet1.q3 = packet_in.q3;
4678 packet1.q4 = packet_in.q4;
4679 packet1.roll = packet_in.roll;
4680 packet1.pitch = packet_in.pitch;
4681 packet1.yaw = packet_in.yaw;
4682 packet1.xacc = packet_in.xacc;
4683 packet1.yacc = packet_in.yacc;
4684 packet1.zacc = packet_in.zacc;
4685 packet1.xgyro = packet_in.xgyro;
4686 packet1.ygyro = packet_in.ygyro;
4687 packet1.zgyro = packet_in.zgyro;
4688 packet1.lat = packet_in.lat;
4689 packet1.lon = packet_in.lon;
4690 packet1.alt = packet_in.alt;
4691 packet1.std_dev_horz = packet_in.std_dev_horz;
4692 packet1.std_dev_vert = packet_in.std_dev_vert;
4693 packet1.vn = packet_in.vn;
4694 packet1.ve = packet_in.ve;
4695 packet1.vd = packet_in.vd;
4696
4697
4698#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4699 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4700 // cope with extensions
4701 memset(MAVLINK_MSG_ID_SIM_STATE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SIM_STATE_MIN_LEN);
4702 }
4703#endif
4704 memset(&packet2, 0, sizeof(packet2));
4705 mavlink_msg_sim_state_encode(system_id, component_id, &msg, &packet1);
4706 mavlink_msg_sim_state_decode(&msg, &packet2);
4707 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4708
4709 memset(&packet2, 0, sizeof(packet2));
4710 mavlink_msg_sim_state_pack(system_id, component_id, &msg , packet1.q1 , packet1.q2 , packet1.q3 , packet1.q4 , packet1.roll , packet1.pitch , packet1.yaw , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.lat , packet1.lon , packet1.alt , packet1.std_dev_horz , packet1.std_dev_vert , packet1.vn , packet1.ve , packet1.vd );
4711 mavlink_msg_sim_state_decode(&msg, &packet2);
4712 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4713
4714 memset(&packet2, 0, sizeof(packet2));
4715 mavlink_msg_sim_state_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.q1 , packet1.q2 , packet1.q3 , packet1.q4 , packet1.roll , packet1.pitch , packet1.yaw , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.lat , packet1.lon , packet1.alt , packet1.std_dev_horz , packet1.std_dev_vert , packet1.vn , packet1.ve , packet1.vd );
4716 mavlink_msg_sim_state_decode(&msg, &packet2);
4717 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4718
4719 memset(&packet2, 0, sizeof(packet2));
4720 mavlink_msg_to_send_buffer(buffer, &msg);
4721 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4722 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4723 }
4724 mavlink_msg_sim_state_decode(last_msg, &packet2);
4725 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4726
4727 memset(&packet2, 0, sizeof(packet2));
4728 mavlink_msg_sim_state_send(MAVLINK_COMM_1 , packet1.q1 , packet1.q2 , packet1.q3 , packet1.q4 , packet1.roll , packet1.pitch , packet1.yaw , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.lat , packet1.lon , packet1.alt , packet1.std_dev_horz , packet1.std_dev_vert , packet1.vn , packet1.ve , packet1.vd );
4729 mavlink_msg_sim_state_decode(last_msg, &packet2);
4730 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4731}
4732
4733static void mavlink_test_radio_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4734{
4735#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4736 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4737 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_RADIO_STATUS >= 256) {
4738 return;
4739 }
4740#endif
4741 mavlink_message_t msg;
4742 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4743 uint16_t i;
4744 mavlink_radio_status_t packet_in = {
4745 17235,17339,17,84,151,218,29
4746 };
4747 mavlink_radio_status_t packet1, packet2;
4748 memset(&packet1, 0, sizeof(packet1));
4749 packet1.rxerrors = packet_in.rxerrors;
4750 packet1.fixed = packet_in.fixed;
4751 packet1.rssi = packet_in.rssi;
4752 packet1.remrssi = packet_in.remrssi;
4753 packet1.txbuf = packet_in.txbuf;
4754 packet1.noise = packet_in.noise;
4755 packet1.remnoise = packet_in.remnoise;
4756
4757
4758#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4759 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4760 // cope with extensions
4761 memset(MAVLINK_MSG_ID_RADIO_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_RADIO_STATUS_MIN_LEN);
4762 }
4763#endif
4764 memset(&packet2, 0, sizeof(packet2));
4765 mavlink_msg_radio_status_encode(system_id, component_id, &msg, &packet1);
4766 mavlink_msg_radio_status_decode(&msg, &packet2);
4767 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4768
4769 memset(&packet2, 0, sizeof(packet2));
4770 mavlink_msg_radio_status_pack(system_id, component_id, &msg , packet1.rssi , packet1.remrssi , packet1.txbuf , packet1.noise , packet1.remnoise , packet1.rxerrors , packet1.fixed );
4771 mavlink_msg_radio_status_decode(&msg, &packet2);
4772 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4773
4774 memset(&packet2, 0, sizeof(packet2));
4775 mavlink_msg_radio_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.rssi , packet1.remrssi , packet1.txbuf , packet1.noise , packet1.remnoise , packet1.rxerrors , packet1.fixed );
4776 mavlink_msg_radio_status_decode(&msg, &packet2);
4777 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4778
4779 memset(&packet2, 0, sizeof(packet2));
4780 mavlink_msg_to_send_buffer(buffer, &msg);
4781 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4782 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4783 }
4784 mavlink_msg_radio_status_decode(last_msg, &packet2);
4785 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4786
4787 memset(&packet2, 0, sizeof(packet2));
4788 mavlink_msg_radio_status_send(MAVLINK_COMM_1 , packet1.rssi , packet1.remrssi , packet1.txbuf , packet1.noise , packet1.remnoise , packet1.rxerrors , packet1.fixed );
4789 mavlink_msg_radio_status_decode(last_msg, &packet2);
4790 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4791}
4792
4793static void mavlink_test_file_transfer_protocol(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4794{
4795#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4796 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4797 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL >= 256) {
4798 return;
4799 }
4800#endif
4801 mavlink_message_t msg;
4802 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4803 uint16_t i;
4804 mavlink_file_transfer_protocol_t packet_in = {
4805 5,72,139,{ 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200 }
4806 };
4807 mavlink_file_transfer_protocol_t packet1, packet2;
4808 memset(&packet1, 0, sizeof(packet1));
4809 packet1.target_network = packet_in.target_network;
4810 packet1.target_system = packet_in.target_system;
4811 packet1.target_component = packet_in.target_component;
4812
4813 mav_array_memcpy(packet1.payload, packet_in.payload, sizeof(uint8_t)*251);
4814
4815#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4816 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4817 // cope with extensions
4818 memset(MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL_MIN_LEN);
4819 }
4820#endif
4821 memset(&packet2, 0, sizeof(packet2));
4822 mavlink_msg_file_transfer_protocol_encode(system_id, component_id, &msg, &packet1);
4823 mavlink_msg_file_transfer_protocol_decode(&msg, &packet2);
4824 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4825
4826 memset(&packet2, 0, sizeof(packet2));
4827 mavlink_msg_file_transfer_protocol_pack(system_id, component_id, &msg , packet1.target_network , packet1.target_system , packet1.target_component , packet1.payload );
4828 mavlink_msg_file_transfer_protocol_decode(&msg, &packet2);
4829 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4830
4831 memset(&packet2, 0, sizeof(packet2));
4832 mavlink_msg_file_transfer_protocol_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_network , packet1.target_system , packet1.target_component , packet1.payload );
4833 mavlink_msg_file_transfer_protocol_decode(&msg, &packet2);
4834 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4835
4836 memset(&packet2, 0, sizeof(packet2));
4837 mavlink_msg_to_send_buffer(buffer, &msg);
4838 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4839 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4840 }
4841 mavlink_msg_file_transfer_protocol_decode(last_msg, &packet2);
4842 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4843
4844 memset(&packet2, 0, sizeof(packet2));
4845 mavlink_msg_file_transfer_protocol_send(MAVLINK_COMM_1 , packet1.target_network , packet1.target_system , packet1.target_component , packet1.payload );
4846 mavlink_msg_file_transfer_protocol_decode(last_msg, &packet2);
4847 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4848}
4849
4850static void mavlink_test_timesync(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4851{
4852#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4853 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4854 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_TIMESYNC >= 256) {
4855 return;
4856 }
4857#endif
4858 mavlink_message_t msg;
4859 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4860 uint16_t i;
4861 mavlink_timesync_t packet_in = {
4862 93372036854775807LL,93372036854776311LL
4863 };
4864 mavlink_timesync_t packet1, packet2;
4865 memset(&packet1, 0, sizeof(packet1));
4866 packet1.tc1 = packet_in.tc1;
4867 packet1.ts1 = packet_in.ts1;
4868
4869
4870#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4871 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4872 // cope with extensions
4873 memset(MAVLINK_MSG_ID_TIMESYNC_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_TIMESYNC_MIN_LEN);
4874 }
4875#endif
4876 memset(&packet2, 0, sizeof(packet2));
4877 mavlink_msg_timesync_encode(system_id, component_id, &msg, &packet1);
4878 mavlink_msg_timesync_decode(&msg, &packet2);
4879 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4880
4881 memset(&packet2, 0, sizeof(packet2));
4882 mavlink_msg_timesync_pack(system_id, component_id, &msg , packet1.tc1 , packet1.ts1 );
4883 mavlink_msg_timesync_decode(&msg, &packet2);
4884 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4885
4886 memset(&packet2, 0, sizeof(packet2));
4887 mavlink_msg_timesync_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.tc1 , packet1.ts1 );
4888 mavlink_msg_timesync_decode(&msg, &packet2);
4889 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4890
4891 memset(&packet2, 0, sizeof(packet2));
4892 mavlink_msg_to_send_buffer(buffer, &msg);
4893 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4894 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4895 }
4896 mavlink_msg_timesync_decode(last_msg, &packet2);
4897 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4898
4899 memset(&packet2, 0, sizeof(packet2));
4900 mavlink_msg_timesync_send(MAVLINK_COMM_1 , packet1.tc1 , packet1.ts1 );
4901 mavlink_msg_timesync_decode(last_msg, &packet2);
4902 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4903}
4904
4905static void mavlink_test_camera_trigger(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4906{
4907#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4908 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4909 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_CAMERA_TRIGGER >= 256) {
4910 return;
4911 }
4912#endif
4913 mavlink_message_t msg;
4914 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4915 uint16_t i;
4916 mavlink_camera_trigger_t packet_in = {
4917 93372036854775807ULL,963497880
4918 };
4919 mavlink_camera_trigger_t packet1, packet2;
4920 memset(&packet1, 0, sizeof(packet1));
4921 packet1.time_usec = packet_in.time_usec;
4922 packet1.seq = packet_in.seq;
4923
4924
4925#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4926 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4927 // cope with extensions
4928 memset(MAVLINK_MSG_ID_CAMERA_TRIGGER_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CAMERA_TRIGGER_MIN_LEN);
4929 }
4930#endif
4931 memset(&packet2, 0, sizeof(packet2));
4932 mavlink_msg_camera_trigger_encode(system_id, component_id, &msg, &packet1);
4933 mavlink_msg_camera_trigger_decode(&msg, &packet2);
4934 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4935
4936 memset(&packet2, 0, sizeof(packet2));
4937 mavlink_msg_camera_trigger_pack(system_id, component_id, &msg , packet1.time_usec , packet1.seq );
4938 mavlink_msg_camera_trigger_decode(&msg, &packet2);
4939 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4940
4941 memset(&packet2, 0, sizeof(packet2));
4942 mavlink_msg_camera_trigger_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.seq );
4943 mavlink_msg_camera_trigger_decode(&msg, &packet2);
4944 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4945
4946 memset(&packet2, 0, sizeof(packet2));
4947 mavlink_msg_to_send_buffer(buffer, &msg);
4948 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
4949 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
4950 }
4951 mavlink_msg_camera_trigger_decode(last_msg, &packet2);
4952 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4953
4954 memset(&packet2, 0, sizeof(packet2));
4955 mavlink_msg_camera_trigger_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.seq );
4956 mavlink_msg_camera_trigger_decode(last_msg, &packet2);
4957 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
4958}
4959
4960static void mavlink_test_hil_gps(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
4961{
4962#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4963 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
4964 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HIL_GPS >= 256) {
4965 return;
4966 }
4967#endif
4968 mavlink_message_t msg;
4969 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
4970 uint16_t i;
4971 mavlink_hil_gps_t packet_in = {
4972 93372036854775807ULL,963497880,963498088,963498296,18275,18379,18483,18587,18691,18795,18899,235,46
4973 };
4974 mavlink_hil_gps_t packet1, packet2;
4975 memset(&packet1, 0, sizeof(packet1));
4976 packet1.time_usec = packet_in.time_usec;
4977 packet1.lat = packet_in.lat;
4978 packet1.lon = packet_in.lon;
4979 packet1.alt = packet_in.alt;
4980 packet1.eph = packet_in.eph;
4981 packet1.epv = packet_in.epv;
4982 packet1.vel = packet_in.vel;
4983 packet1.vn = packet_in.vn;
4984 packet1.ve = packet_in.ve;
4985 packet1.vd = packet_in.vd;
4986 packet1.cog = packet_in.cog;
4987 packet1.fix_type = packet_in.fix_type;
4988 packet1.satellites_visible = packet_in.satellites_visible;
4989
4990
4991#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
4992 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
4993 // cope with extensions
4994 memset(MAVLINK_MSG_ID_HIL_GPS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HIL_GPS_MIN_LEN);
4995 }
4996#endif
4997 memset(&packet2, 0, sizeof(packet2));
4998 mavlink_msg_hil_gps_encode(system_id, component_id, &msg, &packet1);
4999 mavlink_msg_hil_gps_decode(&msg, &packet2);
5000 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5001
5002 memset(&packet2, 0, sizeof(packet2));
5003 mavlink_msg_hil_gps_pack(system_id, component_id, &msg , packet1.time_usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.vel , packet1.vn , packet1.ve , packet1.vd , packet1.cog , packet1.satellites_visible );
5004 mavlink_msg_hil_gps_decode(&msg, &packet2);
5005 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5006
5007 memset(&packet2, 0, sizeof(packet2));
5008 mavlink_msg_hil_gps_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.vel , packet1.vn , packet1.ve , packet1.vd , packet1.cog , packet1.satellites_visible );
5009 mavlink_msg_hil_gps_decode(&msg, &packet2);
5010 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5011
5012 memset(&packet2, 0, sizeof(packet2));
5013 mavlink_msg_to_send_buffer(buffer, &msg);
5014 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5015 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5016 }
5017 mavlink_msg_hil_gps_decode(last_msg, &packet2);
5018 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5019
5020 memset(&packet2, 0, sizeof(packet2));
5021 mavlink_msg_hil_gps_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.vel , packet1.vn , packet1.ve , packet1.vd , packet1.cog , packet1.satellites_visible );
5022 mavlink_msg_hil_gps_decode(last_msg, &packet2);
5023 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5024}
5025
5026static void mavlink_test_hil_optical_flow(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5027{
5028#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5029 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5030 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HIL_OPTICAL_FLOW >= 256) {
5031 return;
5032 }
5033#endif
5034 mavlink_message_t msg;
5035 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5036 uint16_t i;
5037 mavlink_hil_optical_flow_t packet_in = {
5038 93372036854775807ULL,963497880,101.0,129.0,157.0,185.0,213.0,963499128,269.0,19315,3,70
5039 };
5040 mavlink_hil_optical_flow_t packet1, packet2;
5041 memset(&packet1, 0, sizeof(packet1));
5042 packet1.time_usec = packet_in.time_usec;
5043 packet1.integration_time_us = packet_in.integration_time_us;
5044 packet1.integrated_x = packet_in.integrated_x;
5045 packet1.integrated_y = packet_in.integrated_y;
5046 packet1.integrated_xgyro = packet_in.integrated_xgyro;
5047 packet1.integrated_ygyro = packet_in.integrated_ygyro;
5048 packet1.integrated_zgyro = packet_in.integrated_zgyro;
5049 packet1.time_delta_distance_us = packet_in.time_delta_distance_us;
5050 packet1.distance = packet_in.distance;
5051 packet1.temperature = packet_in.temperature;
5052 packet1.sensor_id = packet_in.sensor_id;
5053 packet1.quality = packet_in.quality;
5054
5055
5056#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5057 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5058 // cope with extensions
5059 memset(MAVLINK_MSG_ID_HIL_OPTICAL_FLOW_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HIL_OPTICAL_FLOW_MIN_LEN);
5060 }
5061#endif
5062 memset(&packet2, 0, sizeof(packet2));
5063 mavlink_msg_hil_optical_flow_encode(system_id, component_id, &msg, &packet1);
5064 mavlink_msg_hil_optical_flow_decode(&msg, &packet2);
5065 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5066
5067 memset(&packet2, 0, sizeof(packet2));
5068 mavlink_msg_hil_optical_flow_pack(system_id, component_id, &msg , packet1.time_usec , packet1.sensor_id , packet1.integration_time_us , packet1.integrated_x , packet1.integrated_y , packet1.integrated_xgyro , packet1.integrated_ygyro , packet1.integrated_zgyro , packet1.temperature , packet1.quality , packet1.time_delta_distance_us , packet1.distance );
5069 mavlink_msg_hil_optical_flow_decode(&msg, &packet2);
5070 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5071
5072 memset(&packet2, 0, sizeof(packet2));
5073 mavlink_msg_hil_optical_flow_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.sensor_id , packet1.integration_time_us , packet1.integrated_x , packet1.integrated_y , packet1.integrated_xgyro , packet1.integrated_ygyro , packet1.integrated_zgyro , packet1.temperature , packet1.quality , packet1.time_delta_distance_us , packet1.distance );
5074 mavlink_msg_hil_optical_flow_decode(&msg, &packet2);
5075 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5076
5077 memset(&packet2, 0, sizeof(packet2));
5078 mavlink_msg_to_send_buffer(buffer, &msg);
5079 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5080 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5081 }
5082 mavlink_msg_hil_optical_flow_decode(last_msg, &packet2);
5083 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5084
5085 memset(&packet2, 0, sizeof(packet2));
5086 mavlink_msg_hil_optical_flow_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.sensor_id , packet1.integration_time_us , packet1.integrated_x , packet1.integrated_y , packet1.integrated_xgyro , packet1.integrated_ygyro , packet1.integrated_zgyro , packet1.temperature , packet1.quality , packet1.time_delta_distance_us , packet1.distance );
5087 mavlink_msg_hil_optical_flow_decode(last_msg, &packet2);
5088 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5089}
5090
5091static void mavlink_test_hil_state_quaternion(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5092{
5093#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5094 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5095 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HIL_STATE_QUATERNION >= 256) {
5096 return;
5097 }
5098#endif
5099 mavlink_message_t msg;
5100 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5101 uint16_t i;
5102 mavlink_hil_state_quaternion_t packet_in = {
5103 93372036854775807ULL,{ 73.0, 74.0, 75.0, 76.0 },185.0,213.0,241.0,963499336,963499544,963499752,19731,19835,19939,20043,20147,20251,20355,20459
5104 };
5105 mavlink_hil_state_quaternion_t packet1, packet2;
5106 memset(&packet1, 0, sizeof(packet1));
5107 packet1.time_usec = packet_in.time_usec;
5108 packet1.rollspeed = packet_in.rollspeed;
5109 packet1.pitchspeed = packet_in.pitchspeed;
5110 packet1.yawspeed = packet_in.yawspeed;
5111 packet1.lat = packet_in.lat;
5112 packet1.lon = packet_in.lon;
5113 packet1.alt = packet_in.alt;
5114 packet1.vx = packet_in.vx;
5115 packet1.vy = packet_in.vy;
5116 packet1.vz = packet_in.vz;
5117 packet1.ind_airspeed = packet_in.ind_airspeed;
5118 packet1.true_airspeed = packet_in.true_airspeed;
5119 packet1.xacc = packet_in.xacc;
5120 packet1.yacc = packet_in.yacc;
5121 packet1.zacc = packet_in.zacc;
5122
5123 mav_array_memcpy(packet1.attitude_quaternion, packet_in.attitude_quaternion, sizeof(float)*4);
5124
5125#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5126 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5127 // cope with extensions
5128 memset(MAVLINK_MSG_ID_HIL_STATE_QUATERNION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HIL_STATE_QUATERNION_MIN_LEN);
5129 }
5130#endif
5131 memset(&packet2, 0, sizeof(packet2));
5132 mavlink_msg_hil_state_quaternion_encode(system_id, component_id, &msg, &packet1);
5133 mavlink_msg_hil_state_quaternion_decode(&msg, &packet2);
5134 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5135
5136 memset(&packet2, 0, sizeof(packet2));
5137 mavlink_msg_hil_state_quaternion_pack(system_id, component_id, &msg , packet1.time_usec , packet1.attitude_quaternion , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.ind_airspeed , packet1.true_airspeed , packet1.xacc , packet1.yacc , packet1.zacc );
5138 mavlink_msg_hil_state_quaternion_decode(&msg, &packet2);
5139 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5140
5141 memset(&packet2, 0, sizeof(packet2));
5142 mavlink_msg_hil_state_quaternion_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.attitude_quaternion , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.ind_airspeed , packet1.true_airspeed , packet1.xacc , packet1.yacc , packet1.zacc );
5143 mavlink_msg_hil_state_quaternion_decode(&msg, &packet2);
5144 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5145
5146 memset(&packet2, 0, sizeof(packet2));
5147 mavlink_msg_to_send_buffer(buffer, &msg);
5148 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5149 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5150 }
5151 mavlink_msg_hil_state_quaternion_decode(last_msg, &packet2);
5152 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5153
5154 memset(&packet2, 0, sizeof(packet2));
5155 mavlink_msg_hil_state_quaternion_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.attitude_quaternion , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz , packet1.ind_airspeed , packet1.true_airspeed , packet1.xacc , packet1.yacc , packet1.zacc );
5156 mavlink_msg_hil_state_quaternion_decode(last_msg, &packet2);
5157 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5158}
5159
5160static void mavlink_test_scaled_imu2(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5161{
5162#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5163 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5164 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SCALED_IMU2 >= 256) {
5165 return;
5166 }
5167#endif
5168 mavlink_message_t msg;
5169 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5170 uint16_t i;
5171 mavlink_scaled_imu2_t packet_in = {
5172 963497464,17443,17547,17651,17755,17859,17963,18067,18171,18275
5173 };
5174 mavlink_scaled_imu2_t packet1, packet2;
5175 memset(&packet1, 0, sizeof(packet1));
5176 packet1.time_boot_ms = packet_in.time_boot_ms;
5177 packet1.xacc = packet_in.xacc;
5178 packet1.yacc = packet_in.yacc;
5179 packet1.zacc = packet_in.zacc;
5180 packet1.xgyro = packet_in.xgyro;
5181 packet1.ygyro = packet_in.ygyro;
5182 packet1.zgyro = packet_in.zgyro;
5183 packet1.xmag = packet_in.xmag;
5184 packet1.ymag = packet_in.ymag;
5185 packet1.zmag = packet_in.zmag;
5186
5187
5188#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5189 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5190 // cope with extensions
5191 memset(MAVLINK_MSG_ID_SCALED_IMU2_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SCALED_IMU2_MIN_LEN);
5192 }
5193#endif
5194 memset(&packet2, 0, sizeof(packet2));
5195 mavlink_msg_scaled_imu2_encode(system_id, component_id, &msg, &packet1);
5196 mavlink_msg_scaled_imu2_decode(&msg, &packet2);
5197 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5198
5199 memset(&packet2, 0, sizeof(packet2));
5200 mavlink_msg_scaled_imu2_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
5201 mavlink_msg_scaled_imu2_decode(&msg, &packet2);
5202 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5203
5204 memset(&packet2, 0, sizeof(packet2));
5205 mavlink_msg_scaled_imu2_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
5206 mavlink_msg_scaled_imu2_decode(&msg, &packet2);
5207 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5208
5209 memset(&packet2, 0, sizeof(packet2));
5210 mavlink_msg_to_send_buffer(buffer, &msg);
5211 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5212 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5213 }
5214 mavlink_msg_scaled_imu2_decode(last_msg, &packet2);
5215 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5216
5217 memset(&packet2, 0, sizeof(packet2));
5218 mavlink_msg_scaled_imu2_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
5219 mavlink_msg_scaled_imu2_decode(last_msg, &packet2);
5220 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5221}
5222
5223static void mavlink_test_log_request_list(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5224{
5225#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5226 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5227 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOG_REQUEST_LIST >= 256) {
5228 return;
5229 }
5230#endif
5231 mavlink_message_t msg;
5232 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5233 uint16_t i;
5234 mavlink_log_request_list_t packet_in = {
5235 17235,17339,17,84
5236 };
5237 mavlink_log_request_list_t packet1, packet2;
5238 memset(&packet1, 0, sizeof(packet1));
5239 packet1.start = packet_in.start;
5240 packet1.end = packet_in.end;
5241 packet1.target_system = packet_in.target_system;
5242 packet1.target_component = packet_in.target_component;
5243
5244
5245#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5246 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5247 // cope with extensions
5248 memset(MAVLINK_MSG_ID_LOG_REQUEST_LIST_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOG_REQUEST_LIST_MIN_LEN);
5249 }
5250#endif
5251 memset(&packet2, 0, sizeof(packet2));
5252 mavlink_msg_log_request_list_encode(system_id, component_id, &msg, &packet1);
5253 mavlink_msg_log_request_list_decode(&msg, &packet2);
5254 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5255
5256 memset(&packet2, 0, sizeof(packet2));
5257 mavlink_msg_log_request_list_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.start , packet1.end );
5258 mavlink_msg_log_request_list_decode(&msg, &packet2);
5259 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5260
5261 memset(&packet2, 0, sizeof(packet2));
5262 mavlink_msg_log_request_list_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.start , packet1.end );
5263 mavlink_msg_log_request_list_decode(&msg, &packet2);
5264 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5265
5266 memset(&packet2, 0, sizeof(packet2));
5267 mavlink_msg_to_send_buffer(buffer, &msg);
5268 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5269 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5270 }
5271 mavlink_msg_log_request_list_decode(last_msg, &packet2);
5272 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5273
5274 memset(&packet2, 0, sizeof(packet2));
5275 mavlink_msg_log_request_list_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.start , packet1.end );
5276 mavlink_msg_log_request_list_decode(last_msg, &packet2);
5277 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5278}
5279
5280static void mavlink_test_log_entry(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5281{
5282#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5283 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5284 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOG_ENTRY >= 256) {
5285 return;
5286 }
5287#endif
5288 mavlink_message_t msg;
5289 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5290 uint16_t i;
5291 mavlink_log_entry_t packet_in = {
5292 963497464,963497672,17651,17755,17859
5293 };
5294 mavlink_log_entry_t packet1, packet2;
5295 memset(&packet1, 0, sizeof(packet1));
5296 packet1.time_utc = packet_in.time_utc;
5297 packet1.size = packet_in.size;
5298 packet1.id = packet_in.id;
5299 packet1.num_logs = packet_in.num_logs;
5300 packet1.last_log_num = packet_in.last_log_num;
5301
5302
5303#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5304 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5305 // cope with extensions
5306 memset(MAVLINK_MSG_ID_LOG_ENTRY_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOG_ENTRY_MIN_LEN);
5307 }
5308#endif
5309 memset(&packet2, 0, sizeof(packet2));
5310 mavlink_msg_log_entry_encode(system_id, component_id, &msg, &packet1);
5311 mavlink_msg_log_entry_decode(&msg, &packet2);
5312 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5313
5314 memset(&packet2, 0, sizeof(packet2));
5315 mavlink_msg_log_entry_pack(system_id, component_id, &msg , packet1.id , packet1.num_logs , packet1.last_log_num , packet1.time_utc , packet1.size );
5316 mavlink_msg_log_entry_decode(&msg, &packet2);
5317 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5318
5319 memset(&packet2, 0, sizeof(packet2));
5320 mavlink_msg_log_entry_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.id , packet1.num_logs , packet1.last_log_num , packet1.time_utc , packet1.size );
5321 mavlink_msg_log_entry_decode(&msg, &packet2);
5322 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5323
5324 memset(&packet2, 0, sizeof(packet2));
5325 mavlink_msg_to_send_buffer(buffer, &msg);
5326 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5327 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5328 }
5329 mavlink_msg_log_entry_decode(last_msg, &packet2);
5330 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5331
5332 memset(&packet2, 0, sizeof(packet2));
5333 mavlink_msg_log_entry_send(MAVLINK_COMM_1 , packet1.id , packet1.num_logs , packet1.last_log_num , packet1.time_utc , packet1.size );
5334 mavlink_msg_log_entry_decode(last_msg, &packet2);
5335 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5336}
5337
5338static void mavlink_test_log_request_data(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5339{
5340#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5341 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5342 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOG_REQUEST_DATA >= 256) {
5343 return;
5344 }
5345#endif
5346 mavlink_message_t msg;
5347 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5348 uint16_t i;
5349 mavlink_log_request_data_t packet_in = {
5350 963497464,963497672,17651,163,230
5351 };
5352 mavlink_log_request_data_t packet1, packet2;
5353 memset(&packet1, 0, sizeof(packet1));
5354 packet1.ofs = packet_in.ofs;
5355 packet1.count = packet_in.count;
5356 packet1.id = packet_in.id;
5357 packet1.target_system = packet_in.target_system;
5358 packet1.target_component = packet_in.target_component;
5359
5360
5361#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5362 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5363 // cope with extensions
5364 memset(MAVLINK_MSG_ID_LOG_REQUEST_DATA_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOG_REQUEST_DATA_MIN_LEN);
5365 }
5366#endif
5367 memset(&packet2, 0, sizeof(packet2));
5368 mavlink_msg_log_request_data_encode(system_id, component_id, &msg, &packet1);
5369 mavlink_msg_log_request_data_decode(&msg, &packet2);
5370 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5371
5372 memset(&packet2, 0, sizeof(packet2));
5373 mavlink_msg_log_request_data_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.id , packet1.ofs , packet1.count );
5374 mavlink_msg_log_request_data_decode(&msg, &packet2);
5375 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5376
5377 memset(&packet2, 0, sizeof(packet2));
5378 mavlink_msg_log_request_data_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.id , packet1.ofs , packet1.count );
5379 mavlink_msg_log_request_data_decode(&msg, &packet2);
5380 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5381
5382 memset(&packet2, 0, sizeof(packet2));
5383 mavlink_msg_to_send_buffer(buffer, &msg);
5384 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5385 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5386 }
5387 mavlink_msg_log_request_data_decode(last_msg, &packet2);
5388 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5389
5390 memset(&packet2, 0, sizeof(packet2));
5391 mavlink_msg_log_request_data_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.id , packet1.ofs , packet1.count );
5392 mavlink_msg_log_request_data_decode(last_msg, &packet2);
5393 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5394}
5395
5396static void mavlink_test_log_data(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5397{
5398#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5399 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5400 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOG_DATA >= 256) {
5401 return;
5402 }
5403#endif
5404 mavlink_message_t msg;
5405 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5406 uint16_t i;
5407 mavlink_log_data_t packet_in = {
5408 963497464,17443,151,{ 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 }
5409 };
5410 mavlink_log_data_t packet1, packet2;
5411 memset(&packet1, 0, sizeof(packet1));
5412 packet1.ofs = packet_in.ofs;
5413 packet1.id = packet_in.id;
5414 packet1.count = packet_in.count;
5415
5416 mav_array_memcpy(packet1.data, packet_in.data, sizeof(uint8_t)*90);
5417
5418#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5419 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5420 // cope with extensions
5421 memset(MAVLINK_MSG_ID_LOG_DATA_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOG_DATA_MIN_LEN);
5422 }
5423#endif
5424 memset(&packet2, 0, sizeof(packet2));
5425 mavlink_msg_log_data_encode(system_id, component_id, &msg, &packet1);
5426 mavlink_msg_log_data_decode(&msg, &packet2);
5427 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5428
5429 memset(&packet2, 0, sizeof(packet2));
5430 mavlink_msg_log_data_pack(system_id, component_id, &msg , packet1.id , packet1.ofs , packet1.count , packet1.data );
5431 mavlink_msg_log_data_decode(&msg, &packet2);
5432 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5433
5434 memset(&packet2, 0, sizeof(packet2));
5435 mavlink_msg_log_data_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.id , packet1.ofs , packet1.count , packet1.data );
5436 mavlink_msg_log_data_decode(&msg, &packet2);
5437 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5438
5439 memset(&packet2, 0, sizeof(packet2));
5440 mavlink_msg_to_send_buffer(buffer, &msg);
5441 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5442 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5443 }
5444 mavlink_msg_log_data_decode(last_msg, &packet2);
5445 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5446
5447 memset(&packet2, 0, sizeof(packet2));
5448 mavlink_msg_log_data_send(MAVLINK_COMM_1 , packet1.id , packet1.ofs , packet1.count , packet1.data );
5449 mavlink_msg_log_data_decode(last_msg, &packet2);
5450 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5451}
5452
5453static void mavlink_test_log_erase(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5454{
5455#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5456 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5457 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOG_ERASE >= 256) {
5458 return;
5459 }
5460#endif
5461 mavlink_message_t msg;
5462 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5463 uint16_t i;
5464 mavlink_log_erase_t packet_in = {
5465 5,72
5466 };
5467 mavlink_log_erase_t packet1, packet2;
5468 memset(&packet1, 0, sizeof(packet1));
5469 packet1.target_system = packet_in.target_system;
5470 packet1.target_component = packet_in.target_component;
5471
5472
5473#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5474 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5475 // cope with extensions
5476 memset(MAVLINK_MSG_ID_LOG_ERASE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOG_ERASE_MIN_LEN);
5477 }
5478#endif
5479 memset(&packet2, 0, sizeof(packet2));
5480 mavlink_msg_log_erase_encode(system_id, component_id, &msg, &packet1);
5481 mavlink_msg_log_erase_decode(&msg, &packet2);
5482 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5483
5484 memset(&packet2, 0, sizeof(packet2));
5485 mavlink_msg_log_erase_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component );
5486 mavlink_msg_log_erase_decode(&msg, &packet2);
5487 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5488
5489 memset(&packet2, 0, sizeof(packet2));
5490 mavlink_msg_log_erase_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component );
5491 mavlink_msg_log_erase_decode(&msg, &packet2);
5492 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5493
5494 memset(&packet2, 0, sizeof(packet2));
5495 mavlink_msg_to_send_buffer(buffer, &msg);
5496 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5497 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5498 }
5499 mavlink_msg_log_erase_decode(last_msg, &packet2);
5500 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5501
5502 memset(&packet2, 0, sizeof(packet2));
5503 mavlink_msg_log_erase_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component );
5504 mavlink_msg_log_erase_decode(last_msg, &packet2);
5505 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5506}
5507
5508static void mavlink_test_log_request_end(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5509{
5510#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5511 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5512 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOG_REQUEST_END >= 256) {
5513 return;
5514 }
5515#endif
5516 mavlink_message_t msg;
5517 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5518 uint16_t i;
5519 mavlink_log_request_end_t packet_in = {
5520 5,72
5521 };
5522 mavlink_log_request_end_t packet1, packet2;
5523 memset(&packet1, 0, sizeof(packet1));
5524 packet1.target_system = packet_in.target_system;
5525 packet1.target_component = packet_in.target_component;
5526
5527
5528#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5529 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5530 // cope with extensions
5531 memset(MAVLINK_MSG_ID_LOG_REQUEST_END_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOG_REQUEST_END_MIN_LEN);
5532 }
5533#endif
5534 memset(&packet2, 0, sizeof(packet2));
5535 mavlink_msg_log_request_end_encode(system_id, component_id, &msg, &packet1);
5536 mavlink_msg_log_request_end_decode(&msg, &packet2);
5537 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5538
5539 memset(&packet2, 0, sizeof(packet2));
5540 mavlink_msg_log_request_end_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component );
5541 mavlink_msg_log_request_end_decode(&msg, &packet2);
5542 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5543
5544 memset(&packet2, 0, sizeof(packet2));
5545 mavlink_msg_log_request_end_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component );
5546 mavlink_msg_log_request_end_decode(&msg, &packet2);
5547 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5548
5549 memset(&packet2, 0, sizeof(packet2));
5550 mavlink_msg_to_send_buffer(buffer, &msg);
5551 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5552 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5553 }
5554 mavlink_msg_log_request_end_decode(last_msg, &packet2);
5555 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5556
5557 memset(&packet2, 0, sizeof(packet2));
5558 mavlink_msg_log_request_end_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component );
5559 mavlink_msg_log_request_end_decode(last_msg, &packet2);
5560 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5561}
5562
5563static void mavlink_test_gps_inject_data(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5564{
5565#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5566 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5567 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GPS_INJECT_DATA >= 256) {
5568 return;
5569 }
5570#endif
5571 mavlink_message_t msg;
5572 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5573 uint16_t i;
5574 mavlink_gps_inject_data_t packet_in = {
5575 5,72,139,{ 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59 }
5576 };
5577 mavlink_gps_inject_data_t packet1, packet2;
5578 memset(&packet1, 0, sizeof(packet1));
5579 packet1.target_system = packet_in.target_system;
5580 packet1.target_component = packet_in.target_component;
5581 packet1.len = packet_in.len;
5582
5583 mav_array_memcpy(packet1.data, packet_in.data, sizeof(uint8_t)*110);
5584
5585#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5586 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5587 // cope with extensions
5588 memset(MAVLINK_MSG_ID_GPS_INJECT_DATA_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GPS_INJECT_DATA_MIN_LEN);
5589 }
5590#endif
5591 memset(&packet2, 0, sizeof(packet2));
5592 mavlink_msg_gps_inject_data_encode(system_id, component_id, &msg, &packet1);
5593 mavlink_msg_gps_inject_data_decode(&msg, &packet2);
5594 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5595
5596 memset(&packet2, 0, sizeof(packet2));
5597 mavlink_msg_gps_inject_data_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.len , packet1.data );
5598 mavlink_msg_gps_inject_data_decode(&msg, &packet2);
5599 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5600
5601 memset(&packet2, 0, sizeof(packet2));
5602 mavlink_msg_gps_inject_data_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.len , packet1.data );
5603 mavlink_msg_gps_inject_data_decode(&msg, &packet2);
5604 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5605
5606 memset(&packet2, 0, sizeof(packet2));
5607 mavlink_msg_to_send_buffer(buffer, &msg);
5608 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5609 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5610 }
5611 mavlink_msg_gps_inject_data_decode(last_msg, &packet2);
5612 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5613
5614 memset(&packet2, 0, sizeof(packet2));
5615 mavlink_msg_gps_inject_data_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.len , packet1.data );
5616 mavlink_msg_gps_inject_data_decode(last_msg, &packet2);
5617 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5618}
5619
5620static void mavlink_test_gps2_raw(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5621{
5622#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5623 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5624 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GPS2_RAW >= 256) {
5625 return;
5626 }
5627#endif
5628 mavlink_message_t msg;
5629 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5630 uint16_t i;
5631 mavlink_gps2_raw_t packet_in = {
5632 93372036854775807ULL,963497880,963498088,963498296,963498504,18483,18587,18691,18795,101,168,235
5633 };
5634 mavlink_gps2_raw_t packet1, packet2;
5635 memset(&packet1, 0, sizeof(packet1));
5636 packet1.time_usec = packet_in.time_usec;
5637 packet1.lat = packet_in.lat;
5638 packet1.lon = packet_in.lon;
5639 packet1.alt = packet_in.alt;
5640 packet1.dgps_age = packet_in.dgps_age;
5641 packet1.eph = packet_in.eph;
5642 packet1.epv = packet_in.epv;
5643 packet1.vel = packet_in.vel;
5644 packet1.cog = packet_in.cog;
5645 packet1.fix_type = packet_in.fix_type;
5646 packet1.satellites_visible = packet_in.satellites_visible;
5647 packet1.dgps_numch = packet_in.dgps_numch;
5648
5649
5650#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5651 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5652 // cope with extensions
5653 memset(MAVLINK_MSG_ID_GPS2_RAW_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GPS2_RAW_MIN_LEN);
5654 }
5655#endif
5656 memset(&packet2, 0, sizeof(packet2));
5657 mavlink_msg_gps2_raw_encode(system_id, component_id, &msg, &packet1);
5658 mavlink_msg_gps2_raw_decode(&msg, &packet2);
5659 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5660
5661 memset(&packet2, 0, sizeof(packet2));
5662 mavlink_msg_gps2_raw_pack(system_id, component_id, &msg , packet1.time_usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.vel , packet1.cog , packet1.satellites_visible , packet1.dgps_numch , packet1.dgps_age );
5663 mavlink_msg_gps2_raw_decode(&msg, &packet2);
5664 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5665
5666 memset(&packet2, 0, sizeof(packet2));
5667 mavlink_msg_gps2_raw_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.vel , packet1.cog , packet1.satellites_visible , packet1.dgps_numch , packet1.dgps_age );
5668 mavlink_msg_gps2_raw_decode(&msg, &packet2);
5669 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5670
5671 memset(&packet2, 0, sizeof(packet2));
5672 mavlink_msg_to_send_buffer(buffer, &msg);
5673 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5674 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5675 }
5676 mavlink_msg_gps2_raw_decode(last_msg, &packet2);
5677 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5678
5679 memset(&packet2, 0, sizeof(packet2));
5680 mavlink_msg_gps2_raw_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.vel , packet1.cog , packet1.satellites_visible , packet1.dgps_numch , packet1.dgps_age );
5681 mavlink_msg_gps2_raw_decode(last_msg, &packet2);
5682 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5683}
5684
5685static void mavlink_test_power_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5686{
5687#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5688 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5689 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_POWER_STATUS >= 256) {
5690 return;
5691 }
5692#endif
5693 mavlink_message_t msg;
5694 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5695 uint16_t i;
5696 mavlink_power_status_t packet_in = {
5697 17235,17339,17443
5698 };
5699 mavlink_power_status_t packet1, packet2;
5700 memset(&packet1, 0, sizeof(packet1));
5701 packet1.Vcc = packet_in.Vcc;
5702 packet1.Vservo = packet_in.Vservo;
5703 packet1.flags = packet_in.flags;
5704
5705
5706#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5707 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5708 // cope with extensions
5709 memset(MAVLINK_MSG_ID_POWER_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_POWER_STATUS_MIN_LEN);
5710 }
5711#endif
5712 memset(&packet2, 0, sizeof(packet2));
5713 mavlink_msg_power_status_encode(system_id, component_id, &msg, &packet1);
5714 mavlink_msg_power_status_decode(&msg, &packet2);
5715 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5716
5717 memset(&packet2, 0, sizeof(packet2));
5718 mavlink_msg_power_status_pack(system_id, component_id, &msg , packet1.Vcc , packet1.Vservo , packet1.flags );
5719 mavlink_msg_power_status_decode(&msg, &packet2);
5720 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5721
5722 memset(&packet2, 0, sizeof(packet2));
5723 mavlink_msg_power_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.Vcc , packet1.Vservo , packet1.flags );
5724 mavlink_msg_power_status_decode(&msg, &packet2);
5725 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5726
5727 memset(&packet2, 0, sizeof(packet2));
5728 mavlink_msg_to_send_buffer(buffer, &msg);
5729 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5730 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5731 }
5732 mavlink_msg_power_status_decode(last_msg, &packet2);
5733 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5734
5735 memset(&packet2, 0, sizeof(packet2));
5736 mavlink_msg_power_status_send(MAVLINK_COMM_1 , packet1.Vcc , packet1.Vservo , packet1.flags );
5737 mavlink_msg_power_status_decode(last_msg, &packet2);
5738 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5739}
5740
5741static void mavlink_test_serial_control(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5742{
5743#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5744 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5745 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SERIAL_CONTROL >= 256) {
5746 return;
5747 }
5748#endif
5749 mavlink_message_t msg;
5750 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5751 uint16_t i;
5752 mavlink_serial_control_t packet_in = {
5753 963497464,17443,151,218,29,{ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165 }
5754 };
5755 mavlink_serial_control_t packet1, packet2;
5756 memset(&packet1, 0, sizeof(packet1));
5757 packet1.baudrate = packet_in.baudrate;
5758 packet1.timeout = packet_in.timeout;
5759 packet1.device = packet_in.device;
5760 packet1.flags = packet_in.flags;
5761 packet1.count = packet_in.count;
5762
5763 mav_array_memcpy(packet1.data, packet_in.data, sizeof(uint8_t)*70);
5764
5765#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5766 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5767 // cope with extensions
5768 memset(MAVLINK_MSG_ID_SERIAL_CONTROL_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SERIAL_CONTROL_MIN_LEN);
5769 }
5770#endif
5771 memset(&packet2, 0, sizeof(packet2));
5772 mavlink_msg_serial_control_encode(system_id, component_id, &msg, &packet1);
5773 mavlink_msg_serial_control_decode(&msg, &packet2);
5774 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5775
5776 memset(&packet2, 0, sizeof(packet2));
5777 mavlink_msg_serial_control_pack(system_id, component_id, &msg , packet1.device , packet1.flags , packet1.timeout , packet1.baudrate , packet1.count , packet1.data );
5778 mavlink_msg_serial_control_decode(&msg, &packet2);
5779 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5780
5781 memset(&packet2, 0, sizeof(packet2));
5782 mavlink_msg_serial_control_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.device , packet1.flags , packet1.timeout , packet1.baudrate , packet1.count , packet1.data );
5783 mavlink_msg_serial_control_decode(&msg, &packet2);
5784 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5785
5786 memset(&packet2, 0, sizeof(packet2));
5787 mavlink_msg_to_send_buffer(buffer, &msg);
5788 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5789 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5790 }
5791 mavlink_msg_serial_control_decode(last_msg, &packet2);
5792 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5793
5794 memset(&packet2, 0, sizeof(packet2));
5795 mavlink_msg_serial_control_send(MAVLINK_COMM_1 , packet1.device , packet1.flags , packet1.timeout , packet1.baudrate , packet1.count , packet1.data );
5796 mavlink_msg_serial_control_decode(last_msg, &packet2);
5797 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5798}
5799
5800static void mavlink_test_gps_rtk(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5801{
5802#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5803 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5804 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GPS_RTK >= 256) {
5805 return;
5806 }
5807#endif
5808 mavlink_message_t msg;
5809 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5810 uint16_t i;
5811 mavlink_gps_rtk_t packet_in = {
5812 963497464,963497672,963497880,963498088,963498296,963498504,963498712,18691,223,34,101,168,235
5813 };
5814 mavlink_gps_rtk_t packet1, packet2;
5815 memset(&packet1, 0, sizeof(packet1));
5816 packet1.time_last_baseline_ms = packet_in.time_last_baseline_ms;
5817 packet1.tow = packet_in.tow;
5818 packet1.baseline_a_mm = packet_in.baseline_a_mm;
5819 packet1.baseline_b_mm = packet_in.baseline_b_mm;
5820 packet1.baseline_c_mm = packet_in.baseline_c_mm;
5821 packet1.accuracy = packet_in.accuracy;
5822 packet1.iar_num_hypotheses = packet_in.iar_num_hypotheses;
5823 packet1.wn = packet_in.wn;
5824 packet1.rtk_receiver_id = packet_in.rtk_receiver_id;
5825 packet1.rtk_health = packet_in.rtk_health;
5826 packet1.rtk_rate = packet_in.rtk_rate;
5827 packet1.nsats = packet_in.nsats;
5828 packet1.baseline_coords_type = packet_in.baseline_coords_type;
5829
5830
5831#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5832 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5833 // cope with extensions
5834 memset(MAVLINK_MSG_ID_GPS_RTK_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GPS_RTK_MIN_LEN);
5835 }
5836#endif
5837 memset(&packet2, 0, sizeof(packet2));
5838 mavlink_msg_gps_rtk_encode(system_id, component_id, &msg, &packet1);
5839 mavlink_msg_gps_rtk_decode(&msg, &packet2);
5840 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5841
5842 memset(&packet2, 0, sizeof(packet2));
5843 mavlink_msg_gps_rtk_pack(system_id, component_id, &msg , packet1.time_last_baseline_ms , packet1.rtk_receiver_id , packet1.wn , packet1.tow , packet1.rtk_health , packet1.rtk_rate , packet1.nsats , packet1.baseline_coords_type , packet1.baseline_a_mm , packet1.baseline_b_mm , packet1.baseline_c_mm , packet1.accuracy , packet1.iar_num_hypotheses );
5844 mavlink_msg_gps_rtk_decode(&msg, &packet2);
5845 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5846
5847 memset(&packet2, 0, sizeof(packet2));
5848 mavlink_msg_gps_rtk_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_last_baseline_ms , packet1.rtk_receiver_id , packet1.wn , packet1.tow , packet1.rtk_health , packet1.rtk_rate , packet1.nsats , packet1.baseline_coords_type , packet1.baseline_a_mm , packet1.baseline_b_mm , packet1.baseline_c_mm , packet1.accuracy , packet1.iar_num_hypotheses );
5849 mavlink_msg_gps_rtk_decode(&msg, &packet2);
5850 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5851
5852 memset(&packet2, 0, sizeof(packet2));
5853 mavlink_msg_to_send_buffer(buffer, &msg);
5854 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5855 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5856 }
5857 mavlink_msg_gps_rtk_decode(last_msg, &packet2);
5858 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5859
5860 memset(&packet2, 0, sizeof(packet2));
5861 mavlink_msg_gps_rtk_send(MAVLINK_COMM_1 , packet1.time_last_baseline_ms , packet1.rtk_receiver_id , packet1.wn , packet1.tow , packet1.rtk_health , packet1.rtk_rate , packet1.nsats , packet1.baseline_coords_type , packet1.baseline_a_mm , packet1.baseline_b_mm , packet1.baseline_c_mm , packet1.accuracy , packet1.iar_num_hypotheses );
5862 mavlink_msg_gps_rtk_decode(last_msg, &packet2);
5863 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5864}
5865
5866static void mavlink_test_gps2_rtk(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5867{
5868#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5869 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5870 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GPS2_RTK >= 256) {
5871 return;
5872 }
5873#endif
5874 mavlink_message_t msg;
5875 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5876 uint16_t i;
5877 mavlink_gps2_rtk_t packet_in = {
5878 963497464,963497672,963497880,963498088,963498296,963498504,963498712,18691,223,34,101,168,235
5879 };
5880 mavlink_gps2_rtk_t packet1, packet2;
5881 memset(&packet1, 0, sizeof(packet1));
5882 packet1.time_last_baseline_ms = packet_in.time_last_baseline_ms;
5883 packet1.tow = packet_in.tow;
5884 packet1.baseline_a_mm = packet_in.baseline_a_mm;
5885 packet1.baseline_b_mm = packet_in.baseline_b_mm;
5886 packet1.baseline_c_mm = packet_in.baseline_c_mm;
5887 packet1.accuracy = packet_in.accuracy;
5888 packet1.iar_num_hypotheses = packet_in.iar_num_hypotheses;
5889 packet1.wn = packet_in.wn;
5890 packet1.rtk_receiver_id = packet_in.rtk_receiver_id;
5891 packet1.rtk_health = packet_in.rtk_health;
5892 packet1.rtk_rate = packet_in.rtk_rate;
5893 packet1.nsats = packet_in.nsats;
5894 packet1.baseline_coords_type = packet_in.baseline_coords_type;
5895
5896
5897#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5898 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5899 // cope with extensions
5900 memset(MAVLINK_MSG_ID_GPS2_RTK_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GPS2_RTK_MIN_LEN);
5901 }
5902#endif
5903 memset(&packet2, 0, sizeof(packet2));
5904 mavlink_msg_gps2_rtk_encode(system_id, component_id, &msg, &packet1);
5905 mavlink_msg_gps2_rtk_decode(&msg, &packet2);
5906 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5907
5908 memset(&packet2, 0, sizeof(packet2));
5909 mavlink_msg_gps2_rtk_pack(system_id, component_id, &msg , packet1.time_last_baseline_ms , packet1.rtk_receiver_id , packet1.wn , packet1.tow , packet1.rtk_health , packet1.rtk_rate , packet1.nsats , packet1.baseline_coords_type , packet1.baseline_a_mm , packet1.baseline_b_mm , packet1.baseline_c_mm , packet1.accuracy , packet1.iar_num_hypotheses );
5910 mavlink_msg_gps2_rtk_decode(&msg, &packet2);
5911 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5912
5913 memset(&packet2, 0, sizeof(packet2));
5914 mavlink_msg_gps2_rtk_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_last_baseline_ms , packet1.rtk_receiver_id , packet1.wn , packet1.tow , packet1.rtk_health , packet1.rtk_rate , packet1.nsats , packet1.baseline_coords_type , packet1.baseline_a_mm , packet1.baseline_b_mm , packet1.baseline_c_mm , packet1.accuracy , packet1.iar_num_hypotheses );
5915 mavlink_msg_gps2_rtk_decode(&msg, &packet2);
5916 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5917
5918 memset(&packet2, 0, sizeof(packet2));
5919 mavlink_msg_to_send_buffer(buffer, &msg);
5920 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5921 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5922 }
5923 mavlink_msg_gps2_rtk_decode(last_msg, &packet2);
5924 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5925
5926 memset(&packet2, 0, sizeof(packet2));
5927 mavlink_msg_gps2_rtk_send(MAVLINK_COMM_1 , packet1.time_last_baseline_ms , packet1.rtk_receiver_id , packet1.wn , packet1.tow , packet1.rtk_health , packet1.rtk_rate , packet1.nsats , packet1.baseline_coords_type , packet1.baseline_a_mm , packet1.baseline_b_mm , packet1.baseline_c_mm , packet1.accuracy , packet1.iar_num_hypotheses );
5928 mavlink_msg_gps2_rtk_decode(last_msg, &packet2);
5929 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5930}
5931
5932static void mavlink_test_scaled_imu3(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5933{
5934#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5935 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5936 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SCALED_IMU3 >= 256) {
5937 return;
5938 }
5939#endif
5940 mavlink_message_t msg;
5941 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
5942 uint16_t i;
5943 mavlink_scaled_imu3_t packet_in = {
5944 963497464,17443,17547,17651,17755,17859,17963,18067,18171,18275
5945 };
5946 mavlink_scaled_imu3_t packet1, packet2;
5947 memset(&packet1, 0, sizeof(packet1));
5948 packet1.time_boot_ms = packet_in.time_boot_ms;
5949 packet1.xacc = packet_in.xacc;
5950 packet1.yacc = packet_in.yacc;
5951 packet1.zacc = packet_in.zacc;
5952 packet1.xgyro = packet_in.xgyro;
5953 packet1.ygyro = packet_in.ygyro;
5954 packet1.zgyro = packet_in.zgyro;
5955 packet1.xmag = packet_in.xmag;
5956 packet1.ymag = packet_in.ymag;
5957 packet1.zmag = packet_in.zmag;
5958
5959
5960#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5961 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
5962 // cope with extensions
5963 memset(MAVLINK_MSG_ID_SCALED_IMU3_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SCALED_IMU3_MIN_LEN);
5964 }
5965#endif
5966 memset(&packet2, 0, sizeof(packet2));
5967 mavlink_msg_scaled_imu3_encode(system_id, component_id, &msg, &packet1);
5968 mavlink_msg_scaled_imu3_decode(&msg, &packet2);
5969 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5970
5971 memset(&packet2, 0, sizeof(packet2));
5972 mavlink_msg_scaled_imu3_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
5973 mavlink_msg_scaled_imu3_decode(&msg, &packet2);
5974 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5975
5976 memset(&packet2, 0, sizeof(packet2));
5977 mavlink_msg_scaled_imu3_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
5978 mavlink_msg_scaled_imu3_decode(&msg, &packet2);
5979 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5980
5981 memset(&packet2, 0, sizeof(packet2));
5982 mavlink_msg_to_send_buffer(buffer, &msg);
5983 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
5984 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
5985 }
5986 mavlink_msg_scaled_imu3_decode(last_msg, &packet2);
5987 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5988
5989 memset(&packet2, 0, sizeof(packet2));
5990 mavlink_msg_scaled_imu3_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
5991 mavlink_msg_scaled_imu3_decode(last_msg, &packet2);
5992 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
5993}
5994
5995static void mavlink_test_data_transmission_handshake(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
5996{
5997#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
5998 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
5999 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_DATA_TRANSMISSION_HANDSHAKE >= 256) {
6000 return;
6001 }
6002#endif
6003 mavlink_message_t msg;
6004 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6005 uint16_t i;
6006 mavlink_data_transmission_handshake_t packet_in = {
6007 963497464,17443,17547,17651,163,230,41
6008 };
6009 mavlink_data_transmission_handshake_t packet1, packet2;
6010 memset(&packet1, 0, sizeof(packet1));
6011 packet1.size = packet_in.size;
6012 packet1.width = packet_in.width;
6013 packet1.height = packet_in.height;
6014 packet1.packets = packet_in.packets;
6015 packet1.type = packet_in.type;
6016 packet1.payload = packet_in.payload;
6017 packet1.jpg_quality = packet_in.jpg_quality;
6018
6019
6020#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6021 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6022 // cope with extensions
6023 memset(MAVLINK_MSG_ID_DATA_TRANSMISSION_HANDSHAKE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_DATA_TRANSMISSION_HANDSHAKE_MIN_LEN);
6024 }
6025#endif
6026 memset(&packet2, 0, sizeof(packet2));
6027 mavlink_msg_data_transmission_handshake_encode(system_id, component_id, &msg, &packet1);
6028 mavlink_msg_data_transmission_handshake_decode(&msg, &packet2);
6029 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6030
6031 memset(&packet2, 0, sizeof(packet2));
6032 mavlink_msg_data_transmission_handshake_pack(system_id, component_id, &msg , packet1.type , packet1.size , packet1.width , packet1.height , packet1.packets , packet1.payload , packet1.jpg_quality );
6033 mavlink_msg_data_transmission_handshake_decode(&msg, &packet2);
6034 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6035
6036 memset(&packet2, 0, sizeof(packet2));
6037 mavlink_msg_data_transmission_handshake_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.type , packet1.size , packet1.width , packet1.height , packet1.packets , packet1.payload , packet1.jpg_quality );
6038 mavlink_msg_data_transmission_handshake_decode(&msg, &packet2);
6039 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6040
6041 memset(&packet2, 0, sizeof(packet2));
6042 mavlink_msg_to_send_buffer(buffer, &msg);
6043 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6044 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6045 }
6046 mavlink_msg_data_transmission_handshake_decode(last_msg, &packet2);
6047 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6048
6049 memset(&packet2, 0, sizeof(packet2));
6050 mavlink_msg_data_transmission_handshake_send(MAVLINK_COMM_1 , packet1.type , packet1.size , packet1.width , packet1.height , packet1.packets , packet1.payload , packet1.jpg_quality );
6051 mavlink_msg_data_transmission_handshake_decode(last_msg, &packet2);
6052 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6053}
6054
6055static void mavlink_test_encapsulated_data(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6056{
6057#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6058 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6059 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ENCAPSULATED_DATA >= 256) {
6060 return;
6061 }
6062#endif
6063 mavlink_message_t msg;
6064 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6065 uint16_t i;
6066 mavlink_encapsulated_data_t packet_in = {
6067 17235,{ 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135 }
6068 };
6069 mavlink_encapsulated_data_t packet1, packet2;
6070 memset(&packet1, 0, sizeof(packet1));
6071 packet1.seqnr = packet_in.seqnr;
6072
6073 mav_array_memcpy(packet1.data, packet_in.data, sizeof(uint8_t)*253);
6074
6075#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6076 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6077 // cope with extensions
6078 memset(MAVLINK_MSG_ID_ENCAPSULATED_DATA_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ENCAPSULATED_DATA_MIN_LEN);
6079 }
6080#endif
6081 memset(&packet2, 0, sizeof(packet2));
6082 mavlink_msg_encapsulated_data_encode(system_id, component_id, &msg, &packet1);
6083 mavlink_msg_encapsulated_data_decode(&msg, &packet2);
6084 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6085
6086 memset(&packet2, 0, sizeof(packet2));
6087 mavlink_msg_encapsulated_data_pack(system_id, component_id, &msg , packet1.seqnr , packet1.data );
6088 mavlink_msg_encapsulated_data_decode(&msg, &packet2);
6089 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6090
6091 memset(&packet2, 0, sizeof(packet2));
6092 mavlink_msg_encapsulated_data_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.seqnr , packet1.data );
6093 mavlink_msg_encapsulated_data_decode(&msg, &packet2);
6094 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6095
6096 memset(&packet2, 0, sizeof(packet2));
6097 mavlink_msg_to_send_buffer(buffer, &msg);
6098 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6099 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6100 }
6101 mavlink_msg_encapsulated_data_decode(last_msg, &packet2);
6102 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6103
6104 memset(&packet2, 0, sizeof(packet2));
6105 mavlink_msg_encapsulated_data_send(MAVLINK_COMM_1 , packet1.seqnr , packet1.data );
6106 mavlink_msg_encapsulated_data_decode(last_msg, &packet2);
6107 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6108}
6109
6110static void mavlink_test_distance_sensor(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6111{
6112#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6113 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6114 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_DISTANCE_SENSOR >= 256) {
6115 return;
6116 }
6117#endif
6118 mavlink_message_t msg;
6119 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6120 uint16_t i;
6121 mavlink_distance_sensor_t packet_in = {
6122 963497464,17443,17547,17651,163,230,41,108
6123 };
6124 mavlink_distance_sensor_t packet1, packet2;
6125 memset(&packet1, 0, sizeof(packet1));
6126 packet1.time_boot_ms = packet_in.time_boot_ms;
6127 packet1.min_distance = packet_in.min_distance;
6128 packet1.max_distance = packet_in.max_distance;
6129 packet1.current_distance = packet_in.current_distance;
6130 packet1.type = packet_in.type;
6131 packet1.id = packet_in.id;
6132 packet1.orientation = packet_in.orientation;
6133 packet1.covariance = packet_in.covariance;
6134
6135
6136#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6137 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6138 // cope with extensions
6139 memset(MAVLINK_MSG_ID_DISTANCE_SENSOR_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_DISTANCE_SENSOR_MIN_LEN);
6140 }
6141#endif
6142 memset(&packet2, 0, sizeof(packet2));
6143 mavlink_msg_distance_sensor_encode(system_id, component_id, &msg, &packet1);
6144 mavlink_msg_distance_sensor_decode(&msg, &packet2);
6145 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6146
6147 memset(&packet2, 0, sizeof(packet2));
6148 mavlink_msg_distance_sensor_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.min_distance , packet1.max_distance , packet1.current_distance , packet1.type , packet1.id , packet1.orientation , packet1.covariance );
6149 mavlink_msg_distance_sensor_decode(&msg, &packet2);
6150 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6151
6152 memset(&packet2, 0, sizeof(packet2));
6153 mavlink_msg_distance_sensor_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.min_distance , packet1.max_distance , packet1.current_distance , packet1.type , packet1.id , packet1.orientation , packet1.covariance );
6154 mavlink_msg_distance_sensor_decode(&msg, &packet2);
6155 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6156
6157 memset(&packet2, 0, sizeof(packet2));
6158 mavlink_msg_to_send_buffer(buffer, &msg);
6159 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6160 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6161 }
6162 mavlink_msg_distance_sensor_decode(last_msg, &packet2);
6163 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6164
6165 memset(&packet2, 0, sizeof(packet2));
6166 mavlink_msg_distance_sensor_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.min_distance , packet1.max_distance , packet1.current_distance , packet1.type , packet1.id , packet1.orientation , packet1.covariance );
6167 mavlink_msg_distance_sensor_decode(last_msg, &packet2);
6168 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6169}
6170
6171static void mavlink_test_terrain_request(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6172{
6173#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6174 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6175 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_TERRAIN_REQUEST >= 256) {
6176 return;
6177 }
6178#endif
6179 mavlink_message_t msg;
6180 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6181 uint16_t i;
6182 mavlink_terrain_request_t packet_in = {
6183 93372036854775807ULL,963497880,963498088,18067
6184 };
6185 mavlink_terrain_request_t packet1, packet2;
6186 memset(&packet1, 0, sizeof(packet1));
6187 packet1.mask = packet_in.mask;
6188 packet1.lat = packet_in.lat;
6189 packet1.lon = packet_in.lon;
6190 packet1.grid_spacing = packet_in.grid_spacing;
6191
6192
6193#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6194 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6195 // cope with extensions
6196 memset(MAVLINK_MSG_ID_TERRAIN_REQUEST_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_TERRAIN_REQUEST_MIN_LEN);
6197 }
6198#endif
6199 memset(&packet2, 0, sizeof(packet2));
6200 mavlink_msg_terrain_request_encode(system_id, component_id, &msg, &packet1);
6201 mavlink_msg_terrain_request_decode(&msg, &packet2);
6202 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6203
6204 memset(&packet2, 0, sizeof(packet2));
6205 mavlink_msg_terrain_request_pack(system_id, component_id, &msg , packet1.lat , packet1.lon , packet1.grid_spacing , packet1.mask );
6206 mavlink_msg_terrain_request_decode(&msg, &packet2);
6207 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6208
6209 memset(&packet2, 0, sizeof(packet2));
6210 mavlink_msg_terrain_request_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.lat , packet1.lon , packet1.grid_spacing , packet1.mask );
6211 mavlink_msg_terrain_request_decode(&msg, &packet2);
6212 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6213
6214 memset(&packet2, 0, sizeof(packet2));
6215 mavlink_msg_to_send_buffer(buffer, &msg);
6216 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6217 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6218 }
6219 mavlink_msg_terrain_request_decode(last_msg, &packet2);
6220 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6221
6222 memset(&packet2, 0, sizeof(packet2));
6223 mavlink_msg_terrain_request_send(MAVLINK_COMM_1 , packet1.lat , packet1.lon , packet1.grid_spacing , packet1.mask );
6224 mavlink_msg_terrain_request_decode(last_msg, &packet2);
6225 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6226}
6227
6228static void mavlink_test_terrain_data(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6229{
6230#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6231 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6232 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_TERRAIN_DATA >= 256) {
6233 return;
6234 }
6235#endif
6236 mavlink_message_t msg;
6237 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6238 uint16_t i;
6239 mavlink_terrain_data_t packet_in = {
6240 963497464,963497672,17651,{ 17755, 17756, 17757, 17758, 17759, 17760, 17761, 17762, 17763, 17764, 17765, 17766, 17767, 17768, 17769, 17770 },3
6241 };
6242 mavlink_terrain_data_t packet1, packet2;
6243 memset(&packet1, 0, sizeof(packet1));
6244 packet1.lat = packet_in.lat;
6245 packet1.lon = packet_in.lon;
6246 packet1.grid_spacing = packet_in.grid_spacing;
6247 packet1.gridbit = packet_in.gridbit;
6248
6249 mav_array_memcpy(packet1.data, packet_in.data, sizeof(int16_t)*16);
6250
6251#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6252 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6253 // cope with extensions
6254 memset(MAVLINK_MSG_ID_TERRAIN_DATA_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_TERRAIN_DATA_MIN_LEN);
6255 }
6256#endif
6257 memset(&packet2, 0, sizeof(packet2));
6258 mavlink_msg_terrain_data_encode(system_id, component_id, &msg, &packet1);
6259 mavlink_msg_terrain_data_decode(&msg, &packet2);
6260 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6261
6262 memset(&packet2, 0, sizeof(packet2));
6263 mavlink_msg_terrain_data_pack(system_id, component_id, &msg , packet1.lat , packet1.lon , packet1.grid_spacing , packet1.gridbit , packet1.data );
6264 mavlink_msg_terrain_data_decode(&msg, &packet2);
6265 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6266
6267 memset(&packet2, 0, sizeof(packet2));
6268 mavlink_msg_terrain_data_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.lat , packet1.lon , packet1.grid_spacing , packet1.gridbit , packet1.data );
6269 mavlink_msg_terrain_data_decode(&msg, &packet2);
6270 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6271
6272 memset(&packet2, 0, sizeof(packet2));
6273 mavlink_msg_to_send_buffer(buffer, &msg);
6274 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6275 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6276 }
6277 mavlink_msg_terrain_data_decode(last_msg, &packet2);
6278 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6279
6280 memset(&packet2, 0, sizeof(packet2));
6281 mavlink_msg_terrain_data_send(MAVLINK_COMM_1 , packet1.lat , packet1.lon , packet1.grid_spacing , packet1.gridbit , packet1.data );
6282 mavlink_msg_terrain_data_decode(last_msg, &packet2);
6283 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6284}
6285
6286static void mavlink_test_terrain_check(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6287{
6288#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6289 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6290 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_TERRAIN_CHECK >= 256) {
6291 return;
6292 }
6293#endif
6294 mavlink_message_t msg;
6295 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6296 uint16_t i;
6297 mavlink_terrain_check_t packet_in = {
6298 963497464,963497672
6299 };
6300 mavlink_terrain_check_t packet1, packet2;
6301 memset(&packet1, 0, sizeof(packet1));
6302 packet1.lat = packet_in.lat;
6303 packet1.lon = packet_in.lon;
6304
6305
6306#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6307 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6308 // cope with extensions
6309 memset(MAVLINK_MSG_ID_TERRAIN_CHECK_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_TERRAIN_CHECK_MIN_LEN);
6310 }
6311#endif
6312 memset(&packet2, 0, sizeof(packet2));
6313 mavlink_msg_terrain_check_encode(system_id, component_id, &msg, &packet1);
6314 mavlink_msg_terrain_check_decode(&msg, &packet2);
6315 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6316
6317 memset(&packet2, 0, sizeof(packet2));
6318 mavlink_msg_terrain_check_pack(system_id, component_id, &msg , packet1.lat , packet1.lon );
6319 mavlink_msg_terrain_check_decode(&msg, &packet2);
6320 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6321
6322 memset(&packet2, 0, sizeof(packet2));
6323 mavlink_msg_terrain_check_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.lat , packet1.lon );
6324 mavlink_msg_terrain_check_decode(&msg, &packet2);
6325 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6326
6327 memset(&packet2, 0, sizeof(packet2));
6328 mavlink_msg_to_send_buffer(buffer, &msg);
6329 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6330 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6331 }
6332 mavlink_msg_terrain_check_decode(last_msg, &packet2);
6333 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6334
6335 memset(&packet2, 0, sizeof(packet2));
6336 mavlink_msg_terrain_check_send(MAVLINK_COMM_1 , packet1.lat , packet1.lon );
6337 mavlink_msg_terrain_check_decode(last_msg, &packet2);
6338 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6339}
6340
6341static void mavlink_test_terrain_report(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6342{
6343#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6344 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6345 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_TERRAIN_REPORT >= 256) {
6346 return;
6347 }
6348#endif
6349 mavlink_message_t msg;
6350 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6351 uint16_t i;
6352 mavlink_terrain_report_t packet_in = {
6353 963497464,963497672,73.0,101.0,18067,18171,18275
6354 };
6355 mavlink_terrain_report_t packet1, packet2;
6356 memset(&packet1, 0, sizeof(packet1));
6357 packet1.lat = packet_in.lat;
6358 packet1.lon = packet_in.lon;
6359 packet1.terrain_height = packet_in.terrain_height;
6360 packet1.current_height = packet_in.current_height;
6361 packet1.spacing = packet_in.spacing;
6362 packet1.pending = packet_in.pending;
6363 packet1.loaded = packet_in.loaded;
6364
6365
6366#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6367 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6368 // cope with extensions
6369 memset(MAVLINK_MSG_ID_TERRAIN_REPORT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_TERRAIN_REPORT_MIN_LEN);
6370 }
6371#endif
6372 memset(&packet2, 0, sizeof(packet2));
6373 mavlink_msg_terrain_report_encode(system_id, component_id, &msg, &packet1);
6374 mavlink_msg_terrain_report_decode(&msg, &packet2);
6375 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6376
6377 memset(&packet2, 0, sizeof(packet2));
6378 mavlink_msg_terrain_report_pack(system_id, component_id, &msg , packet1.lat , packet1.lon , packet1.spacing , packet1.terrain_height , packet1.current_height , packet1.pending , packet1.loaded );
6379 mavlink_msg_terrain_report_decode(&msg, &packet2);
6380 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6381
6382 memset(&packet2, 0, sizeof(packet2));
6383 mavlink_msg_terrain_report_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.lat , packet1.lon , packet1.spacing , packet1.terrain_height , packet1.current_height , packet1.pending , packet1.loaded );
6384 mavlink_msg_terrain_report_decode(&msg, &packet2);
6385 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6386
6387 memset(&packet2, 0, sizeof(packet2));
6388 mavlink_msg_to_send_buffer(buffer, &msg);
6389 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6390 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6391 }
6392 mavlink_msg_terrain_report_decode(last_msg, &packet2);
6393 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6394
6395 memset(&packet2, 0, sizeof(packet2));
6396 mavlink_msg_terrain_report_send(MAVLINK_COMM_1 , packet1.lat , packet1.lon , packet1.spacing , packet1.terrain_height , packet1.current_height , packet1.pending , packet1.loaded );
6397 mavlink_msg_terrain_report_decode(last_msg, &packet2);
6398 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6399}
6400
6401static void mavlink_test_scaled_pressure2(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6402{
6403#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6404 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6405 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SCALED_PRESSURE2 >= 256) {
6406 return;
6407 }
6408#endif
6409 mavlink_message_t msg;
6410 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6411 uint16_t i;
6412 mavlink_scaled_pressure2_t packet_in = {
6413 963497464,45.0,73.0,17859
6414 };
6415 mavlink_scaled_pressure2_t packet1, packet2;
6416 memset(&packet1, 0, sizeof(packet1));
6417 packet1.time_boot_ms = packet_in.time_boot_ms;
6418 packet1.press_abs = packet_in.press_abs;
6419 packet1.press_diff = packet_in.press_diff;
6420 packet1.temperature = packet_in.temperature;
6421
6422
6423#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6424 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6425 // cope with extensions
6426 memset(MAVLINK_MSG_ID_SCALED_PRESSURE2_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SCALED_PRESSURE2_MIN_LEN);
6427 }
6428#endif
6429 memset(&packet2, 0, sizeof(packet2));
6430 mavlink_msg_scaled_pressure2_encode(system_id, component_id, &msg, &packet1);
6431 mavlink_msg_scaled_pressure2_decode(&msg, &packet2);
6432 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6433
6434 memset(&packet2, 0, sizeof(packet2));
6435 mavlink_msg_scaled_pressure2_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.press_abs , packet1.press_diff , packet1.temperature );
6436 mavlink_msg_scaled_pressure2_decode(&msg, &packet2);
6437 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6438
6439 memset(&packet2, 0, sizeof(packet2));
6440 mavlink_msg_scaled_pressure2_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.press_abs , packet1.press_diff , packet1.temperature );
6441 mavlink_msg_scaled_pressure2_decode(&msg, &packet2);
6442 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6443
6444 memset(&packet2, 0, sizeof(packet2));
6445 mavlink_msg_to_send_buffer(buffer, &msg);
6446 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6447 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6448 }
6449 mavlink_msg_scaled_pressure2_decode(last_msg, &packet2);
6450 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6451
6452 memset(&packet2, 0, sizeof(packet2));
6453 mavlink_msg_scaled_pressure2_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.press_abs , packet1.press_diff , packet1.temperature );
6454 mavlink_msg_scaled_pressure2_decode(last_msg, &packet2);
6455 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6456}
6457
6458static void mavlink_test_att_pos_mocap(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6459{
6460#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6461 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6462 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ATT_POS_MOCAP >= 256) {
6463 return;
6464 }
6465#endif
6466 mavlink_message_t msg;
6467 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6468 uint16_t i;
6469 mavlink_att_pos_mocap_t packet_in = {
6470 93372036854775807ULL,{ 73.0, 74.0, 75.0, 76.0 },185.0,213.0,241.0
6471 };
6472 mavlink_att_pos_mocap_t packet1, packet2;
6473 memset(&packet1, 0, sizeof(packet1));
6474 packet1.time_usec = packet_in.time_usec;
6475 packet1.x = packet_in.x;
6476 packet1.y = packet_in.y;
6477 packet1.z = packet_in.z;
6478
6479 mav_array_memcpy(packet1.q, packet_in.q, sizeof(float)*4);
6480
6481#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6482 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6483 // cope with extensions
6484 memset(MAVLINK_MSG_ID_ATT_POS_MOCAP_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ATT_POS_MOCAP_MIN_LEN);
6485 }
6486#endif
6487 memset(&packet2, 0, sizeof(packet2));
6488 mavlink_msg_att_pos_mocap_encode(system_id, component_id, &msg, &packet1);
6489 mavlink_msg_att_pos_mocap_decode(&msg, &packet2);
6490 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6491
6492 memset(&packet2, 0, sizeof(packet2));
6493 mavlink_msg_att_pos_mocap_pack(system_id, component_id, &msg , packet1.time_usec , packet1.q , packet1.x , packet1.y , packet1.z );
6494 mavlink_msg_att_pos_mocap_decode(&msg, &packet2);
6495 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6496
6497 memset(&packet2, 0, sizeof(packet2));
6498 mavlink_msg_att_pos_mocap_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.q , packet1.x , packet1.y , packet1.z );
6499 mavlink_msg_att_pos_mocap_decode(&msg, &packet2);
6500 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6501
6502 memset(&packet2, 0, sizeof(packet2));
6503 mavlink_msg_to_send_buffer(buffer, &msg);
6504 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6505 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6506 }
6507 mavlink_msg_att_pos_mocap_decode(last_msg, &packet2);
6508 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6509
6510 memset(&packet2, 0, sizeof(packet2));
6511 mavlink_msg_att_pos_mocap_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.q , packet1.x , packet1.y , packet1.z );
6512 mavlink_msg_att_pos_mocap_decode(last_msg, &packet2);
6513 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6514}
6515
6516static void mavlink_test_set_actuator_control_target(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6517{
6518#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6519 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6520 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET >= 256) {
6521 return;
6522 }
6523#endif
6524 mavlink_message_t msg;
6525 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6526 uint16_t i;
6527 mavlink_set_actuator_control_target_t packet_in = {
6528 93372036854775807ULL,{ 73.0, 74.0, 75.0, 76.0, 77.0, 78.0, 79.0, 80.0 },125,192,3
6529 };
6530 mavlink_set_actuator_control_target_t packet1, packet2;
6531 memset(&packet1, 0, sizeof(packet1));
6532 packet1.time_usec = packet_in.time_usec;
6533 packet1.group_mlx = packet_in.group_mlx;
6534 packet1.target_system = packet_in.target_system;
6535 packet1.target_component = packet_in.target_component;
6536
6537 mav_array_memcpy(packet1.controls, packet_in.controls, sizeof(float)*8);
6538
6539#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6540 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6541 // cope with extensions
6542 memset(MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SET_ACTUATOR_CONTROL_TARGET_MIN_LEN);
6543 }
6544#endif
6545 memset(&packet2, 0, sizeof(packet2));
6546 mavlink_msg_set_actuator_control_target_encode(system_id, component_id, &msg, &packet1);
6547 mavlink_msg_set_actuator_control_target_decode(&msg, &packet2);
6548 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6549
6550 memset(&packet2, 0, sizeof(packet2));
6551 mavlink_msg_set_actuator_control_target_pack(system_id, component_id, &msg , packet1.time_usec , packet1.group_mlx , packet1.target_system , packet1.target_component , packet1.controls );
6552 mavlink_msg_set_actuator_control_target_decode(&msg, &packet2);
6553 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6554
6555 memset(&packet2, 0, sizeof(packet2));
6556 mavlink_msg_set_actuator_control_target_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.group_mlx , packet1.target_system , packet1.target_component , packet1.controls );
6557 mavlink_msg_set_actuator_control_target_decode(&msg, &packet2);
6558 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6559
6560 memset(&packet2, 0, sizeof(packet2));
6561 mavlink_msg_to_send_buffer(buffer, &msg);
6562 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6563 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6564 }
6565 mavlink_msg_set_actuator_control_target_decode(last_msg, &packet2);
6566 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6567
6568 memset(&packet2, 0, sizeof(packet2));
6569 mavlink_msg_set_actuator_control_target_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.group_mlx , packet1.target_system , packet1.target_component , packet1.controls );
6570 mavlink_msg_set_actuator_control_target_decode(last_msg, &packet2);
6571 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6572}
6573
6574static void mavlink_test_actuator_control_target(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6575{
6576#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6577 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6578 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET >= 256) {
6579 return;
6580 }
6581#endif
6582 mavlink_message_t msg;
6583 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6584 uint16_t i;
6585 mavlink_actuator_control_target_t packet_in = {
6586 93372036854775807ULL,{ 73.0, 74.0, 75.0, 76.0, 77.0, 78.0, 79.0, 80.0 },125
6587 };
6588 mavlink_actuator_control_target_t packet1, packet2;
6589 memset(&packet1, 0, sizeof(packet1));
6590 packet1.time_usec = packet_in.time_usec;
6591 packet1.group_mlx = packet_in.group_mlx;
6592
6593 mav_array_memcpy(packet1.controls, packet_in.controls, sizeof(float)*8);
6594
6595#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6596 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6597 // cope with extensions
6598 memset(MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ACTUATOR_CONTROL_TARGET_MIN_LEN);
6599 }
6600#endif
6601 memset(&packet2, 0, sizeof(packet2));
6602 mavlink_msg_actuator_control_target_encode(system_id, component_id, &msg, &packet1);
6603 mavlink_msg_actuator_control_target_decode(&msg, &packet2);
6604 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6605
6606 memset(&packet2, 0, sizeof(packet2));
6607 mavlink_msg_actuator_control_target_pack(system_id, component_id, &msg , packet1.time_usec , packet1.group_mlx , packet1.controls );
6608 mavlink_msg_actuator_control_target_decode(&msg, &packet2);
6609 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6610
6611 memset(&packet2, 0, sizeof(packet2));
6612 mavlink_msg_actuator_control_target_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.group_mlx , packet1.controls );
6613 mavlink_msg_actuator_control_target_decode(&msg, &packet2);
6614 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6615
6616 memset(&packet2, 0, sizeof(packet2));
6617 mavlink_msg_to_send_buffer(buffer, &msg);
6618 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6619 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6620 }
6621 mavlink_msg_actuator_control_target_decode(last_msg, &packet2);
6622 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6623
6624 memset(&packet2, 0, sizeof(packet2));
6625 mavlink_msg_actuator_control_target_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.group_mlx , packet1.controls );
6626 mavlink_msg_actuator_control_target_decode(last_msg, &packet2);
6627 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6628}
6629
6630static void mavlink_test_altitude(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6631{
6632#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6633 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6634 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ALTITUDE >= 256) {
6635 return;
6636 }
6637#endif
6638 mavlink_message_t msg;
6639 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6640 uint16_t i;
6641 mavlink_altitude_t packet_in = {
6642 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0
6643 };
6644 mavlink_altitude_t packet1, packet2;
6645 memset(&packet1, 0, sizeof(packet1));
6646 packet1.time_usec = packet_in.time_usec;
6647 packet1.altitude_monotonic = packet_in.altitude_monotonic;
6648 packet1.altitude_amsl = packet_in.altitude_amsl;
6649 packet1.altitude_local = packet_in.altitude_local;
6650 packet1.altitude_relative = packet_in.altitude_relative;
6651 packet1.altitude_terrain = packet_in.altitude_terrain;
6652 packet1.bottom_clearance = packet_in.bottom_clearance;
6653
6654
6655#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6656 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6657 // cope with extensions
6658 memset(MAVLINK_MSG_ID_ALTITUDE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ALTITUDE_MIN_LEN);
6659 }
6660#endif
6661 memset(&packet2, 0, sizeof(packet2));
6662 mavlink_msg_altitude_encode(system_id, component_id, &msg, &packet1);
6663 mavlink_msg_altitude_decode(&msg, &packet2);
6664 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6665
6666 memset(&packet2, 0, sizeof(packet2));
6667 mavlink_msg_altitude_pack(system_id, component_id, &msg , packet1.time_usec , packet1.altitude_monotonic , packet1.altitude_amsl , packet1.altitude_local , packet1.altitude_relative , packet1.altitude_terrain , packet1.bottom_clearance );
6668 mavlink_msg_altitude_decode(&msg, &packet2);
6669 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6670
6671 memset(&packet2, 0, sizeof(packet2));
6672 mavlink_msg_altitude_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.altitude_monotonic , packet1.altitude_amsl , packet1.altitude_local , packet1.altitude_relative , packet1.altitude_terrain , packet1.bottom_clearance );
6673 mavlink_msg_altitude_decode(&msg, &packet2);
6674 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6675
6676 memset(&packet2, 0, sizeof(packet2));
6677 mavlink_msg_to_send_buffer(buffer, &msg);
6678 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6679 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6680 }
6681 mavlink_msg_altitude_decode(last_msg, &packet2);
6682 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6683
6684 memset(&packet2, 0, sizeof(packet2));
6685 mavlink_msg_altitude_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.altitude_monotonic , packet1.altitude_amsl , packet1.altitude_local , packet1.altitude_relative , packet1.altitude_terrain , packet1.bottom_clearance );
6686 mavlink_msg_altitude_decode(last_msg, &packet2);
6687 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6688}
6689
6690static void mavlink_test_resource_request(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6691{
6692#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6693 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6694 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_RESOURCE_REQUEST >= 256) {
6695 return;
6696 }
6697#endif
6698 mavlink_message_t msg;
6699 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6700 uint16_t i;
6701 mavlink_resource_request_t packet_in = {
6702 5,72,{ 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2 },243,{ 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173 }
6703 };
6704 mavlink_resource_request_t packet1, packet2;
6705 memset(&packet1, 0, sizeof(packet1));
6706 packet1.request_id = packet_in.request_id;
6707 packet1.uri_type = packet_in.uri_type;
6708 packet1.transfer_type = packet_in.transfer_type;
6709
6710 mav_array_memcpy(packet1.uri, packet_in.uri, sizeof(uint8_t)*120);
6711 mav_array_memcpy(packet1.storage, packet_in.storage, sizeof(uint8_t)*120);
6712
6713#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6714 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6715 // cope with extensions
6716 memset(MAVLINK_MSG_ID_RESOURCE_REQUEST_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_RESOURCE_REQUEST_MIN_LEN);
6717 }
6718#endif
6719 memset(&packet2, 0, sizeof(packet2));
6720 mavlink_msg_resource_request_encode(system_id, component_id, &msg, &packet1);
6721 mavlink_msg_resource_request_decode(&msg, &packet2);
6722 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6723
6724 memset(&packet2, 0, sizeof(packet2));
6725 mavlink_msg_resource_request_pack(system_id, component_id, &msg , packet1.request_id , packet1.uri_type , packet1.uri , packet1.transfer_type , packet1.storage );
6726 mavlink_msg_resource_request_decode(&msg, &packet2);
6727 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6728
6729 memset(&packet2, 0, sizeof(packet2));
6730 mavlink_msg_resource_request_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.request_id , packet1.uri_type , packet1.uri , packet1.transfer_type , packet1.storage );
6731 mavlink_msg_resource_request_decode(&msg, &packet2);
6732 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6733
6734 memset(&packet2, 0, sizeof(packet2));
6735 mavlink_msg_to_send_buffer(buffer, &msg);
6736 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6737 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6738 }
6739 mavlink_msg_resource_request_decode(last_msg, &packet2);
6740 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6741
6742 memset(&packet2, 0, sizeof(packet2));
6743 mavlink_msg_resource_request_send(MAVLINK_COMM_1 , packet1.request_id , packet1.uri_type , packet1.uri , packet1.transfer_type , packet1.storage );
6744 mavlink_msg_resource_request_decode(last_msg, &packet2);
6745 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6746}
6747
6748static void mavlink_test_scaled_pressure3(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6749{
6750#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6751 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6752 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SCALED_PRESSURE3 >= 256) {
6753 return;
6754 }
6755#endif
6756 mavlink_message_t msg;
6757 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6758 uint16_t i;
6759 mavlink_scaled_pressure3_t packet_in = {
6760 963497464,45.0,73.0,17859
6761 };
6762 mavlink_scaled_pressure3_t packet1, packet2;
6763 memset(&packet1, 0, sizeof(packet1));
6764 packet1.time_boot_ms = packet_in.time_boot_ms;
6765 packet1.press_abs = packet_in.press_abs;
6766 packet1.press_diff = packet_in.press_diff;
6767 packet1.temperature = packet_in.temperature;
6768
6769
6770#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6771 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6772 // cope with extensions
6773 memset(MAVLINK_MSG_ID_SCALED_PRESSURE3_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SCALED_PRESSURE3_MIN_LEN);
6774 }
6775#endif
6776 memset(&packet2, 0, sizeof(packet2));
6777 mavlink_msg_scaled_pressure3_encode(system_id, component_id, &msg, &packet1);
6778 mavlink_msg_scaled_pressure3_decode(&msg, &packet2);
6779 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6780
6781 memset(&packet2, 0, sizeof(packet2));
6782 mavlink_msg_scaled_pressure3_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.press_abs , packet1.press_diff , packet1.temperature );
6783 mavlink_msg_scaled_pressure3_decode(&msg, &packet2);
6784 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6785
6786 memset(&packet2, 0, sizeof(packet2));
6787 mavlink_msg_scaled_pressure3_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.press_abs , packet1.press_diff , packet1.temperature );
6788 mavlink_msg_scaled_pressure3_decode(&msg, &packet2);
6789 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6790
6791 memset(&packet2, 0, sizeof(packet2));
6792 mavlink_msg_to_send_buffer(buffer, &msg);
6793 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6794 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6795 }
6796 mavlink_msg_scaled_pressure3_decode(last_msg, &packet2);
6797 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6798
6799 memset(&packet2, 0, sizeof(packet2));
6800 mavlink_msg_scaled_pressure3_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.press_abs , packet1.press_diff , packet1.temperature );
6801 mavlink_msg_scaled_pressure3_decode(last_msg, &packet2);
6802 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6803}
6804
6805static void mavlink_test_follow_target(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6806{
6807#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6808 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6809 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_FOLLOW_TARGET >= 256) {
6810 return;
6811 }
6812#endif
6813 mavlink_message_t msg;
6814 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6815 uint16_t i;
6816 mavlink_follow_target_t packet_in = {
6817 93372036854775807ULL,93372036854776311ULL,963498296,963498504,185.0,{ 213.0, 214.0, 215.0 },{ 297.0, 298.0, 299.0 },{ 381.0, 382.0, 383.0, 384.0 },{ 493.0, 494.0, 495.0 },{ 577.0, 578.0, 579.0 },25
6818 };
6819 mavlink_follow_target_t packet1, packet2;
6820 memset(&packet1, 0, sizeof(packet1));
6821 packet1.timestamp = packet_in.timestamp;
6822 packet1.custom_state = packet_in.custom_state;
6823 packet1.lat = packet_in.lat;
6824 packet1.lon = packet_in.lon;
6825 packet1.alt = packet_in.alt;
6826 packet1.est_capabilities = packet_in.est_capabilities;
6827
6828 mav_array_memcpy(packet1.vel, packet_in.vel, sizeof(float)*3);
6829 mav_array_memcpy(packet1.acc, packet_in.acc, sizeof(float)*3);
6830 mav_array_memcpy(packet1.attitude_q, packet_in.attitude_q, sizeof(float)*4);
6831 mav_array_memcpy(packet1.rates, packet_in.rates, sizeof(float)*3);
6832 mav_array_memcpy(packet1.position_cov, packet_in.position_cov, sizeof(float)*3);
6833
6834#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6835 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6836 // cope with extensions
6837 memset(MAVLINK_MSG_ID_FOLLOW_TARGET_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_FOLLOW_TARGET_MIN_LEN);
6838 }
6839#endif
6840 memset(&packet2, 0, sizeof(packet2));
6841 mavlink_msg_follow_target_encode(system_id, component_id, &msg, &packet1);
6842 mavlink_msg_follow_target_decode(&msg, &packet2);
6843 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6844
6845 memset(&packet2, 0, sizeof(packet2));
6846 mavlink_msg_follow_target_pack(system_id, component_id, &msg , packet1.timestamp , packet1.est_capabilities , packet1.lat , packet1.lon , packet1.alt , packet1.vel , packet1.acc , packet1.attitude_q , packet1.rates , packet1.position_cov , packet1.custom_state );
6847 mavlink_msg_follow_target_decode(&msg, &packet2);
6848 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6849
6850 memset(&packet2, 0, sizeof(packet2));
6851 mavlink_msg_follow_target_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.timestamp , packet1.est_capabilities , packet1.lat , packet1.lon , packet1.alt , packet1.vel , packet1.acc , packet1.attitude_q , packet1.rates , packet1.position_cov , packet1.custom_state );
6852 mavlink_msg_follow_target_decode(&msg, &packet2);
6853 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6854
6855 memset(&packet2, 0, sizeof(packet2));
6856 mavlink_msg_to_send_buffer(buffer, &msg);
6857 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6858 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6859 }
6860 mavlink_msg_follow_target_decode(last_msg, &packet2);
6861 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6862
6863 memset(&packet2, 0, sizeof(packet2));
6864 mavlink_msg_follow_target_send(MAVLINK_COMM_1 , packet1.timestamp , packet1.est_capabilities , packet1.lat , packet1.lon , packet1.alt , packet1.vel , packet1.acc , packet1.attitude_q , packet1.rates , packet1.position_cov , packet1.custom_state );
6865 mavlink_msg_follow_target_decode(last_msg, &packet2);
6866 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6867}
6868
6869static void mavlink_test_control_system_state(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6870{
6871#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6872 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6873 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE >= 256) {
6874 return;
6875 }
6876#endif
6877 mavlink_message_t msg;
6878 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6879 uint16_t i;
6880 mavlink_control_system_state_t packet_in = {
6881 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,297.0,325.0,{ 353.0, 354.0, 355.0 },{ 437.0, 438.0, 439.0 },{ 521.0, 522.0, 523.0, 524.0 },633.0,661.0,689.0
6882 };
6883 mavlink_control_system_state_t packet1, packet2;
6884 memset(&packet1, 0, sizeof(packet1));
6885 packet1.time_usec = packet_in.time_usec;
6886 packet1.x_acc = packet_in.x_acc;
6887 packet1.y_acc = packet_in.y_acc;
6888 packet1.z_acc = packet_in.z_acc;
6889 packet1.x_vel = packet_in.x_vel;
6890 packet1.y_vel = packet_in.y_vel;
6891 packet1.z_vel = packet_in.z_vel;
6892 packet1.x_pos = packet_in.x_pos;
6893 packet1.y_pos = packet_in.y_pos;
6894 packet1.z_pos = packet_in.z_pos;
6895 packet1.airspeed = packet_in.airspeed;
6896 packet1.roll_rate = packet_in.roll_rate;
6897 packet1.pitch_rate = packet_in.pitch_rate;
6898 packet1.yaw_rate = packet_in.yaw_rate;
6899
6900 mav_array_memcpy(packet1.vel_variance, packet_in.vel_variance, sizeof(float)*3);
6901 mav_array_memcpy(packet1.pos_variance, packet_in.pos_variance, sizeof(float)*3);
6902 mav_array_memcpy(packet1.q, packet_in.q, sizeof(float)*4);
6903
6904#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6905 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6906 // cope with extensions
6907 memset(MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CONTROL_SYSTEM_STATE_MIN_LEN);
6908 }
6909#endif
6910 memset(&packet2, 0, sizeof(packet2));
6911 mavlink_msg_control_system_state_encode(system_id, component_id, &msg, &packet1);
6912 mavlink_msg_control_system_state_decode(&msg, &packet2);
6913 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6914
6915 memset(&packet2, 0, sizeof(packet2));
6916 mavlink_msg_control_system_state_pack(system_id, component_id, &msg , packet1.time_usec , packet1.x_acc , packet1.y_acc , packet1.z_acc , packet1.x_vel , packet1.y_vel , packet1.z_vel , packet1.x_pos , packet1.y_pos , packet1.z_pos , packet1.airspeed , packet1.vel_variance , packet1.pos_variance , packet1.q , packet1.roll_rate , packet1.pitch_rate , packet1.yaw_rate );
6917 mavlink_msg_control_system_state_decode(&msg, &packet2);
6918 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6919
6920 memset(&packet2, 0, sizeof(packet2));
6921 mavlink_msg_control_system_state_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.x_acc , packet1.y_acc , packet1.z_acc , packet1.x_vel , packet1.y_vel , packet1.z_vel , packet1.x_pos , packet1.y_pos , packet1.z_pos , packet1.airspeed , packet1.vel_variance , packet1.pos_variance , packet1.q , packet1.roll_rate , packet1.pitch_rate , packet1.yaw_rate );
6922 mavlink_msg_control_system_state_decode(&msg, &packet2);
6923 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6924
6925 memset(&packet2, 0, sizeof(packet2));
6926 mavlink_msg_to_send_buffer(buffer, &msg);
6927 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6928 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6929 }
6930 mavlink_msg_control_system_state_decode(last_msg, &packet2);
6931 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6932
6933 memset(&packet2, 0, sizeof(packet2));
6934 mavlink_msg_control_system_state_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.x_acc , packet1.y_acc , packet1.z_acc , packet1.x_vel , packet1.y_vel , packet1.z_vel , packet1.x_pos , packet1.y_pos , packet1.z_pos , packet1.airspeed , packet1.vel_variance , packet1.pos_variance , packet1.q , packet1.roll_rate , packet1.pitch_rate , packet1.yaw_rate );
6935 mavlink_msg_control_system_state_decode(last_msg, &packet2);
6936 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6937}
6938
6939static void mavlink_test_battery_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
6940{
6941#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6942 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
6943 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_BATTERY_STATUS >= 256) {
6944 return;
6945 }
6946#endif
6947 mavlink_message_t msg;
6948 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
6949 uint16_t i;
6950 mavlink_battery_status_t packet_in = {
6951 963497464,963497672,17651,{ 17755, 17756, 17757, 17758, 17759, 17760, 17761, 17762, 17763, 17764 },18795,101,168,235,46
6952 };
6953 mavlink_battery_status_t packet1, packet2;
6954 memset(&packet1, 0, sizeof(packet1));
6955 packet1.current_consumed = packet_in.current_consumed;
6956 packet1.energy_consumed = packet_in.energy_consumed;
6957 packet1.temperature = packet_in.temperature;
6958 packet1.current_battery = packet_in.current_battery;
6959 packet1.id = packet_in.id;
6960 packet1.battery_function = packet_in.battery_function;
6961 packet1.type = packet_in.type;
6962 packet1.battery_remaining = packet_in.battery_remaining;
6963
6964 mav_array_memcpy(packet1.voltages, packet_in.voltages, sizeof(uint16_t)*10);
6965
6966#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
6967 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
6968 // cope with extensions
6969 memset(MAVLINK_MSG_ID_BATTERY_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_BATTERY_STATUS_MIN_LEN);
6970 }
6971#endif
6972 memset(&packet2, 0, sizeof(packet2));
6973 mavlink_msg_battery_status_encode(system_id, component_id, &msg, &packet1);
6974 mavlink_msg_battery_status_decode(&msg, &packet2);
6975 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6976
6977 memset(&packet2, 0, sizeof(packet2));
6978 mavlink_msg_battery_status_pack(system_id, component_id, &msg , packet1.id , packet1.battery_function , packet1.type , packet1.temperature , packet1.voltages , packet1.current_battery , packet1.current_consumed , packet1.energy_consumed , packet1.battery_remaining );
6979 mavlink_msg_battery_status_decode(&msg, &packet2);
6980 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6981
6982 memset(&packet2, 0, sizeof(packet2));
6983 mavlink_msg_battery_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.id , packet1.battery_function , packet1.type , packet1.temperature , packet1.voltages , packet1.current_battery , packet1.current_consumed , packet1.energy_consumed , packet1.battery_remaining );
6984 mavlink_msg_battery_status_decode(&msg, &packet2);
6985 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6986
6987 memset(&packet2, 0, sizeof(packet2));
6988 mavlink_msg_to_send_buffer(buffer, &msg);
6989 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
6990 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
6991 }
6992 mavlink_msg_battery_status_decode(last_msg, &packet2);
6993 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6994
6995 memset(&packet2, 0, sizeof(packet2));
6996 mavlink_msg_battery_status_send(MAVLINK_COMM_1 , packet1.id , packet1.battery_function , packet1.type , packet1.temperature , packet1.voltages , packet1.current_battery , packet1.current_consumed , packet1.energy_consumed , packet1.battery_remaining );
6997 mavlink_msg_battery_status_decode(last_msg, &packet2);
6998 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
6999}
7000
7001static void mavlink_test_autopilot_version(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7002{
7003#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7004 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7005 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_AUTOPILOT_VERSION >= 256) {
7006 return;
7007 }
7008#endif
7009 mavlink_message_t msg;
7010 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7011 uint16_t i;
7012 mavlink_autopilot_version_t packet_in = {
7013 93372036854775807ULL,93372036854776311ULL,963498296,963498504,963498712,963498920,18899,19003,{ 113, 114, 115, 116, 117, 118, 119, 120 },{ 137, 138, 139, 140, 141, 142, 143, 144 },{ 161, 162, 163, 164, 165, 166, 167, 168 },{ 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202 }
7014 };
7015 mavlink_autopilot_version_t packet1, packet2;
7016 memset(&packet1, 0, sizeof(packet1));
7017 packet1.capabilities = packet_in.capabilities;
7018 packet1.uid = packet_in.uid;
7019 packet1.flight_sw_version = packet_in.flight_sw_version;
7020 packet1.middleware_sw_version = packet_in.middleware_sw_version;
7021 packet1.os_sw_version = packet_in.os_sw_version;
7022 packet1.board_version = packet_in.board_version;
7023 packet1.vendor_id = packet_in.vendor_id;
7024 packet1.product_id = packet_in.product_id;
7025
7026 mav_array_memcpy(packet1.flight_custom_version, packet_in.flight_custom_version, sizeof(uint8_t)*8);
7027 mav_array_memcpy(packet1.middleware_custom_version, packet_in.middleware_custom_version, sizeof(uint8_t)*8);
7028 mav_array_memcpy(packet1.os_custom_version, packet_in.os_custom_version, sizeof(uint8_t)*8);
7029 mav_array_memcpy(packet1.uid2, packet_in.uid2, sizeof(uint8_t)*18);
7030
7031#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7032 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7033 // cope with extensions
7034 memset(MAVLINK_MSG_ID_AUTOPILOT_VERSION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_AUTOPILOT_VERSION_MIN_LEN);
7035 }
7036#endif
7037 memset(&packet2, 0, sizeof(packet2));
7038 mavlink_msg_autopilot_version_encode(system_id, component_id, &msg, &packet1);
7039 mavlink_msg_autopilot_version_decode(&msg, &packet2);
7040 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7041
7042 memset(&packet2, 0, sizeof(packet2));
7043 mavlink_msg_autopilot_version_pack(system_id, component_id, &msg , packet1.capabilities , packet1.flight_sw_version , packet1.middleware_sw_version , packet1.os_sw_version , packet1.board_version , packet1.flight_custom_version , packet1.middleware_custom_version , packet1.os_custom_version , packet1.vendor_id , packet1.product_id , packet1.uid , packet1.uid2 );
7044 mavlink_msg_autopilot_version_decode(&msg, &packet2);
7045 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7046
7047 memset(&packet2, 0, sizeof(packet2));
7048 mavlink_msg_autopilot_version_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.capabilities , packet1.flight_sw_version , packet1.middleware_sw_version , packet1.os_sw_version , packet1.board_version , packet1.flight_custom_version , packet1.middleware_custom_version , packet1.os_custom_version , packet1.vendor_id , packet1.product_id , packet1.uid , packet1.uid2 );
7049 mavlink_msg_autopilot_version_decode(&msg, &packet2);
7050 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7051
7052 memset(&packet2, 0, sizeof(packet2));
7053 mavlink_msg_to_send_buffer(buffer, &msg);
7054 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7055 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7056 }
7057 mavlink_msg_autopilot_version_decode(last_msg, &packet2);
7058 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7059
7060 memset(&packet2, 0, sizeof(packet2));
7061 mavlink_msg_autopilot_version_send(MAVLINK_COMM_1 , packet1.capabilities , packet1.flight_sw_version , packet1.middleware_sw_version , packet1.os_sw_version , packet1.board_version , packet1.flight_custom_version , packet1.middleware_custom_version , packet1.os_custom_version , packet1.vendor_id , packet1.product_id , packet1.uid , packet1.uid2 );
7062 mavlink_msg_autopilot_version_decode(last_msg, &packet2);
7063 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7064}
7065
7066static void mavlink_test_landing_target(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7067{
7068#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7069 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7070 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LANDING_TARGET >= 256) {
7071 return;
7072 }
7073#endif
7074 mavlink_message_t msg;
7075 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7076 uint16_t i;
7077 mavlink_landing_target_t packet_in = {
7078 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,89,156,227.0,255.0,283.0,{ 311.0, 312.0, 313.0, 314.0 },51,118
7079 };
7080 mavlink_landing_target_t packet1, packet2;
7081 memset(&packet1, 0, sizeof(packet1));
7082 packet1.time_usec = packet_in.time_usec;
7083 packet1.angle_x = packet_in.angle_x;
7084 packet1.angle_y = packet_in.angle_y;
7085 packet1.distance = packet_in.distance;
7086 packet1.size_x = packet_in.size_x;
7087 packet1.size_y = packet_in.size_y;
7088 packet1.target_num = packet_in.target_num;
7089 packet1.frame = packet_in.frame;
7090 packet1.x = packet_in.x;
7091 packet1.y = packet_in.y;
7092 packet1.z = packet_in.z;
7093 packet1.type = packet_in.type;
7094 packet1.position_valid = packet_in.position_valid;
7095
7096 mav_array_memcpy(packet1.q, packet_in.q, sizeof(float)*4);
7097
7098#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7099 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7100 // cope with extensions
7101 memset(MAVLINK_MSG_ID_LANDING_TARGET_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LANDING_TARGET_MIN_LEN);
7102 }
7103#endif
7104 memset(&packet2, 0, sizeof(packet2));
7105 mavlink_msg_landing_target_encode(system_id, component_id, &msg, &packet1);
7106 mavlink_msg_landing_target_decode(&msg, &packet2);
7107 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7108
7109 memset(&packet2, 0, sizeof(packet2));
7110 mavlink_msg_landing_target_pack(system_id, component_id, &msg , packet1.time_usec , packet1.target_num , packet1.frame , packet1.angle_x , packet1.angle_y , packet1.distance , packet1.size_x , packet1.size_y , packet1.x , packet1.y , packet1.z , packet1.q , packet1.type , packet1.position_valid );
7111 mavlink_msg_landing_target_decode(&msg, &packet2);
7112 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7113
7114 memset(&packet2, 0, sizeof(packet2));
7115 mavlink_msg_landing_target_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.target_num , packet1.frame , packet1.angle_x , packet1.angle_y , packet1.distance , packet1.size_x , packet1.size_y , packet1.x , packet1.y , packet1.z , packet1.q , packet1.type , packet1.position_valid );
7116 mavlink_msg_landing_target_decode(&msg, &packet2);
7117 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7118
7119 memset(&packet2, 0, sizeof(packet2));
7120 mavlink_msg_to_send_buffer(buffer, &msg);
7121 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7122 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7123 }
7124 mavlink_msg_landing_target_decode(last_msg, &packet2);
7125 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7126
7127 memset(&packet2, 0, sizeof(packet2));
7128 mavlink_msg_landing_target_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.target_num , packet1.frame , packet1.angle_x , packet1.angle_y , packet1.distance , packet1.size_x , packet1.size_y , packet1.x , packet1.y , packet1.z , packet1.q , packet1.type , packet1.position_valid );
7129 mavlink_msg_landing_target_decode(last_msg, &packet2);
7130 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7131}
7132
7133static void mavlink_test_estimator_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7134{
7135#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7136 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7137 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ESTIMATOR_STATUS >= 256) {
7138 return;
7139 }
7140#endif
7141 mavlink_message_t msg;
7142 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7143 uint16_t i;
7144 mavlink_estimator_status_t packet_in = {
7145 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0,19315
7146 };
7147 mavlink_estimator_status_t packet1, packet2;
7148 memset(&packet1, 0, sizeof(packet1));
7149 packet1.time_usec = packet_in.time_usec;
7150 packet1.vel_ratio = packet_in.vel_ratio;
7151 packet1.pos_horiz_ratio = packet_in.pos_horiz_ratio;
7152 packet1.pos_vert_ratio = packet_in.pos_vert_ratio;
7153 packet1.mag_ratio = packet_in.mag_ratio;
7154 packet1.hagl_ratio = packet_in.hagl_ratio;
7155 packet1.tas_ratio = packet_in.tas_ratio;
7156 packet1.pos_horiz_accuracy = packet_in.pos_horiz_accuracy;
7157 packet1.pos_vert_accuracy = packet_in.pos_vert_accuracy;
7158 packet1.flags = packet_in.flags;
7159
7160
7161#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7162 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7163 // cope with extensions
7164 memset(MAVLINK_MSG_ID_ESTIMATOR_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ESTIMATOR_STATUS_MIN_LEN);
7165 }
7166#endif
7167 memset(&packet2, 0, sizeof(packet2));
7168 mavlink_msg_estimator_status_encode(system_id, component_id, &msg, &packet1);
7169 mavlink_msg_estimator_status_decode(&msg, &packet2);
7170 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7171
7172 memset(&packet2, 0, sizeof(packet2));
7173 mavlink_msg_estimator_status_pack(system_id, component_id, &msg , packet1.time_usec , packet1.flags , packet1.vel_ratio , packet1.pos_horiz_ratio , packet1.pos_vert_ratio , packet1.mag_ratio , packet1.hagl_ratio , packet1.tas_ratio , packet1.pos_horiz_accuracy , packet1.pos_vert_accuracy );
7174 mavlink_msg_estimator_status_decode(&msg, &packet2);
7175 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7176
7177 memset(&packet2, 0, sizeof(packet2));
7178 mavlink_msg_estimator_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.flags , packet1.vel_ratio , packet1.pos_horiz_ratio , packet1.pos_vert_ratio , packet1.mag_ratio , packet1.hagl_ratio , packet1.tas_ratio , packet1.pos_horiz_accuracy , packet1.pos_vert_accuracy );
7179 mavlink_msg_estimator_status_decode(&msg, &packet2);
7180 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7181
7182 memset(&packet2, 0, sizeof(packet2));
7183 mavlink_msg_to_send_buffer(buffer, &msg);
7184 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7185 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7186 }
7187 mavlink_msg_estimator_status_decode(last_msg, &packet2);
7188 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7189
7190 memset(&packet2, 0, sizeof(packet2));
7191 mavlink_msg_estimator_status_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.flags , packet1.vel_ratio , packet1.pos_horiz_ratio , packet1.pos_vert_ratio , packet1.mag_ratio , packet1.hagl_ratio , packet1.tas_ratio , packet1.pos_horiz_accuracy , packet1.pos_vert_accuracy );
7192 mavlink_msg_estimator_status_decode(last_msg, &packet2);
7193 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7194}
7195
7196static void mavlink_test_wind_cov(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7197{
7198#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7199 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7200 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_WIND_COV >= 256) {
7201 return;
7202 }
7203#endif
7204 mavlink_message_t msg;
7205 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7206 uint16_t i;
7207 mavlink_wind_cov_t packet_in = {
7208 93372036854775807ULL,73.0,101.0,129.0,157.0,185.0,213.0,241.0,269.0
7209 };
7210 mavlink_wind_cov_t packet1, packet2;
7211 memset(&packet1, 0, sizeof(packet1));
7212 packet1.time_usec = packet_in.time_usec;
7213 packet1.wind_x = packet_in.wind_x;
7214 packet1.wind_y = packet_in.wind_y;
7215 packet1.wind_z = packet_in.wind_z;
7216 packet1.var_horiz = packet_in.var_horiz;
7217 packet1.var_vert = packet_in.var_vert;
7218 packet1.wind_alt = packet_in.wind_alt;
7219 packet1.horiz_accuracy = packet_in.horiz_accuracy;
7220 packet1.vert_accuracy = packet_in.vert_accuracy;
7221
7222
7223#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7224 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7225 // cope with extensions
7226 memset(MAVLINK_MSG_ID_WIND_COV_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_WIND_COV_MIN_LEN);
7227 }
7228#endif
7229 memset(&packet2, 0, sizeof(packet2));
7230 mavlink_msg_wind_cov_encode(system_id, component_id, &msg, &packet1);
7231 mavlink_msg_wind_cov_decode(&msg, &packet2);
7232 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7233
7234 memset(&packet2, 0, sizeof(packet2));
7235 mavlink_msg_wind_cov_pack(system_id, component_id, &msg , packet1.time_usec , packet1.wind_x , packet1.wind_y , packet1.wind_z , packet1.var_horiz , packet1.var_vert , packet1.wind_alt , packet1.horiz_accuracy , packet1.vert_accuracy );
7236 mavlink_msg_wind_cov_decode(&msg, &packet2);
7237 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7238
7239 memset(&packet2, 0, sizeof(packet2));
7240 mavlink_msg_wind_cov_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.wind_x , packet1.wind_y , packet1.wind_z , packet1.var_horiz , packet1.var_vert , packet1.wind_alt , packet1.horiz_accuracy , packet1.vert_accuracy );
7241 mavlink_msg_wind_cov_decode(&msg, &packet2);
7242 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7243
7244 memset(&packet2, 0, sizeof(packet2));
7245 mavlink_msg_to_send_buffer(buffer, &msg);
7246 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7247 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7248 }
7249 mavlink_msg_wind_cov_decode(last_msg, &packet2);
7250 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7251
7252 memset(&packet2, 0, sizeof(packet2));
7253 mavlink_msg_wind_cov_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.wind_x , packet1.wind_y , packet1.wind_z , packet1.var_horiz , packet1.var_vert , packet1.wind_alt , packet1.horiz_accuracy , packet1.vert_accuracy );
7254 mavlink_msg_wind_cov_decode(last_msg, &packet2);
7255 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7256}
7257
7258static void mavlink_test_gps_input(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7259{
7260#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7261 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7262 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GPS_INPUT >= 256) {
7263 return;
7264 }
7265#endif
7266 mavlink_message_t msg;
7267 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7268 uint16_t i;
7269 mavlink_gps_input_t packet_in = {
7270 93372036854775807ULL,963497880,963498088,963498296,157.0,185.0,213.0,241.0,269.0,297.0,325.0,353.0,381.0,20147,20251,185,252,63
7271 };
7272 mavlink_gps_input_t packet1, packet2;
7273 memset(&packet1, 0, sizeof(packet1));
7274 packet1.time_usec = packet_in.time_usec;
7275 packet1.time_week_ms = packet_in.time_week_ms;
7276 packet1.lat = packet_in.lat;
7277 packet1.lon = packet_in.lon;
7278 packet1.alt = packet_in.alt;
7279 packet1.hdop = packet_in.hdop;
7280 packet1.vdop = packet_in.vdop;
7281 packet1.vn = packet_in.vn;
7282 packet1.ve = packet_in.ve;
7283 packet1.vd = packet_in.vd;
7284 packet1.speed_accuracy = packet_in.speed_accuracy;
7285 packet1.horiz_accuracy = packet_in.horiz_accuracy;
7286 packet1.vert_accuracy = packet_in.vert_accuracy;
7287 packet1.ignore_flags = packet_in.ignore_flags;
7288 packet1.time_week = packet_in.time_week;
7289 packet1.gps_id = packet_in.gps_id;
7290 packet1.fix_type = packet_in.fix_type;
7291 packet1.satellites_visible = packet_in.satellites_visible;
7292
7293
7294#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7295 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7296 // cope with extensions
7297 memset(MAVLINK_MSG_ID_GPS_INPUT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GPS_INPUT_MIN_LEN);
7298 }
7299#endif
7300 memset(&packet2, 0, sizeof(packet2));
7301 mavlink_msg_gps_input_encode(system_id, component_id, &msg, &packet1);
7302 mavlink_msg_gps_input_decode(&msg, &packet2);
7303 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7304
7305 memset(&packet2, 0, sizeof(packet2));
7306 mavlink_msg_gps_input_pack(system_id, component_id, &msg , packet1.time_usec , packet1.gps_id , packet1.ignore_flags , packet1.time_week_ms , packet1.time_week , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.hdop , packet1.vdop , packet1.vn , packet1.ve , packet1.vd , packet1.speed_accuracy , packet1.horiz_accuracy , packet1.vert_accuracy , packet1.satellites_visible );
7307 mavlink_msg_gps_input_decode(&msg, &packet2);
7308 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7309
7310 memset(&packet2, 0, sizeof(packet2));
7311 mavlink_msg_gps_input_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.gps_id , packet1.ignore_flags , packet1.time_week_ms , packet1.time_week , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.hdop , packet1.vdop , packet1.vn , packet1.ve , packet1.vd , packet1.speed_accuracy , packet1.horiz_accuracy , packet1.vert_accuracy , packet1.satellites_visible );
7312 mavlink_msg_gps_input_decode(&msg, &packet2);
7313 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7314
7315 memset(&packet2, 0, sizeof(packet2));
7316 mavlink_msg_to_send_buffer(buffer, &msg);
7317 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7318 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7319 }
7320 mavlink_msg_gps_input_decode(last_msg, &packet2);
7321 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7322
7323 memset(&packet2, 0, sizeof(packet2));
7324 mavlink_msg_gps_input_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.gps_id , packet1.ignore_flags , packet1.time_week_ms , packet1.time_week , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.hdop , packet1.vdop , packet1.vn , packet1.ve , packet1.vd , packet1.speed_accuracy , packet1.horiz_accuracy , packet1.vert_accuracy , packet1.satellites_visible );
7325 mavlink_msg_gps_input_decode(last_msg, &packet2);
7326 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7327}
7328
7329static void mavlink_test_gps_rtcm_data(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7330{
7331#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7332 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7333 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GPS_RTCM_DATA >= 256) {
7334 return;
7335 }
7336#endif
7337 mavlink_message_t msg;
7338 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7339 uint16_t i;
7340 mavlink_gps_rtcm_data_t packet_in = {
7341 5,72,{ 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62 }
7342 };
7343 mavlink_gps_rtcm_data_t packet1, packet2;
7344 memset(&packet1, 0, sizeof(packet1));
7345 packet1.flags = packet_in.flags;
7346 packet1.len = packet_in.len;
7347
7348 mav_array_memcpy(packet1.data, packet_in.data, sizeof(uint8_t)*180);
7349
7350#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7351 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7352 // cope with extensions
7353 memset(MAVLINK_MSG_ID_GPS_RTCM_DATA_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GPS_RTCM_DATA_MIN_LEN);
7354 }
7355#endif
7356 memset(&packet2, 0, sizeof(packet2));
7357 mavlink_msg_gps_rtcm_data_encode(system_id, component_id, &msg, &packet1);
7358 mavlink_msg_gps_rtcm_data_decode(&msg, &packet2);
7359 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7360
7361 memset(&packet2, 0, sizeof(packet2));
7362 mavlink_msg_gps_rtcm_data_pack(system_id, component_id, &msg , packet1.flags , packet1.len , packet1.data );
7363 mavlink_msg_gps_rtcm_data_decode(&msg, &packet2);
7364 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7365
7366 memset(&packet2, 0, sizeof(packet2));
7367 mavlink_msg_gps_rtcm_data_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.flags , packet1.len , packet1.data );
7368 mavlink_msg_gps_rtcm_data_decode(&msg, &packet2);
7369 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7370
7371 memset(&packet2, 0, sizeof(packet2));
7372 mavlink_msg_to_send_buffer(buffer, &msg);
7373 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7374 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7375 }
7376 mavlink_msg_gps_rtcm_data_decode(last_msg, &packet2);
7377 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7378
7379 memset(&packet2, 0, sizeof(packet2));
7380 mavlink_msg_gps_rtcm_data_send(MAVLINK_COMM_1 , packet1.flags , packet1.len , packet1.data );
7381 mavlink_msg_gps_rtcm_data_decode(last_msg, &packet2);
7382 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7383}
7384
7385static void mavlink_test_high_latency(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7386{
7387#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7388 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7389 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HIGH_LATENCY >= 256) {
7390 return;
7391 }
7392#endif
7393 mavlink_message_t msg;
7394 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7395 uint16_t i;
7396 mavlink_high_latency_t packet_in = {
7397 963497464,963497672,963497880,17859,17963,18067,18171,18275,18379,18483,211,22,89,156,223,34,101,168,235,46,113,180,247,58
7398 };
7399 mavlink_high_latency_t packet1, packet2;
7400 memset(&packet1, 0, sizeof(packet1));
7401 packet1.custom_mode = packet_in.custom_mode;
7402 packet1.latitude = packet_in.latitude;
7403 packet1.longitude = packet_in.longitude;
7404 packet1.roll = packet_in.roll;
7405 packet1.pitch = packet_in.pitch;
7406 packet1.heading = packet_in.heading;
7407 packet1.heading_sp = packet_in.heading_sp;
7408 packet1.altitude_amsl = packet_in.altitude_amsl;
7409 packet1.altitude_sp = packet_in.altitude_sp;
7410 packet1.wp_distance = packet_in.wp_distance;
7411 packet1.base_mode = packet_in.base_mode;
7412 packet1.landed_state = packet_in.landed_state;
7413 packet1.throttle = packet_in.throttle;
7414 packet1.airspeed = packet_in.airspeed;
7415 packet1.airspeed_sp = packet_in.airspeed_sp;
7416 packet1.groundspeed = packet_in.groundspeed;
7417 packet1.climb_rate = packet_in.climb_rate;
7418 packet1.gps_nsat = packet_in.gps_nsat;
7419 packet1.gps_fix_type = packet_in.gps_fix_type;
7420 packet1.battery_remaining = packet_in.battery_remaining;
7421 packet1.temperature = packet_in.temperature;
7422 packet1.temperature_air = packet_in.temperature_air;
7423 packet1.failsafe = packet_in.failsafe;
7424 packet1.wp_num = packet_in.wp_num;
7425
7426
7427#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7428 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7429 // cope with extensions
7430 memset(MAVLINK_MSG_ID_HIGH_LATENCY_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HIGH_LATENCY_MIN_LEN);
7431 }
7432#endif
7433 memset(&packet2, 0, sizeof(packet2));
7434 mavlink_msg_high_latency_encode(system_id, component_id, &msg, &packet1);
7435 mavlink_msg_high_latency_decode(&msg, &packet2);
7436 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7437
7438 memset(&packet2, 0, sizeof(packet2));
7439 mavlink_msg_high_latency_pack(system_id, component_id, &msg , packet1.base_mode , packet1.custom_mode , packet1.landed_state , packet1.roll , packet1.pitch , packet1.heading , packet1.throttle , packet1.heading_sp , packet1.latitude , packet1.longitude , packet1.altitude_amsl , packet1.altitude_sp , packet1.airspeed , packet1.airspeed_sp , packet1.groundspeed , packet1.climb_rate , packet1.gps_nsat , packet1.gps_fix_type , packet1.battery_remaining , packet1.temperature , packet1.temperature_air , packet1.failsafe , packet1.wp_num , packet1.wp_distance );
7440 mavlink_msg_high_latency_decode(&msg, &packet2);
7441 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7442
7443 memset(&packet2, 0, sizeof(packet2));
7444 mavlink_msg_high_latency_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.base_mode , packet1.custom_mode , packet1.landed_state , packet1.roll , packet1.pitch , packet1.heading , packet1.throttle , packet1.heading_sp , packet1.latitude , packet1.longitude , packet1.altitude_amsl , packet1.altitude_sp , packet1.airspeed , packet1.airspeed_sp , packet1.groundspeed , packet1.climb_rate , packet1.gps_nsat , packet1.gps_fix_type , packet1.battery_remaining , packet1.temperature , packet1.temperature_air , packet1.failsafe , packet1.wp_num , packet1.wp_distance );
7445 mavlink_msg_high_latency_decode(&msg, &packet2);
7446 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7447
7448 memset(&packet2, 0, sizeof(packet2));
7449 mavlink_msg_to_send_buffer(buffer, &msg);
7450 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7451 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7452 }
7453 mavlink_msg_high_latency_decode(last_msg, &packet2);
7454 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7455
7456 memset(&packet2, 0, sizeof(packet2));
7457 mavlink_msg_high_latency_send(MAVLINK_COMM_1 , packet1.base_mode , packet1.custom_mode , packet1.landed_state , packet1.roll , packet1.pitch , packet1.heading , packet1.throttle , packet1.heading_sp , packet1.latitude , packet1.longitude , packet1.altitude_amsl , packet1.altitude_sp , packet1.airspeed , packet1.airspeed_sp , packet1.groundspeed , packet1.climb_rate , packet1.gps_nsat , packet1.gps_fix_type , packet1.battery_remaining , packet1.temperature , packet1.temperature_air , packet1.failsafe , packet1.wp_num , packet1.wp_distance );
7458 mavlink_msg_high_latency_decode(last_msg, &packet2);
7459 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7460}
7461
7462static void mavlink_test_vibration(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7463{
7464#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7465 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7466 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_VIBRATION >= 256) {
7467 return;
7468 }
7469#endif
7470 mavlink_message_t msg;
7471 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7472 uint16_t i;
7473 mavlink_vibration_t packet_in = {
7474 93372036854775807ULL,73.0,101.0,129.0,963498504,963498712,963498920
7475 };
7476 mavlink_vibration_t packet1, packet2;
7477 memset(&packet1, 0, sizeof(packet1));
7478 packet1.time_usec = packet_in.time_usec;
7479 packet1.vibration_x = packet_in.vibration_x;
7480 packet1.vibration_y = packet_in.vibration_y;
7481 packet1.vibration_z = packet_in.vibration_z;
7482 packet1.clipping_0 = packet_in.clipping_0;
7483 packet1.clipping_1 = packet_in.clipping_1;
7484 packet1.clipping_2 = packet_in.clipping_2;
7485
7486
7487#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7488 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7489 // cope with extensions
7490 memset(MAVLINK_MSG_ID_VIBRATION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_VIBRATION_MIN_LEN);
7491 }
7492#endif
7493 memset(&packet2, 0, sizeof(packet2));
7494 mavlink_msg_vibration_encode(system_id, component_id, &msg, &packet1);
7495 mavlink_msg_vibration_decode(&msg, &packet2);
7496 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7497
7498 memset(&packet2, 0, sizeof(packet2));
7499 mavlink_msg_vibration_pack(system_id, component_id, &msg , packet1.time_usec , packet1.vibration_x , packet1.vibration_y , packet1.vibration_z , packet1.clipping_0 , packet1.clipping_1 , packet1.clipping_2 );
7500 mavlink_msg_vibration_decode(&msg, &packet2);
7501 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7502
7503 memset(&packet2, 0, sizeof(packet2));
7504 mavlink_msg_vibration_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.vibration_x , packet1.vibration_y , packet1.vibration_z , packet1.clipping_0 , packet1.clipping_1 , packet1.clipping_2 );
7505 mavlink_msg_vibration_decode(&msg, &packet2);
7506 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7507
7508 memset(&packet2, 0, sizeof(packet2));
7509 mavlink_msg_to_send_buffer(buffer, &msg);
7510 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7511 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7512 }
7513 mavlink_msg_vibration_decode(last_msg, &packet2);
7514 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7515
7516 memset(&packet2, 0, sizeof(packet2));
7517 mavlink_msg_vibration_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.vibration_x , packet1.vibration_y , packet1.vibration_z , packet1.clipping_0 , packet1.clipping_1 , packet1.clipping_2 );
7518 mavlink_msg_vibration_decode(last_msg, &packet2);
7519 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7520}
7521
7522static void mavlink_test_home_position(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7523{
7524#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7525 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7526 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_HOME_POSITION >= 256) {
7527 return;
7528 }
7529#endif
7530 mavlink_message_t msg;
7531 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7532 uint16_t i;
7533 mavlink_home_position_t packet_in = {
7534 963497464,963497672,963497880,101.0,129.0,157.0,{ 185.0, 186.0, 187.0, 188.0 },297.0,325.0,353.0,93372036854779083ULL
7535 };
7536 mavlink_home_position_t packet1, packet2;
7537 memset(&packet1, 0, sizeof(packet1));
7538 packet1.latitude = packet_in.latitude;
7539 packet1.longitude = packet_in.longitude;
7540 packet1.altitude = packet_in.altitude;
7541 packet1.x = packet_in.x;
7542 packet1.y = packet_in.y;
7543 packet1.z = packet_in.z;
7544 packet1.approach_x = packet_in.approach_x;
7545 packet1.approach_y = packet_in.approach_y;
7546 packet1.approach_z = packet_in.approach_z;
7547 packet1.time_usec = packet_in.time_usec;
7548
7549 mav_array_memcpy(packet1.q, packet_in.q, sizeof(float)*4);
7550
7551#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7552 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7553 // cope with extensions
7554 memset(MAVLINK_MSG_ID_HOME_POSITION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_HOME_POSITION_MIN_LEN);
7555 }
7556#endif
7557 memset(&packet2, 0, sizeof(packet2));
7558 mavlink_msg_home_position_encode(system_id, component_id, &msg, &packet1);
7559 mavlink_msg_home_position_decode(&msg, &packet2);
7560 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7561
7562 memset(&packet2, 0, sizeof(packet2));
7563 mavlink_msg_home_position_pack(system_id, component_id, &msg , packet1.latitude , packet1.longitude , packet1.altitude , packet1.x , packet1.y , packet1.z , packet1.q , packet1.approach_x , packet1.approach_y , packet1.approach_z , packet1.time_usec );
7564 mavlink_msg_home_position_decode(&msg, &packet2);
7565 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7566
7567 memset(&packet2, 0, sizeof(packet2));
7568 mavlink_msg_home_position_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.latitude , packet1.longitude , packet1.altitude , packet1.x , packet1.y , packet1.z , packet1.q , packet1.approach_x , packet1.approach_y , packet1.approach_z , packet1.time_usec );
7569 mavlink_msg_home_position_decode(&msg, &packet2);
7570 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7571
7572 memset(&packet2, 0, sizeof(packet2));
7573 mavlink_msg_to_send_buffer(buffer, &msg);
7574 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7575 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7576 }
7577 mavlink_msg_home_position_decode(last_msg, &packet2);
7578 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7579
7580 memset(&packet2, 0, sizeof(packet2));
7581 mavlink_msg_home_position_send(MAVLINK_COMM_1 , packet1.latitude , packet1.longitude , packet1.altitude , packet1.x , packet1.y , packet1.z , packet1.q , packet1.approach_x , packet1.approach_y , packet1.approach_z , packet1.time_usec );
7582 mavlink_msg_home_position_decode(last_msg, &packet2);
7583 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7584}
7585
7586static void mavlink_test_set_home_position(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7587{
7588#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7589 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7590 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SET_HOME_POSITION >= 256) {
7591 return;
7592 }
7593#endif
7594 mavlink_message_t msg;
7595 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7596 uint16_t i;
7597 mavlink_set_home_position_t packet_in = {
7598 963497464,963497672,963497880,101.0,129.0,157.0,{ 185.0, 186.0, 187.0, 188.0 },297.0,325.0,353.0,161,93372036854779146ULL
7599 };
7600 mavlink_set_home_position_t packet1, packet2;
7601 memset(&packet1, 0, sizeof(packet1));
7602 packet1.latitude = packet_in.latitude;
7603 packet1.longitude = packet_in.longitude;
7604 packet1.altitude = packet_in.altitude;
7605 packet1.x = packet_in.x;
7606 packet1.y = packet_in.y;
7607 packet1.z = packet_in.z;
7608 packet1.approach_x = packet_in.approach_x;
7609 packet1.approach_y = packet_in.approach_y;
7610 packet1.approach_z = packet_in.approach_z;
7611 packet1.target_system = packet_in.target_system;
7612 packet1.time_usec = packet_in.time_usec;
7613
7614 mav_array_memcpy(packet1.q, packet_in.q, sizeof(float)*4);
7615
7616#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7617 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7618 // cope with extensions
7619 memset(MAVLINK_MSG_ID_SET_HOME_POSITION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SET_HOME_POSITION_MIN_LEN);
7620 }
7621#endif
7622 memset(&packet2, 0, sizeof(packet2));
7623 mavlink_msg_set_home_position_encode(system_id, component_id, &msg, &packet1);
7624 mavlink_msg_set_home_position_decode(&msg, &packet2);
7625 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7626
7627 memset(&packet2, 0, sizeof(packet2));
7628 mavlink_msg_set_home_position_pack(system_id, component_id, &msg , packet1.target_system , packet1.latitude , packet1.longitude , packet1.altitude , packet1.x , packet1.y , packet1.z , packet1.q , packet1.approach_x , packet1.approach_y , packet1.approach_z , packet1.time_usec );
7629 mavlink_msg_set_home_position_decode(&msg, &packet2);
7630 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7631
7632 memset(&packet2, 0, sizeof(packet2));
7633 mavlink_msg_set_home_position_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.latitude , packet1.longitude , packet1.altitude , packet1.x , packet1.y , packet1.z , packet1.q , packet1.approach_x , packet1.approach_y , packet1.approach_z , packet1.time_usec );
7634 mavlink_msg_set_home_position_decode(&msg, &packet2);
7635 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7636
7637 memset(&packet2, 0, sizeof(packet2));
7638 mavlink_msg_to_send_buffer(buffer, &msg);
7639 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7640 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7641 }
7642 mavlink_msg_set_home_position_decode(last_msg, &packet2);
7643 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7644
7645 memset(&packet2, 0, sizeof(packet2));
7646 mavlink_msg_set_home_position_send(MAVLINK_COMM_1 , packet1.target_system , packet1.latitude , packet1.longitude , packet1.altitude , packet1.x , packet1.y , packet1.z , packet1.q , packet1.approach_x , packet1.approach_y , packet1.approach_z , packet1.time_usec );
7647 mavlink_msg_set_home_position_decode(last_msg, &packet2);
7648 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7649}
7650
7651static void mavlink_test_message_interval(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7652{
7653#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7654 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7655 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MESSAGE_INTERVAL >= 256) {
7656 return;
7657 }
7658#endif
7659 mavlink_message_t msg;
7660 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7661 uint16_t i;
7662 mavlink_message_interval_t packet_in = {
7663 963497464,17443
7664 };
7665 mavlink_message_interval_t packet1, packet2;
7666 memset(&packet1, 0, sizeof(packet1));
7667 packet1.interval_us = packet_in.interval_us;
7668 packet1.message_id = packet_in.message_id;
7669
7670
7671#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7672 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7673 // cope with extensions
7674 memset(MAVLINK_MSG_ID_MESSAGE_INTERVAL_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MESSAGE_INTERVAL_MIN_LEN);
7675 }
7676#endif
7677 memset(&packet2, 0, sizeof(packet2));
7678 mavlink_msg_message_interval_encode(system_id, component_id, &msg, &packet1);
7679 mavlink_msg_message_interval_decode(&msg, &packet2);
7680 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7681
7682 memset(&packet2, 0, sizeof(packet2));
7683 mavlink_msg_message_interval_pack(system_id, component_id, &msg , packet1.message_id , packet1.interval_us );
7684 mavlink_msg_message_interval_decode(&msg, &packet2);
7685 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7686
7687 memset(&packet2, 0, sizeof(packet2));
7688 mavlink_msg_message_interval_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.message_id , packet1.interval_us );
7689 mavlink_msg_message_interval_decode(&msg, &packet2);
7690 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7691
7692 memset(&packet2, 0, sizeof(packet2));
7693 mavlink_msg_to_send_buffer(buffer, &msg);
7694 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7695 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7696 }
7697 mavlink_msg_message_interval_decode(last_msg, &packet2);
7698 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7699
7700 memset(&packet2, 0, sizeof(packet2));
7701 mavlink_msg_message_interval_send(MAVLINK_COMM_1 , packet1.message_id , packet1.interval_us );
7702 mavlink_msg_message_interval_decode(last_msg, &packet2);
7703 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7704}
7705
7706static void mavlink_test_extended_sys_state(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7707{
7708#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7709 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7710 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_EXTENDED_SYS_STATE >= 256) {
7711 return;
7712 }
7713#endif
7714 mavlink_message_t msg;
7715 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7716 uint16_t i;
7717 mavlink_extended_sys_state_t packet_in = {
7718 5,72
7719 };
7720 mavlink_extended_sys_state_t packet1, packet2;
7721 memset(&packet1, 0, sizeof(packet1));
7722 packet1.vtol_state = packet_in.vtol_state;
7723 packet1.landed_state = packet_in.landed_state;
7724
7725
7726#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7727 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7728 // cope with extensions
7729 memset(MAVLINK_MSG_ID_EXTENDED_SYS_STATE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_EXTENDED_SYS_STATE_MIN_LEN);
7730 }
7731#endif
7732 memset(&packet2, 0, sizeof(packet2));
7733 mavlink_msg_extended_sys_state_encode(system_id, component_id, &msg, &packet1);
7734 mavlink_msg_extended_sys_state_decode(&msg, &packet2);
7735 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7736
7737 memset(&packet2, 0, sizeof(packet2));
7738 mavlink_msg_extended_sys_state_pack(system_id, component_id, &msg , packet1.vtol_state , packet1.landed_state );
7739 mavlink_msg_extended_sys_state_decode(&msg, &packet2);
7740 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7741
7742 memset(&packet2, 0, sizeof(packet2));
7743 mavlink_msg_extended_sys_state_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.vtol_state , packet1.landed_state );
7744 mavlink_msg_extended_sys_state_decode(&msg, &packet2);
7745 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7746
7747 memset(&packet2, 0, sizeof(packet2));
7748 mavlink_msg_to_send_buffer(buffer, &msg);
7749 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7750 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7751 }
7752 mavlink_msg_extended_sys_state_decode(last_msg, &packet2);
7753 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7754
7755 memset(&packet2, 0, sizeof(packet2));
7756 mavlink_msg_extended_sys_state_send(MAVLINK_COMM_1 , packet1.vtol_state , packet1.landed_state );
7757 mavlink_msg_extended_sys_state_decode(last_msg, &packet2);
7758 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7759}
7760
7761static void mavlink_test_adsb_vehicle(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7762{
7763#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7764 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7765 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ADSB_VEHICLE >= 256) {
7766 return;
7767 }
7768#endif
7769 mavlink_message_t msg;
7770 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7771 uint16_t i;
7772 mavlink_adsb_vehicle_t packet_in = {
7773 963497464,963497672,963497880,963498088,18067,18171,18275,18379,18483,211,"BCDEFGHI",113,180
7774 };
7775 mavlink_adsb_vehicle_t packet1, packet2;
7776 memset(&packet1, 0, sizeof(packet1));
7777 packet1.ICAO_address = packet_in.ICAO_address;
7778 packet1.lat = packet_in.lat;
7779 packet1.lon = packet_in.lon;
7780 packet1.altitude = packet_in.altitude;
7781 packet1.heading = packet_in.heading;
7782 packet1.hor_velocity = packet_in.hor_velocity;
7783 packet1.ver_velocity = packet_in.ver_velocity;
7784 packet1.flags = packet_in.flags;
7785 packet1.squawk = packet_in.squawk;
7786 packet1.altitude_type = packet_in.altitude_type;
7787 packet1.emitter_type = packet_in.emitter_type;
7788 packet1.tslc = packet_in.tslc;
7789
7790 mav_array_memcpy(packet1.callsign, packet_in.callsign, sizeof(char)*9);
7791
7792#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7793 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7794 // cope with extensions
7795 memset(MAVLINK_MSG_ID_ADSB_VEHICLE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ADSB_VEHICLE_MIN_LEN);
7796 }
7797#endif
7798 memset(&packet2, 0, sizeof(packet2));
7799 mavlink_msg_adsb_vehicle_encode(system_id, component_id, &msg, &packet1);
7800 mavlink_msg_adsb_vehicle_decode(&msg, &packet2);
7801 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7802
7803 memset(&packet2, 0, sizeof(packet2));
7804 mavlink_msg_adsb_vehicle_pack(system_id, component_id, &msg , packet1.ICAO_address , packet1.lat , packet1.lon , packet1.altitude_type , packet1.altitude , packet1.heading , packet1.hor_velocity , packet1.ver_velocity , packet1.callsign , packet1.emitter_type , packet1.tslc , packet1.flags , packet1.squawk );
7805 mavlink_msg_adsb_vehicle_decode(&msg, &packet2);
7806 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7807
7808 memset(&packet2, 0, sizeof(packet2));
7809 mavlink_msg_adsb_vehicle_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.ICAO_address , packet1.lat , packet1.lon , packet1.altitude_type , packet1.altitude , packet1.heading , packet1.hor_velocity , packet1.ver_velocity , packet1.callsign , packet1.emitter_type , packet1.tslc , packet1.flags , packet1.squawk );
7810 mavlink_msg_adsb_vehicle_decode(&msg, &packet2);
7811 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7812
7813 memset(&packet2, 0, sizeof(packet2));
7814 mavlink_msg_to_send_buffer(buffer, &msg);
7815 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7816 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7817 }
7818 mavlink_msg_adsb_vehicle_decode(last_msg, &packet2);
7819 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7820
7821 memset(&packet2, 0, sizeof(packet2));
7822 mavlink_msg_adsb_vehicle_send(MAVLINK_COMM_1 , packet1.ICAO_address , packet1.lat , packet1.lon , packet1.altitude_type , packet1.altitude , packet1.heading , packet1.hor_velocity , packet1.ver_velocity , packet1.callsign , packet1.emitter_type , packet1.tslc , packet1.flags , packet1.squawk );
7823 mavlink_msg_adsb_vehicle_decode(last_msg, &packet2);
7824 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7825}
7826
7827static void mavlink_test_collision(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7828{
7829#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7830 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7831 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_COLLISION >= 256) {
7832 return;
7833 }
7834#endif
7835 mavlink_message_t msg;
7836 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7837 uint16_t i;
7838 mavlink_collision_t packet_in = {
7839 963497464,45.0,73.0,101.0,53,120,187
7840 };
7841 mavlink_collision_t packet1, packet2;
7842 memset(&packet1, 0, sizeof(packet1));
7843 packet1.id = packet_in.id;
7844 packet1.time_to_minimum_delta = packet_in.time_to_minimum_delta;
7845 packet1.altitude_minimum_delta = packet_in.altitude_minimum_delta;
7846 packet1.horizontal_minimum_delta = packet_in.horizontal_minimum_delta;
7847 packet1.src = packet_in.src;
7848 packet1.action = packet_in.action;
7849 packet1.threat_level = packet_in.threat_level;
7850
7851
7852#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7853 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7854 // cope with extensions
7855 memset(MAVLINK_MSG_ID_COLLISION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_COLLISION_MIN_LEN);
7856 }
7857#endif
7858 memset(&packet2, 0, sizeof(packet2));
7859 mavlink_msg_collision_encode(system_id, component_id, &msg, &packet1);
7860 mavlink_msg_collision_decode(&msg, &packet2);
7861 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7862
7863 memset(&packet2, 0, sizeof(packet2));
7864 mavlink_msg_collision_pack(system_id, component_id, &msg , packet1.src , packet1.id , packet1.action , packet1.threat_level , packet1.time_to_minimum_delta , packet1.altitude_minimum_delta , packet1.horizontal_minimum_delta );
7865 mavlink_msg_collision_decode(&msg, &packet2);
7866 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7867
7868 memset(&packet2, 0, sizeof(packet2));
7869 mavlink_msg_collision_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.src , packet1.id , packet1.action , packet1.threat_level , packet1.time_to_minimum_delta , packet1.altitude_minimum_delta , packet1.horizontal_minimum_delta );
7870 mavlink_msg_collision_decode(&msg, &packet2);
7871 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7872
7873 memset(&packet2, 0, sizeof(packet2));
7874 mavlink_msg_to_send_buffer(buffer, &msg);
7875 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7876 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7877 }
7878 mavlink_msg_collision_decode(last_msg, &packet2);
7879 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7880
7881 memset(&packet2, 0, sizeof(packet2));
7882 mavlink_msg_collision_send(MAVLINK_COMM_1 , packet1.src , packet1.id , packet1.action , packet1.threat_level , packet1.time_to_minimum_delta , packet1.altitude_minimum_delta , packet1.horizontal_minimum_delta );
7883 mavlink_msg_collision_decode(last_msg, &packet2);
7884 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7885}
7886
7887static void mavlink_test_v2_extension(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7888{
7889#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7890 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7891 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_V2_EXTENSION >= 256) {
7892 return;
7893 }
7894#endif
7895 mavlink_message_t msg;
7896 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7897 uint16_t i;
7898 mavlink_v2_extension_t packet_in = {
7899 17235,139,206,17,{ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76 }
7900 };
7901 mavlink_v2_extension_t packet1, packet2;
7902 memset(&packet1, 0, sizeof(packet1));
7903 packet1.message_type = packet_in.message_type;
7904 packet1.target_network = packet_in.target_network;
7905 packet1.target_system = packet_in.target_system;
7906 packet1.target_component = packet_in.target_component;
7907
7908 mav_array_memcpy(packet1.payload, packet_in.payload, sizeof(uint8_t)*249);
7909
7910#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7911 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7912 // cope with extensions
7913 memset(MAVLINK_MSG_ID_V2_EXTENSION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_V2_EXTENSION_MIN_LEN);
7914 }
7915#endif
7916 memset(&packet2, 0, sizeof(packet2));
7917 mavlink_msg_v2_extension_encode(system_id, component_id, &msg, &packet1);
7918 mavlink_msg_v2_extension_decode(&msg, &packet2);
7919 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7920
7921 memset(&packet2, 0, sizeof(packet2));
7922 mavlink_msg_v2_extension_pack(system_id, component_id, &msg , packet1.target_network , packet1.target_system , packet1.target_component , packet1.message_type , packet1.payload );
7923 mavlink_msg_v2_extension_decode(&msg, &packet2);
7924 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7925
7926 memset(&packet2, 0, sizeof(packet2));
7927 mavlink_msg_v2_extension_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_network , packet1.target_system , packet1.target_component , packet1.message_type , packet1.payload );
7928 mavlink_msg_v2_extension_decode(&msg, &packet2);
7929 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7930
7931 memset(&packet2, 0, sizeof(packet2));
7932 mavlink_msg_to_send_buffer(buffer, &msg);
7933 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7934 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7935 }
7936 mavlink_msg_v2_extension_decode(last_msg, &packet2);
7937 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7938
7939 memset(&packet2, 0, sizeof(packet2));
7940 mavlink_msg_v2_extension_send(MAVLINK_COMM_1 , packet1.target_network , packet1.target_system , packet1.target_component , packet1.message_type , packet1.payload );
7941 mavlink_msg_v2_extension_decode(last_msg, &packet2);
7942 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7943}
7944
7945static void mavlink_test_memory_vect(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
7946{
7947#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7948 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
7949 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MEMORY_VECT >= 256) {
7950 return;
7951 }
7952#endif
7953 mavlink_message_t msg;
7954 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
7955 uint16_t i;
7956 mavlink_memory_vect_t packet_in = {
7957 17235,139,206,{ 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48 }
7958 };
7959 mavlink_memory_vect_t packet1, packet2;
7960 memset(&packet1, 0, sizeof(packet1));
7961 packet1.address = packet_in.address;
7962 packet1.ver = packet_in.ver;
7963 packet1.type = packet_in.type;
7964
7965 mav_array_memcpy(packet1.value, packet_in.value, sizeof(int8_t)*32);
7966
7967#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
7968 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
7969 // cope with extensions
7970 memset(MAVLINK_MSG_ID_MEMORY_VECT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MEMORY_VECT_MIN_LEN);
7971 }
7972#endif
7973 memset(&packet2, 0, sizeof(packet2));
7974 mavlink_msg_memory_vect_encode(system_id, component_id, &msg, &packet1);
7975 mavlink_msg_memory_vect_decode(&msg, &packet2);
7976 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7977
7978 memset(&packet2, 0, sizeof(packet2));
7979 mavlink_msg_memory_vect_pack(system_id, component_id, &msg , packet1.address , packet1.ver , packet1.type , packet1.value );
7980 mavlink_msg_memory_vect_decode(&msg, &packet2);
7981 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7982
7983 memset(&packet2, 0, sizeof(packet2));
7984 mavlink_msg_memory_vect_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.address , packet1.ver , packet1.type , packet1.value );
7985 mavlink_msg_memory_vect_decode(&msg, &packet2);
7986 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7987
7988 memset(&packet2, 0, sizeof(packet2));
7989 mavlink_msg_to_send_buffer(buffer, &msg);
7990 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
7991 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
7992 }
7993 mavlink_msg_memory_vect_decode(last_msg, &packet2);
7994 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
7995
7996 memset(&packet2, 0, sizeof(packet2));
7997 mavlink_msg_memory_vect_send(MAVLINK_COMM_1 , packet1.address , packet1.ver , packet1.type , packet1.value );
7998 mavlink_msg_memory_vect_decode(last_msg, &packet2);
7999 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8000}
8001
8002static void mavlink_test_debug_vect(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8003{
8004#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8005 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8006 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_DEBUG_VECT >= 256) {
8007 return;
8008 }
8009#endif
8010 mavlink_message_t msg;
8011 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8012 uint16_t i;
8013 mavlink_debug_vect_t packet_in = {
8014 93372036854775807ULL,73.0,101.0,129.0,"UVWXYZABC"
8015 };
8016 mavlink_debug_vect_t packet1, packet2;
8017 memset(&packet1, 0, sizeof(packet1));
8018 packet1.time_usec = packet_in.time_usec;
8019 packet1.x = packet_in.x;
8020 packet1.y = packet_in.y;
8021 packet1.z = packet_in.z;
8022
8023 mav_array_memcpy(packet1.name, packet_in.name, sizeof(char)*10);
8024
8025#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8026 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8027 // cope with extensions
8028 memset(MAVLINK_MSG_ID_DEBUG_VECT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_DEBUG_VECT_MIN_LEN);
8029 }
8030#endif
8031 memset(&packet2, 0, sizeof(packet2));
8032 mavlink_msg_debug_vect_encode(system_id, component_id, &msg, &packet1);
8033 mavlink_msg_debug_vect_decode(&msg, &packet2);
8034 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8035
8036 memset(&packet2, 0, sizeof(packet2));
8037 mavlink_msg_debug_vect_pack(system_id, component_id, &msg , packet1.name , packet1.time_usec , packet1.x , packet1.y , packet1.z );
8038 mavlink_msg_debug_vect_decode(&msg, &packet2);
8039 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8040
8041 memset(&packet2, 0, sizeof(packet2));
8042 mavlink_msg_debug_vect_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.name , packet1.time_usec , packet1.x , packet1.y , packet1.z );
8043 mavlink_msg_debug_vect_decode(&msg, &packet2);
8044 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8045
8046 memset(&packet2, 0, sizeof(packet2));
8047 mavlink_msg_to_send_buffer(buffer, &msg);
8048 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8049 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8050 }
8051 mavlink_msg_debug_vect_decode(last_msg, &packet2);
8052 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8053
8054 memset(&packet2, 0, sizeof(packet2));
8055 mavlink_msg_debug_vect_send(MAVLINK_COMM_1 , packet1.name , packet1.time_usec , packet1.x , packet1.y , packet1.z );
8056 mavlink_msg_debug_vect_decode(last_msg, &packet2);
8057 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8058}
8059
8060static void mavlink_test_named_value_float(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8061{
8062#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8063 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8064 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_NAMED_VALUE_FLOAT >= 256) {
8065 return;
8066 }
8067#endif
8068 mavlink_message_t msg;
8069 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8070 uint16_t i;
8071 mavlink_named_value_float_t packet_in = {
8072 963497464,45.0,"IJKLMNOPQ"
8073 };
8074 mavlink_named_value_float_t packet1, packet2;
8075 memset(&packet1, 0, sizeof(packet1));
8076 packet1.time_boot_ms = packet_in.time_boot_ms;
8077 packet1.value = packet_in.value;
8078
8079 mav_array_memcpy(packet1.name, packet_in.name, sizeof(char)*10);
8080
8081#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8082 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8083 // cope with extensions
8084 memset(MAVLINK_MSG_ID_NAMED_VALUE_FLOAT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_NAMED_VALUE_FLOAT_MIN_LEN);
8085 }
8086#endif
8087 memset(&packet2, 0, sizeof(packet2));
8088 mavlink_msg_named_value_float_encode(system_id, component_id, &msg, &packet1);
8089 mavlink_msg_named_value_float_decode(&msg, &packet2);
8090 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8091
8092 memset(&packet2, 0, sizeof(packet2));
8093 mavlink_msg_named_value_float_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.name , packet1.value );
8094 mavlink_msg_named_value_float_decode(&msg, &packet2);
8095 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8096
8097 memset(&packet2, 0, sizeof(packet2));
8098 mavlink_msg_named_value_float_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.name , packet1.value );
8099 mavlink_msg_named_value_float_decode(&msg, &packet2);
8100 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8101
8102 memset(&packet2, 0, sizeof(packet2));
8103 mavlink_msg_to_send_buffer(buffer, &msg);
8104 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8105 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8106 }
8107 mavlink_msg_named_value_float_decode(last_msg, &packet2);
8108 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8109
8110 memset(&packet2, 0, sizeof(packet2));
8111 mavlink_msg_named_value_float_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.name , packet1.value );
8112 mavlink_msg_named_value_float_decode(last_msg, &packet2);
8113 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8114}
8115
8116static void mavlink_test_named_value_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8117{
8118#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8119 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8120 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_NAMED_VALUE_INT >= 256) {
8121 return;
8122 }
8123#endif
8124 mavlink_message_t msg;
8125 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8126 uint16_t i;
8127 mavlink_named_value_int_t packet_in = {
8128 963497464,963497672,"IJKLMNOPQ"
8129 };
8130 mavlink_named_value_int_t packet1, packet2;
8131 memset(&packet1, 0, sizeof(packet1));
8132 packet1.time_boot_ms = packet_in.time_boot_ms;
8133 packet1.value = packet_in.value;
8134
8135 mav_array_memcpy(packet1.name, packet_in.name, sizeof(char)*10);
8136
8137#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8138 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8139 // cope with extensions
8140 memset(MAVLINK_MSG_ID_NAMED_VALUE_INT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_NAMED_VALUE_INT_MIN_LEN);
8141 }
8142#endif
8143 memset(&packet2, 0, sizeof(packet2));
8144 mavlink_msg_named_value_int_encode(system_id, component_id, &msg, &packet1);
8145 mavlink_msg_named_value_int_decode(&msg, &packet2);
8146 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8147
8148 memset(&packet2, 0, sizeof(packet2));
8149 mavlink_msg_named_value_int_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.name , packet1.value );
8150 mavlink_msg_named_value_int_decode(&msg, &packet2);
8151 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8152
8153 memset(&packet2, 0, sizeof(packet2));
8154 mavlink_msg_named_value_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.name , packet1.value );
8155 mavlink_msg_named_value_int_decode(&msg, &packet2);
8156 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8157
8158 memset(&packet2, 0, sizeof(packet2));
8159 mavlink_msg_to_send_buffer(buffer, &msg);
8160 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8161 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8162 }
8163 mavlink_msg_named_value_int_decode(last_msg, &packet2);
8164 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8165
8166 memset(&packet2, 0, sizeof(packet2));
8167 mavlink_msg_named_value_int_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.name , packet1.value );
8168 mavlink_msg_named_value_int_decode(last_msg, &packet2);
8169 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8170}
8171
8172static void mavlink_test_statustext(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8173{
8174#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8175 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8176 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_STATUSTEXT >= 256) {
8177 return;
8178 }
8179#endif
8180 mavlink_message_t msg;
8181 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8182 uint16_t i;
8183 mavlink_statustext_t packet_in = {
8184 5,"BCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX"
8185 };
8186 mavlink_statustext_t packet1, packet2;
8187 memset(&packet1, 0, sizeof(packet1));
8188 packet1.severity = packet_in.severity;
8189
8190 mav_array_memcpy(packet1.text, packet_in.text, sizeof(char)*50);
8191
8192#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8193 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8194 // cope with extensions
8195 memset(MAVLINK_MSG_ID_STATUSTEXT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_STATUSTEXT_MIN_LEN);
8196 }
8197#endif
8198 memset(&packet2, 0, sizeof(packet2));
8199 mavlink_msg_statustext_encode(system_id, component_id, &msg, &packet1);
8200 mavlink_msg_statustext_decode(&msg, &packet2);
8201 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8202
8203 memset(&packet2, 0, sizeof(packet2));
8204 mavlink_msg_statustext_pack(system_id, component_id, &msg , packet1.severity , packet1.text );
8205 mavlink_msg_statustext_decode(&msg, &packet2);
8206 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8207
8208 memset(&packet2, 0, sizeof(packet2));
8209 mavlink_msg_statustext_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.severity , packet1.text );
8210 mavlink_msg_statustext_decode(&msg, &packet2);
8211 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8212
8213 memset(&packet2, 0, sizeof(packet2));
8214 mavlink_msg_to_send_buffer(buffer, &msg);
8215 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8216 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8217 }
8218 mavlink_msg_statustext_decode(last_msg, &packet2);
8219 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8220
8221 memset(&packet2, 0, sizeof(packet2));
8222 mavlink_msg_statustext_send(MAVLINK_COMM_1 , packet1.severity , packet1.text );
8223 mavlink_msg_statustext_decode(last_msg, &packet2);
8224 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8225}
8226
8227static void mavlink_test_debug(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8228{
8229#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8230 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8231 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_DEBUG >= 256) {
8232 return;
8233 }
8234#endif
8235 mavlink_message_t msg;
8236 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8237 uint16_t i;
8238 mavlink_debug_t packet_in = {
8239 963497464,45.0,29
8240 };
8241 mavlink_debug_t packet1, packet2;
8242 memset(&packet1, 0, sizeof(packet1));
8243 packet1.time_boot_ms = packet_in.time_boot_ms;
8244 packet1.value = packet_in.value;
8245 packet1.ind = packet_in.ind;
8246
8247
8248#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8249 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8250 // cope with extensions
8251 memset(MAVLINK_MSG_ID_DEBUG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_DEBUG_MIN_LEN);
8252 }
8253#endif
8254 memset(&packet2, 0, sizeof(packet2));
8255 mavlink_msg_debug_encode(system_id, component_id, &msg, &packet1);
8256 mavlink_msg_debug_decode(&msg, &packet2);
8257 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8258
8259 memset(&packet2, 0, sizeof(packet2));
8260 mavlink_msg_debug_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.ind , packet1.value );
8261 mavlink_msg_debug_decode(&msg, &packet2);
8262 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8263
8264 memset(&packet2, 0, sizeof(packet2));
8265 mavlink_msg_debug_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.ind , packet1.value );
8266 mavlink_msg_debug_decode(&msg, &packet2);
8267 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8268
8269 memset(&packet2, 0, sizeof(packet2));
8270 mavlink_msg_to_send_buffer(buffer, &msg);
8271 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8272 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8273 }
8274 mavlink_msg_debug_decode(last_msg, &packet2);
8275 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8276
8277 memset(&packet2, 0, sizeof(packet2));
8278 mavlink_msg_debug_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.ind , packet1.value );
8279 mavlink_msg_debug_decode(last_msg, &packet2);
8280 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8281}
8282
8283static void mavlink_test_setup_signing(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8284{
8285#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8286 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8287 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SETUP_SIGNING >= 256) {
8288 return;
8289 }
8290#endif
8291 mavlink_message_t msg;
8292 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8293 uint16_t i;
8294 mavlink_setup_signing_t packet_in = {
8295 93372036854775807ULL,29,96,{ 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194 }
8296 };
8297 mavlink_setup_signing_t packet1, packet2;
8298 memset(&packet1, 0, sizeof(packet1));
8299 packet1.initial_timestamp = packet_in.initial_timestamp;
8300 packet1.target_system = packet_in.target_system;
8301 packet1.target_component = packet_in.target_component;
8302
8303 mav_array_memcpy(packet1.secret_key, packet_in.secret_key, sizeof(uint8_t)*32);
8304
8305#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8306 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8307 // cope with extensions
8308 memset(MAVLINK_MSG_ID_SETUP_SIGNING_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SETUP_SIGNING_MIN_LEN);
8309 }
8310#endif
8311 memset(&packet2, 0, sizeof(packet2));
8312 mavlink_msg_setup_signing_encode(system_id, component_id, &msg, &packet1);
8313 mavlink_msg_setup_signing_decode(&msg, &packet2);
8314 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8315
8316 memset(&packet2, 0, sizeof(packet2));
8317 mavlink_msg_setup_signing_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.secret_key , packet1.initial_timestamp );
8318 mavlink_msg_setup_signing_decode(&msg, &packet2);
8319 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8320
8321 memset(&packet2, 0, sizeof(packet2));
8322 mavlink_msg_setup_signing_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.secret_key , packet1.initial_timestamp );
8323 mavlink_msg_setup_signing_decode(&msg, &packet2);
8324 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8325
8326 memset(&packet2, 0, sizeof(packet2));
8327 mavlink_msg_to_send_buffer(buffer, &msg);
8328 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8329 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8330 }
8331 mavlink_msg_setup_signing_decode(last_msg, &packet2);
8332 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8333
8334 memset(&packet2, 0, sizeof(packet2));
8335 mavlink_msg_setup_signing_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.secret_key , packet1.initial_timestamp );
8336 mavlink_msg_setup_signing_decode(last_msg, &packet2);
8337 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8338}
8339
8340static void mavlink_test_button_change(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8341{
8342#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8343 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8344 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_BUTTON_CHANGE >= 256) {
8345 return;
8346 }
8347#endif
8348 mavlink_message_t msg;
8349 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8350 uint16_t i;
8351 mavlink_button_change_t packet_in = {
8352 963497464,963497672,29
8353 };
8354 mavlink_button_change_t packet1, packet2;
8355 memset(&packet1, 0, sizeof(packet1));
8356 packet1.time_boot_ms = packet_in.time_boot_ms;
8357 packet1.last_change_ms = packet_in.last_change_ms;
8358 packet1.state = packet_in.state;
8359
8360
8361#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8362 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8363 // cope with extensions
8364 memset(MAVLINK_MSG_ID_BUTTON_CHANGE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_BUTTON_CHANGE_MIN_LEN);
8365 }
8366#endif
8367 memset(&packet2, 0, sizeof(packet2));
8368 mavlink_msg_button_change_encode(system_id, component_id, &msg, &packet1);
8369 mavlink_msg_button_change_decode(&msg, &packet2);
8370 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8371
8372 memset(&packet2, 0, sizeof(packet2));
8373 mavlink_msg_button_change_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.last_change_ms , packet1.state );
8374 mavlink_msg_button_change_decode(&msg, &packet2);
8375 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8376
8377 memset(&packet2, 0, sizeof(packet2));
8378 mavlink_msg_button_change_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.last_change_ms , packet1.state );
8379 mavlink_msg_button_change_decode(&msg, &packet2);
8380 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8381
8382 memset(&packet2, 0, sizeof(packet2));
8383 mavlink_msg_to_send_buffer(buffer, &msg);
8384 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8385 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8386 }
8387 mavlink_msg_button_change_decode(last_msg, &packet2);
8388 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8389
8390 memset(&packet2, 0, sizeof(packet2));
8391 mavlink_msg_button_change_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.last_change_ms , packet1.state );
8392 mavlink_msg_button_change_decode(last_msg, &packet2);
8393 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8394}
8395
8396static void mavlink_test_play_tune(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8397{
8398#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8399 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8400 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PLAY_TUNE >= 256) {
8401 return;
8402 }
8403#endif
8404 mavlink_message_t msg;
8405 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8406 uint16_t i;
8407 mavlink_play_tune_t packet_in = {
8408 5,72,"CDEFGHIJKLMNOPQRSTUVWXYZABCDE"
8409 };
8410 mavlink_play_tune_t packet1, packet2;
8411 memset(&packet1, 0, sizeof(packet1));
8412 packet1.target_system = packet_in.target_system;
8413 packet1.target_component = packet_in.target_component;
8414
8415 mav_array_memcpy(packet1.tune, packet_in.tune, sizeof(char)*30);
8416
8417#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8418 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8419 // cope with extensions
8420 memset(MAVLINK_MSG_ID_PLAY_TUNE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PLAY_TUNE_MIN_LEN);
8421 }
8422#endif
8423 memset(&packet2, 0, sizeof(packet2));
8424 mavlink_msg_play_tune_encode(system_id, component_id, &msg, &packet1);
8425 mavlink_msg_play_tune_decode(&msg, &packet2);
8426 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8427
8428 memset(&packet2, 0, sizeof(packet2));
8429 mavlink_msg_play_tune_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.tune );
8430 mavlink_msg_play_tune_decode(&msg, &packet2);
8431 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8432
8433 memset(&packet2, 0, sizeof(packet2));
8434 mavlink_msg_play_tune_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.tune );
8435 mavlink_msg_play_tune_decode(&msg, &packet2);
8436 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8437
8438 memset(&packet2, 0, sizeof(packet2));
8439 mavlink_msg_to_send_buffer(buffer, &msg);
8440 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8441 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8442 }
8443 mavlink_msg_play_tune_decode(last_msg, &packet2);
8444 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8445
8446 memset(&packet2, 0, sizeof(packet2));
8447 mavlink_msg_play_tune_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.tune );
8448 mavlink_msg_play_tune_decode(last_msg, &packet2);
8449 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8450}
8451
8452static void mavlink_test_camera_information(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8453{
8454#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8455 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8456 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_CAMERA_INFORMATION >= 256) {
8457 return;
8458 }
8459#endif
8460 mavlink_message_t msg;
8461 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8462 uint16_t i;
8463 mavlink_camera_information_t packet_in = {
8464 963497464,963497672,73.0,101.0,129.0,963498504,18483,18587,18691,{ 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254 },{ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94 },159,"RSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"
8465 };
8466 mavlink_camera_information_t packet1, packet2;
8467 memset(&packet1, 0, sizeof(packet1));
8468 packet1.time_boot_ms = packet_in.time_boot_ms;
8469 packet1.firmware_version = packet_in.firmware_version;
8470 packet1.focal_length = packet_in.focal_length;
8471 packet1.sensor_size_h = packet_in.sensor_size_h;
8472 packet1.sensor_size_v = packet_in.sensor_size_v;
8473 packet1.flags = packet_in.flags;
8474 packet1.resolution_h = packet_in.resolution_h;
8475 packet1.resolution_v = packet_in.resolution_v;
8476 packet1.cam_definition_version = packet_in.cam_definition_version;
8477 packet1.lens_id = packet_in.lens_id;
8478
8479 mav_array_memcpy(packet1.vendor_name, packet_in.vendor_name, sizeof(uint8_t)*32);
8480 mav_array_memcpy(packet1.model_name, packet_in.model_name, sizeof(uint8_t)*32);
8481 mav_array_memcpy(packet1.cam_definition_uri, packet_in.cam_definition_uri, sizeof(char)*140);
8482
8483#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8484 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8485 // cope with extensions
8486 memset(MAVLINK_MSG_ID_CAMERA_INFORMATION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CAMERA_INFORMATION_MIN_LEN);
8487 }
8488#endif
8489 memset(&packet2, 0, sizeof(packet2));
8490 mavlink_msg_camera_information_encode(system_id, component_id, &msg, &packet1);
8491 mavlink_msg_camera_information_decode(&msg, &packet2);
8492 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8493
8494 memset(&packet2, 0, sizeof(packet2));
8495 mavlink_msg_camera_information_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.vendor_name , packet1.model_name , packet1.firmware_version , packet1.focal_length , packet1.sensor_size_h , packet1.sensor_size_v , packet1.resolution_h , packet1.resolution_v , packet1.lens_id , packet1.flags , packet1.cam_definition_version , packet1.cam_definition_uri );
8496 mavlink_msg_camera_information_decode(&msg, &packet2);
8497 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8498
8499 memset(&packet2, 0, sizeof(packet2));
8500 mavlink_msg_camera_information_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.vendor_name , packet1.model_name , packet1.firmware_version , packet1.focal_length , packet1.sensor_size_h , packet1.sensor_size_v , packet1.resolution_h , packet1.resolution_v , packet1.lens_id , packet1.flags , packet1.cam_definition_version , packet1.cam_definition_uri );
8501 mavlink_msg_camera_information_decode(&msg, &packet2);
8502 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8503
8504 memset(&packet2, 0, sizeof(packet2));
8505 mavlink_msg_to_send_buffer(buffer, &msg);
8506 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8507 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8508 }
8509 mavlink_msg_camera_information_decode(last_msg, &packet2);
8510 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8511
8512 memset(&packet2, 0, sizeof(packet2));
8513 mavlink_msg_camera_information_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.vendor_name , packet1.model_name , packet1.firmware_version , packet1.focal_length , packet1.sensor_size_h , packet1.sensor_size_v , packet1.resolution_h , packet1.resolution_v , packet1.lens_id , packet1.flags , packet1.cam_definition_version , packet1.cam_definition_uri );
8514 mavlink_msg_camera_information_decode(last_msg, &packet2);
8515 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8516}
8517
8518static void mavlink_test_camera_settings(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8519{
8520#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8521 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8522 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_CAMERA_SETTINGS >= 256) {
8523 return;
8524 }
8525#endif
8526 mavlink_message_t msg;
8527 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8528 uint16_t i;
8529 mavlink_camera_settings_t packet_in = {
8530 963497464,17
8531 };
8532 mavlink_camera_settings_t packet1, packet2;
8533 memset(&packet1, 0, sizeof(packet1));
8534 packet1.time_boot_ms = packet_in.time_boot_ms;
8535 packet1.mode_id = packet_in.mode_id;
8536
8537
8538#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8539 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8540 // cope with extensions
8541 memset(MAVLINK_MSG_ID_CAMERA_SETTINGS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CAMERA_SETTINGS_MIN_LEN);
8542 }
8543#endif
8544 memset(&packet2, 0, sizeof(packet2));
8545 mavlink_msg_camera_settings_encode(system_id, component_id, &msg, &packet1);
8546 mavlink_msg_camera_settings_decode(&msg, &packet2);
8547 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8548
8549 memset(&packet2, 0, sizeof(packet2));
8550 mavlink_msg_camera_settings_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.mode_id );
8551 mavlink_msg_camera_settings_decode(&msg, &packet2);
8552 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8553
8554 memset(&packet2, 0, sizeof(packet2));
8555 mavlink_msg_camera_settings_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.mode_id );
8556 mavlink_msg_camera_settings_decode(&msg, &packet2);
8557 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8558
8559 memset(&packet2, 0, sizeof(packet2));
8560 mavlink_msg_to_send_buffer(buffer, &msg);
8561 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8562 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8563 }
8564 mavlink_msg_camera_settings_decode(last_msg, &packet2);
8565 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8566
8567 memset(&packet2, 0, sizeof(packet2));
8568 mavlink_msg_camera_settings_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.mode_id );
8569 mavlink_msg_camera_settings_decode(last_msg, &packet2);
8570 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8571}
8572
8573static void mavlink_test_storage_information(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8574{
8575#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8576 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8577 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_STORAGE_INFORMATION >= 256) {
8578 return;
8579 }
8580#endif
8581 mavlink_message_t msg;
8582 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8583 uint16_t i;
8584 mavlink_storage_information_t packet_in = {
8585 963497464,45.0,73.0,101.0,129.0,157.0,77,144,211
8586 };
8587 mavlink_storage_information_t packet1, packet2;
8588 memset(&packet1, 0, sizeof(packet1));
8589 packet1.time_boot_ms = packet_in.time_boot_ms;
8590 packet1.total_capacity = packet_in.total_capacity;
8591 packet1.used_capacity = packet_in.used_capacity;
8592 packet1.available_capacity = packet_in.available_capacity;
8593 packet1.read_speed = packet_in.read_speed;
8594 packet1.write_speed = packet_in.write_speed;
8595 packet1.storage_id = packet_in.storage_id;
8596 packet1.storage_count = packet_in.storage_count;
8597 packet1.status = packet_in.status;
8598
8599
8600#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8601 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8602 // cope with extensions
8603 memset(MAVLINK_MSG_ID_STORAGE_INFORMATION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_STORAGE_INFORMATION_MIN_LEN);
8604 }
8605#endif
8606 memset(&packet2, 0, sizeof(packet2));
8607 mavlink_msg_storage_information_encode(system_id, component_id, &msg, &packet1);
8608 mavlink_msg_storage_information_decode(&msg, &packet2);
8609 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8610
8611 memset(&packet2, 0, sizeof(packet2));
8612 mavlink_msg_storage_information_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.storage_id , packet1.storage_count , packet1.status , packet1.total_capacity , packet1.used_capacity , packet1.available_capacity , packet1.read_speed , packet1.write_speed );
8613 mavlink_msg_storage_information_decode(&msg, &packet2);
8614 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8615
8616 memset(&packet2, 0, sizeof(packet2));
8617 mavlink_msg_storage_information_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.storage_id , packet1.storage_count , packet1.status , packet1.total_capacity , packet1.used_capacity , packet1.available_capacity , packet1.read_speed , packet1.write_speed );
8618 mavlink_msg_storage_information_decode(&msg, &packet2);
8619 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8620
8621 memset(&packet2, 0, sizeof(packet2));
8622 mavlink_msg_to_send_buffer(buffer, &msg);
8623 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8624 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8625 }
8626 mavlink_msg_storage_information_decode(last_msg, &packet2);
8627 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8628
8629 memset(&packet2, 0, sizeof(packet2));
8630 mavlink_msg_storage_information_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.storage_id , packet1.storage_count , packet1.status , packet1.total_capacity , packet1.used_capacity , packet1.available_capacity , packet1.read_speed , packet1.write_speed );
8631 mavlink_msg_storage_information_decode(last_msg, &packet2);
8632 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8633}
8634
8635static void mavlink_test_camera_capture_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8636{
8637#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8638 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8639 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_CAMERA_CAPTURE_STATUS >= 256) {
8640 return;
8641 }
8642#endif
8643 mavlink_message_t msg;
8644 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8645 uint16_t i;
8646 mavlink_camera_capture_status_t packet_in = {
8647 963497464,45.0,963497880,101.0,53,120
8648 };
8649 mavlink_camera_capture_status_t packet1, packet2;
8650 memset(&packet1, 0, sizeof(packet1));
8651 packet1.time_boot_ms = packet_in.time_boot_ms;
8652 packet1.image_interval = packet_in.image_interval;
8653 packet1.recording_time_ms = packet_in.recording_time_ms;
8654 packet1.available_capacity = packet_in.available_capacity;
8655 packet1.image_status = packet_in.image_status;
8656 packet1.video_status = packet_in.video_status;
8657
8658
8659#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8660 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8661 // cope with extensions
8662 memset(MAVLINK_MSG_ID_CAMERA_CAPTURE_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CAMERA_CAPTURE_STATUS_MIN_LEN);
8663 }
8664#endif
8665 memset(&packet2, 0, sizeof(packet2));
8666 mavlink_msg_camera_capture_status_encode(system_id, component_id, &msg, &packet1);
8667 mavlink_msg_camera_capture_status_decode(&msg, &packet2);
8668 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8669
8670 memset(&packet2, 0, sizeof(packet2));
8671 mavlink_msg_camera_capture_status_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.image_status , packet1.video_status , packet1.image_interval , packet1.recording_time_ms , packet1.available_capacity );
8672 mavlink_msg_camera_capture_status_decode(&msg, &packet2);
8673 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8674
8675 memset(&packet2, 0, sizeof(packet2));
8676 mavlink_msg_camera_capture_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.image_status , packet1.video_status , packet1.image_interval , packet1.recording_time_ms , packet1.available_capacity );
8677 mavlink_msg_camera_capture_status_decode(&msg, &packet2);
8678 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8679
8680 memset(&packet2, 0, sizeof(packet2));
8681 mavlink_msg_to_send_buffer(buffer, &msg);
8682 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8683 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8684 }
8685 mavlink_msg_camera_capture_status_decode(last_msg, &packet2);
8686 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8687
8688 memset(&packet2, 0, sizeof(packet2));
8689 mavlink_msg_camera_capture_status_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.image_status , packet1.video_status , packet1.image_interval , packet1.recording_time_ms , packet1.available_capacity );
8690 mavlink_msg_camera_capture_status_decode(last_msg, &packet2);
8691 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8692}
8693
8694static void mavlink_test_camera_image_captured(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8695{
8696#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8697 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8698 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED >= 256) {
8699 return;
8700 }
8701#endif
8702 mavlink_message_t msg;
8703 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8704 uint16_t i;
8705 mavlink_camera_image_captured_t packet_in = {
8706 93372036854775807ULL,963497880,963498088,963498296,963498504,963498712,{ 213.0, 214.0, 215.0, 216.0 },963499752,149,216,"YZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRST"
8707 };
8708 mavlink_camera_image_captured_t packet1, packet2;
8709 memset(&packet1, 0, sizeof(packet1));
8710 packet1.time_utc = packet_in.time_utc;
8711 packet1.time_boot_ms = packet_in.time_boot_ms;
8712 packet1.lat = packet_in.lat;
8713 packet1.lon = packet_in.lon;
8714 packet1.alt = packet_in.alt;
8715 packet1.relative_alt = packet_in.relative_alt;
8716 packet1.image_index = packet_in.image_index;
8717 packet1.camera_id = packet_in.camera_id;
8718 packet1.capture_result = packet_in.capture_result;
8719
8720 mav_array_memcpy(packet1.q, packet_in.q, sizeof(float)*4);
8721 mav_array_memcpy(packet1.file_url, packet_in.file_url, sizeof(char)*205);
8722
8723#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8724 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8725 // cope with extensions
8726 memset(MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CAMERA_IMAGE_CAPTURED_MIN_LEN);
8727 }
8728#endif
8729 memset(&packet2, 0, sizeof(packet2));
8730 mavlink_msg_camera_image_captured_encode(system_id, component_id, &msg, &packet1);
8731 mavlink_msg_camera_image_captured_decode(&msg, &packet2);
8732 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8733
8734 memset(&packet2, 0, sizeof(packet2));
8735 mavlink_msg_camera_image_captured_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.time_utc , packet1.camera_id , packet1.lat , packet1.lon , packet1.alt , packet1.relative_alt , packet1.q , packet1.image_index , packet1.capture_result , packet1.file_url );
8736 mavlink_msg_camera_image_captured_decode(&msg, &packet2);
8737 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8738
8739 memset(&packet2, 0, sizeof(packet2));
8740 mavlink_msg_camera_image_captured_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.time_utc , packet1.camera_id , packet1.lat , packet1.lon , packet1.alt , packet1.relative_alt , packet1.q , packet1.image_index , packet1.capture_result , packet1.file_url );
8741 mavlink_msg_camera_image_captured_decode(&msg, &packet2);
8742 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8743
8744 memset(&packet2, 0, sizeof(packet2));
8745 mavlink_msg_to_send_buffer(buffer, &msg);
8746 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8747 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8748 }
8749 mavlink_msg_camera_image_captured_decode(last_msg, &packet2);
8750 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8751
8752 memset(&packet2, 0, sizeof(packet2));
8753 mavlink_msg_camera_image_captured_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.time_utc , packet1.camera_id , packet1.lat , packet1.lon , packet1.alt , packet1.relative_alt , packet1.q , packet1.image_index , packet1.capture_result , packet1.file_url );
8754 mavlink_msg_camera_image_captured_decode(last_msg, &packet2);
8755 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8756}
8757
8758static void mavlink_test_flight_information(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8759{
8760#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8761 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8762 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_FLIGHT_INFORMATION >= 256) {
8763 return;
8764 }
8765#endif
8766 mavlink_message_t msg;
8767 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8768 uint16_t i;
8769 mavlink_flight_information_t packet_in = {
8770 93372036854775807ULL,93372036854776311ULL,93372036854776815ULL,963498712
8771 };
8772 mavlink_flight_information_t packet1, packet2;
8773 memset(&packet1, 0, sizeof(packet1));
8774 packet1.arming_time_utc = packet_in.arming_time_utc;
8775 packet1.takeoff_time_utc = packet_in.takeoff_time_utc;
8776 packet1.flight_uuid = packet_in.flight_uuid;
8777 packet1.time_boot_ms = packet_in.time_boot_ms;
8778
8779
8780#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8781 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8782 // cope with extensions
8783 memset(MAVLINK_MSG_ID_FLIGHT_INFORMATION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_FLIGHT_INFORMATION_MIN_LEN);
8784 }
8785#endif
8786 memset(&packet2, 0, sizeof(packet2));
8787 mavlink_msg_flight_information_encode(system_id, component_id, &msg, &packet1);
8788 mavlink_msg_flight_information_decode(&msg, &packet2);
8789 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8790
8791 memset(&packet2, 0, sizeof(packet2));
8792 mavlink_msg_flight_information_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.arming_time_utc , packet1.takeoff_time_utc , packet1.flight_uuid );
8793 mavlink_msg_flight_information_decode(&msg, &packet2);
8794 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8795
8796 memset(&packet2, 0, sizeof(packet2));
8797 mavlink_msg_flight_information_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.arming_time_utc , packet1.takeoff_time_utc , packet1.flight_uuid );
8798 mavlink_msg_flight_information_decode(&msg, &packet2);
8799 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8800
8801 memset(&packet2, 0, sizeof(packet2));
8802 mavlink_msg_to_send_buffer(buffer, &msg);
8803 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8804 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8805 }
8806 mavlink_msg_flight_information_decode(last_msg, &packet2);
8807 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8808
8809 memset(&packet2, 0, sizeof(packet2));
8810 mavlink_msg_flight_information_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.arming_time_utc , packet1.takeoff_time_utc , packet1.flight_uuid );
8811 mavlink_msg_flight_information_decode(last_msg, &packet2);
8812 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8813}
8814
8815static void mavlink_test_mount_orientation(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8816{
8817#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8818 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8819 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MOUNT_ORIENTATION >= 256) {
8820 return;
8821 }
8822#endif
8823 mavlink_message_t msg;
8824 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8825 uint16_t i;
8826 mavlink_mount_orientation_t packet_in = {
8827 963497464,45.0,73.0,101.0
8828 };
8829 mavlink_mount_orientation_t packet1, packet2;
8830 memset(&packet1, 0, sizeof(packet1));
8831 packet1.time_boot_ms = packet_in.time_boot_ms;
8832 packet1.roll = packet_in.roll;
8833 packet1.pitch = packet_in.pitch;
8834 packet1.yaw = packet_in.yaw;
8835
8836
8837#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8838 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8839 // cope with extensions
8840 memset(MAVLINK_MSG_ID_MOUNT_ORIENTATION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MOUNT_ORIENTATION_MIN_LEN);
8841 }
8842#endif
8843 memset(&packet2, 0, sizeof(packet2));
8844 mavlink_msg_mount_orientation_encode(system_id, component_id, &msg, &packet1);
8845 mavlink_msg_mount_orientation_decode(&msg, &packet2);
8846 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8847
8848 memset(&packet2, 0, sizeof(packet2));
8849 mavlink_msg_mount_orientation_pack(system_id, component_id, &msg , packet1.time_boot_ms , packet1.roll , packet1.pitch , packet1.yaw );
8850 mavlink_msg_mount_orientation_decode(&msg, &packet2);
8851 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8852
8853 memset(&packet2, 0, sizeof(packet2));
8854 mavlink_msg_mount_orientation_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_boot_ms , packet1.roll , packet1.pitch , packet1.yaw );
8855 mavlink_msg_mount_orientation_decode(&msg, &packet2);
8856 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8857
8858 memset(&packet2, 0, sizeof(packet2));
8859 mavlink_msg_to_send_buffer(buffer, &msg);
8860 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8861 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8862 }
8863 mavlink_msg_mount_orientation_decode(last_msg, &packet2);
8864 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8865
8866 memset(&packet2, 0, sizeof(packet2));
8867 mavlink_msg_mount_orientation_send(MAVLINK_COMM_1 , packet1.time_boot_ms , packet1.roll , packet1.pitch , packet1.yaw );
8868 mavlink_msg_mount_orientation_decode(last_msg, &packet2);
8869 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8870}
8871
8872static void mavlink_test_logging_data(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8873{
8874#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8875 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8876 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOGGING_DATA >= 256) {
8877 return;
8878 }
8879#endif
8880 mavlink_message_t msg;
8881 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8882 uint16_t i;
8883 mavlink_logging_data_t packet_in = {
8884 17235,139,206,17,84,{ 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143 }
8885 };
8886 mavlink_logging_data_t packet1, packet2;
8887 memset(&packet1, 0, sizeof(packet1));
8888 packet1.sequence = packet_in.sequence;
8889 packet1.target_system = packet_in.target_system;
8890 packet1.target_component = packet_in.target_component;
8891 packet1.length = packet_in.length;
8892 packet1.first_message_offset = packet_in.first_message_offset;
8893
8894 mav_array_memcpy(packet1.data, packet_in.data, sizeof(uint8_t)*249);
8895
8896#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8897 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8898 // cope with extensions
8899 memset(MAVLINK_MSG_ID_LOGGING_DATA_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOGGING_DATA_MIN_LEN);
8900 }
8901#endif
8902 memset(&packet2, 0, sizeof(packet2));
8903 mavlink_msg_logging_data_encode(system_id, component_id, &msg, &packet1);
8904 mavlink_msg_logging_data_decode(&msg, &packet2);
8905 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8906
8907 memset(&packet2, 0, sizeof(packet2));
8908 mavlink_msg_logging_data_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.sequence , packet1.length , packet1.first_message_offset , packet1.data );
8909 mavlink_msg_logging_data_decode(&msg, &packet2);
8910 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8911
8912 memset(&packet2, 0, sizeof(packet2));
8913 mavlink_msg_logging_data_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.sequence , packet1.length , packet1.first_message_offset , packet1.data );
8914 mavlink_msg_logging_data_decode(&msg, &packet2);
8915 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8916
8917 memset(&packet2, 0, sizeof(packet2));
8918 mavlink_msg_to_send_buffer(buffer, &msg);
8919 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8920 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8921 }
8922 mavlink_msg_logging_data_decode(last_msg, &packet2);
8923 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8924
8925 memset(&packet2, 0, sizeof(packet2));
8926 mavlink_msg_logging_data_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.sequence , packet1.length , packet1.first_message_offset , packet1.data );
8927 mavlink_msg_logging_data_decode(last_msg, &packet2);
8928 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8929}
8930
8931static void mavlink_test_logging_data_acked(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8932{
8933#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8934 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8935 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOGGING_DATA_ACKED >= 256) {
8936 return;
8937 }
8938#endif
8939 mavlink_message_t msg;
8940 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
8941 uint16_t i;
8942 mavlink_logging_data_acked_t packet_in = {
8943 17235,139,206,17,84,{ 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143 }
8944 };
8945 mavlink_logging_data_acked_t packet1, packet2;
8946 memset(&packet1, 0, sizeof(packet1));
8947 packet1.sequence = packet_in.sequence;
8948 packet1.target_system = packet_in.target_system;
8949 packet1.target_component = packet_in.target_component;
8950 packet1.length = packet_in.length;
8951 packet1.first_message_offset = packet_in.first_message_offset;
8952
8953 mav_array_memcpy(packet1.data, packet_in.data, sizeof(uint8_t)*249);
8954
8955#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8956 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
8957 // cope with extensions
8958 memset(MAVLINK_MSG_ID_LOGGING_DATA_ACKED_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOGGING_DATA_ACKED_MIN_LEN);
8959 }
8960#endif
8961 memset(&packet2, 0, sizeof(packet2));
8962 mavlink_msg_logging_data_acked_encode(system_id, component_id, &msg, &packet1);
8963 mavlink_msg_logging_data_acked_decode(&msg, &packet2);
8964 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8965
8966 memset(&packet2, 0, sizeof(packet2));
8967 mavlink_msg_logging_data_acked_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.sequence , packet1.length , packet1.first_message_offset , packet1.data );
8968 mavlink_msg_logging_data_acked_decode(&msg, &packet2);
8969 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8970
8971 memset(&packet2, 0, sizeof(packet2));
8972 mavlink_msg_logging_data_acked_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.sequence , packet1.length , packet1.first_message_offset , packet1.data );
8973 mavlink_msg_logging_data_acked_decode(&msg, &packet2);
8974 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8975
8976 memset(&packet2, 0, sizeof(packet2));
8977 mavlink_msg_to_send_buffer(buffer, &msg);
8978 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
8979 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
8980 }
8981 mavlink_msg_logging_data_acked_decode(last_msg, &packet2);
8982 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8983
8984 memset(&packet2, 0, sizeof(packet2));
8985 mavlink_msg_logging_data_acked_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.sequence , packet1.length , packet1.first_message_offset , packet1.data );
8986 mavlink_msg_logging_data_acked_decode(last_msg, &packet2);
8987 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
8988}
8989
8990static void mavlink_test_logging_ack(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
8991{
8992#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
8993 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
8994 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_LOGGING_ACK >= 256) {
8995 return;
8996 }
8997#endif
8998 mavlink_message_t msg;
8999 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9000 uint16_t i;
9001 mavlink_logging_ack_t packet_in = {
9002 17235,139,206
9003 };
9004 mavlink_logging_ack_t packet1, packet2;
9005 memset(&packet1, 0, sizeof(packet1));
9006 packet1.sequence = packet_in.sequence;
9007 packet1.target_system = packet_in.target_system;
9008 packet1.target_component = packet_in.target_component;
9009
9010
9011#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9012 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9013 // cope with extensions
9014 memset(MAVLINK_MSG_ID_LOGGING_ACK_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_LOGGING_ACK_MIN_LEN);
9015 }
9016#endif
9017 memset(&packet2, 0, sizeof(packet2));
9018 mavlink_msg_logging_ack_encode(system_id, component_id, &msg, &packet1);
9019 mavlink_msg_logging_ack_decode(&msg, &packet2);
9020 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9021
9022 memset(&packet2, 0, sizeof(packet2));
9023 mavlink_msg_logging_ack_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.sequence );
9024 mavlink_msg_logging_ack_decode(&msg, &packet2);
9025 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9026
9027 memset(&packet2, 0, sizeof(packet2));
9028 mavlink_msg_logging_ack_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.sequence );
9029 mavlink_msg_logging_ack_decode(&msg, &packet2);
9030 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9031
9032 memset(&packet2, 0, sizeof(packet2));
9033 mavlink_msg_to_send_buffer(buffer, &msg);
9034 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9035 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9036 }
9037 mavlink_msg_logging_ack_decode(last_msg, &packet2);
9038 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9039
9040 memset(&packet2, 0, sizeof(packet2));
9041 mavlink_msg_logging_ack_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.sequence );
9042 mavlink_msg_logging_ack_decode(last_msg, &packet2);
9043 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9044}
9045
9046static void mavlink_test_video_stream_information(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9047{
9048#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9049 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9050 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_VIDEO_STREAM_INFORMATION >= 256) {
9051 return;
9052 }
9053#endif
9054 mavlink_message_t msg;
9055 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9056 uint16_t i;
9057 mavlink_video_stream_information_t packet_in = {
9058 17.0,963497672,17651,17755,17859,175,242,"QRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJK"
9059 };
9060 mavlink_video_stream_information_t packet1, packet2;
9061 memset(&packet1, 0, sizeof(packet1));
9062 packet1.framerate = packet_in.framerate;
9063 packet1.bitrate = packet_in.bitrate;
9064 packet1.resolution_h = packet_in.resolution_h;
9065 packet1.resolution_v = packet_in.resolution_v;
9066 packet1.rotation = packet_in.rotation;
9067 packet1.camera_id = packet_in.camera_id;
9068 packet1.status = packet_in.status;
9069
9070 mav_array_memcpy(packet1.uri, packet_in.uri, sizeof(char)*230);
9071
9072#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9073 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9074 // cope with extensions
9075 memset(MAVLINK_MSG_ID_VIDEO_STREAM_INFORMATION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_VIDEO_STREAM_INFORMATION_MIN_LEN);
9076 }
9077#endif
9078 memset(&packet2, 0, sizeof(packet2));
9079 mavlink_msg_video_stream_information_encode(system_id, component_id, &msg, &packet1);
9080 mavlink_msg_video_stream_information_decode(&msg, &packet2);
9081 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9082
9083 memset(&packet2, 0, sizeof(packet2));
9084 mavlink_msg_video_stream_information_pack(system_id, component_id, &msg , packet1.camera_id , packet1.status , packet1.framerate , packet1.resolution_h , packet1.resolution_v , packet1.bitrate , packet1.rotation , packet1.uri );
9085 mavlink_msg_video_stream_information_decode(&msg, &packet2);
9086 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9087
9088 memset(&packet2, 0, sizeof(packet2));
9089 mavlink_msg_video_stream_information_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.camera_id , packet1.status , packet1.framerate , packet1.resolution_h , packet1.resolution_v , packet1.bitrate , packet1.rotation , packet1.uri );
9090 mavlink_msg_video_stream_information_decode(&msg, &packet2);
9091 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9092
9093 memset(&packet2, 0, sizeof(packet2));
9094 mavlink_msg_to_send_buffer(buffer, &msg);
9095 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9096 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9097 }
9098 mavlink_msg_video_stream_information_decode(last_msg, &packet2);
9099 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9100
9101 memset(&packet2, 0, sizeof(packet2));
9102 mavlink_msg_video_stream_information_send(MAVLINK_COMM_1 , packet1.camera_id , packet1.status , packet1.framerate , packet1.resolution_h , packet1.resolution_v , packet1.bitrate , packet1.rotation , packet1.uri );
9103 mavlink_msg_video_stream_information_decode(last_msg, &packet2);
9104 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9105}
9106
9107static void mavlink_test_set_video_stream_settings(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9108{
9109#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9110 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9111 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SET_VIDEO_STREAM_SETTINGS >= 256) {
9112 return;
9113 }
9114#endif
9115 mavlink_message_t msg;
9116 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9117 uint16_t i;
9118 mavlink_set_video_stream_settings_t packet_in = {
9119 17.0,963497672,17651,17755,17859,175,242,53,"RSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL"
9120 };
9121 mavlink_set_video_stream_settings_t packet1, packet2;
9122 memset(&packet1, 0, sizeof(packet1));
9123 packet1.framerate = packet_in.framerate;
9124 packet1.bitrate = packet_in.bitrate;
9125 packet1.resolution_h = packet_in.resolution_h;
9126 packet1.resolution_v = packet_in.resolution_v;
9127 packet1.rotation = packet_in.rotation;
9128 packet1.target_system = packet_in.target_system;
9129 packet1.target_component = packet_in.target_component;
9130 packet1.camera_id = packet_in.camera_id;
9131
9132 mav_array_memcpy(packet1.uri, packet_in.uri, sizeof(char)*230);
9133
9134#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9135 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9136 // cope with extensions
9137 memset(MAVLINK_MSG_ID_SET_VIDEO_STREAM_SETTINGS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SET_VIDEO_STREAM_SETTINGS_MIN_LEN);
9138 }
9139#endif
9140 memset(&packet2, 0, sizeof(packet2));
9141 mavlink_msg_set_video_stream_settings_encode(system_id, component_id, &msg, &packet1);
9142 mavlink_msg_set_video_stream_settings_decode(&msg, &packet2);
9143 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9144
9145 memset(&packet2, 0, sizeof(packet2));
9146 mavlink_msg_set_video_stream_settings_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.camera_id , packet1.framerate , packet1.resolution_h , packet1.resolution_v , packet1.bitrate , packet1.rotation , packet1.uri );
9147 mavlink_msg_set_video_stream_settings_decode(&msg, &packet2);
9148 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9149
9150 memset(&packet2, 0, sizeof(packet2));
9151 mavlink_msg_set_video_stream_settings_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.camera_id , packet1.framerate , packet1.resolution_h , packet1.resolution_v , packet1.bitrate , packet1.rotation , packet1.uri );
9152 mavlink_msg_set_video_stream_settings_decode(&msg, &packet2);
9153 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9154
9155 memset(&packet2, 0, sizeof(packet2));
9156 mavlink_msg_to_send_buffer(buffer, &msg);
9157 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9158 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9159 }
9160 mavlink_msg_set_video_stream_settings_decode(last_msg, &packet2);
9161 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9162
9163 memset(&packet2, 0, sizeof(packet2));
9164 mavlink_msg_set_video_stream_settings_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.camera_id , packet1.framerate , packet1.resolution_h , packet1.resolution_v , packet1.bitrate , packet1.rotation , packet1.uri );
9165 mavlink_msg_set_video_stream_settings_decode(last_msg, &packet2);
9166 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9167}
9168
9169static void mavlink_test_wifi_config_ap(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9170{
9171#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9172 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9173 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_WIFI_CONFIG_AP >= 256) {
9174 return;
9175 }
9176#endif
9177 mavlink_message_t msg;
9178 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9179 uint16_t i;
9180 mavlink_wifi_config_ap_t packet_in = {
9181 "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDE","GHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQ"
9182 };
9183 mavlink_wifi_config_ap_t packet1, packet2;
9184 memset(&packet1, 0, sizeof(packet1));
9185
9186 mav_array_memcpy(packet1.ssid, packet_in.ssid, sizeof(char)*32);
9187 mav_array_memcpy(packet1.password, packet_in.password, sizeof(char)*64);
9188
9189#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9190 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9191 // cope with extensions
9192 memset(MAVLINK_MSG_ID_WIFI_CONFIG_AP_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_WIFI_CONFIG_AP_MIN_LEN);
9193 }
9194#endif
9195 memset(&packet2, 0, sizeof(packet2));
9196 mavlink_msg_wifi_config_ap_encode(system_id, component_id, &msg, &packet1);
9197 mavlink_msg_wifi_config_ap_decode(&msg, &packet2);
9198 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9199
9200 memset(&packet2, 0, sizeof(packet2));
9201 mavlink_msg_wifi_config_ap_pack(system_id, component_id, &msg , packet1.ssid , packet1.password );
9202 mavlink_msg_wifi_config_ap_decode(&msg, &packet2);
9203 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9204
9205 memset(&packet2, 0, sizeof(packet2));
9206 mavlink_msg_wifi_config_ap_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.ssid , packet1.password );
9207 mavlink_msg_wifi_config_ap_decode(&msg, &packet2);
9208 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9209
9210 memset(&packet2, 0, sizeof(packet2));
9211 mavlink_msg_to_send_buffer(buffer, &msg);
9212 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9213 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9214 }
9215 mavlink_msg_wifi_config_ap_decode(last_msg, &packet2);
9216 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9217
9218 memset(&packet2, 0, sizeof(packet2));
9219 mavlink_msg_wifi_config_ap_send(MAVLINK_COMM_1 , packet1.ssid , packet1.password );
9220 mavlink_msg_wifi_config_ap_decode(last_msg, &packet2);
9221 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9222}
9223
9224static void mavlink_test_protocol_version(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9225{
9226#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9227 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9228 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PROTOCOL_VERSION >= 256) {
9229 return;
9230 }
9231#endif
9232 mavlink_message_t msg;
9233 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9234 uint16_t i;
9235 mavlink_protocol_version_t packet_in = {
9236 17235,17339,17443,{ 151, 152, 153, 154, 155, 156, 157, 158 },{ 175, 176, 177, 178, 179, 180, 181, 182 }
9237 };
9238 mavlink_protocol_version_t packet1, packet2;
9239 memset(&packet1, 0, sizeof(packet1));
9240 packet1.version = packet_in.version;
9241 packet1.min_version = packet_in.min_version;
9242 packet1.max_version = packet_in.max_version;
9243
9244 mav_array_memcpy(packet1.spec_version_hash, packet_in.spec_version_hash, sizeof(uint8_t)*8);
9245 mav_array_memcpy(packet1.library_version_hash, packet_in.library_version_hash, sizeof(uint8_t)*8);
9246
9247#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9248 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9249 // cope with extensions
9250 memset(MAVLINK_MSG_ID_PROTOCOL_VERSION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PROTOCOL_VERSION_MIN_LEN);
9251 }
9252#endif
9253 memset(&packet2, 0, sizeof(packet2));
9254 mavlink_msg_protocol_version_encode(system_id, component_id, &msg, &packet1);
9255 mavlink_msg_protocol_version_decode(&msg, &packet2);
9256 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9257
9258 memset(&packet2, 0, sizeof(packet2));
9259 mavlink_msg_protocol_version_pack(system_id, component_id, &msg , packet1.version , packet1.min_version , packet1.max_version , packet1.spec_version_hash , packet1.library_version_hash );
9260 mavlink_msg_protocol_version_decode(&msg, &packet2);
9261 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9262
9263 memset(&packet2, 0, sizeof(packet2));
9264 mavlink_msg_protocol_version_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.version , packet1.min_version , packet1.max_version , packet1.spec_version_hash , packet1.library_version_hash );
9265 mavlink_msg_protocol_version_decode(&msg, &packet2);
9266 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9267
9268 memset(&packet2, 0, sizeof(packet2));
9269 mavlink_msg_to_send_buffer(buffer, &msg);
9270 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9271 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9272 }
9273 mavlink_msg_protocol_version_decode(last_msg, &packet2);
9274 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9275
9276 memset(&packet2, 0, sizeof(packet2));
9277 mavlink_msg_protocol_version_send(MAVLINK_COMM_1 , packet1.version , packet1.min_version , packet1.max_version , packet1.spec_version_hash , packet1.library_version_hash );
9278 mavlink_msg_protocol_version_decode(last_msg, &packet2);
9279 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9280}
9281
9282static void mavlink_test_uavcan_node_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9283{
9284#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9285 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9286 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_UAVCAN_NODE_STATUS >= 256) {
9287 return;
9288 }
9289#endif
9290 mavlink_message_t msg;
9291 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9292 uint16_t i;
9293 mavlink_uavcan_node_status_t packet_in = {
9294 93372036854775807ULL,963497880,17859,175,242,53
9295 };
9296 mavlink_uavcan_node_status_t packet1, packet2;
9297 memset(&packet1, 0, sizeof(packet1));
9298 packet1.time_usec = packet_in.time_usec;
9299 packet1.uptime_sec = packet_in.uptime_sec;
9300 packet1.vendor_specific_status_code = packet_in.vendor_specific_status_code;
9301 packet1.health = packet_in.health;
9302 packet1.mode = packet_in.mode;
9303 packet1.sub_mode = packet_in.sub_mode;
9304
9305
9306#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9307 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9308 // cope with extensions
9309 memset(MAVLINK_MSG_ID_UAVCAN_NODE_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_UAVCAN_NODE_STATUS_MIN_LEN);
9310 }
9311#endif
9312 memset(&packet2, 0, sizeof(packet2));
9313 mavlink_msg_uavcan_node_status_encode(system_id, component_id, &msg, &packet1);
9314 mavlink_msg_uavcan_node_status_decode(&msg, &packet2);
9315 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9316
9317 memset(&packet2, 0, sizeof(packet2));
9318 mavlink_msg_uavcan_node_status_pack(system_id, component_id, &msg , packet1.time_usec , packet1.uptime_sec , packet1.health , packet1.mode , packet1.sub_mode , packet1.vendor_specific_status_code );
9319 mavlink_msg_uavcan_node_status_decode(&msg, &packet2);
9320 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9321
9322 memset(&packet2, 0, sizeof(packet2));
9323 mavlink_msg_uavcan_node_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.uptime_sec , packet1.health , packet1.mode , packet1.sub_mode , packet1.vendor_specific_status_code );
9324 mavlink_msg_uavcan_node_status_decode(&msg, &packet2);
9325 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9326
9327 memset(&packet2, 0, sizeof(packet2));
9328 mavlink_msg_to_send_buffer(buffer, &msg);
9329 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9330 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9331 }
9332 mavlink_msg_uavcan_node_status_decode(last_msg, &packet2);
9333 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9334
9335 memset(&packet2, 0, sizeof(packet2));
9336 mavlink_msg_uavcan_node_status_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.uptime_sec , packet1.health , packet1.mode , packet1.sub_mode , packet1.vendor_specific_status_code );
9337 mavlink_msg_uavcan_node_status_decode(last_msg, &packet2);
9338 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9339}
9340
9341static void mavlink_test_uavcan_node_info(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9342{
9343#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9344 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9345 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_UAVCAN_NODE_INFO >= 256) {
9346 return;
9347 }
9348#endif
9349 mavlink_message_t msg;
9350 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9351 uint16_t i;
9352 mavlink_uavcan_node_info_t packet_in = {
9353 93372036854775807ULL,963497880,963498088,"QRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQ",37,104,{ 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186 },219,30
9354 };
9355 mavlink_uavcan_node_info_t packet1, packet2;
9356 memset(&packet1, 0, sizeof(packet1));
9357 packet1.time_usec = packet_in.time_usec;
9358 packet1.uptime_sec = packet_in.uptime_sec;
9359 packet1.sw_vcs_commit = packet_in.sw_vcs_commit;
9360 packet1.hw_version_major = packet_in.hw_version_major;
9361 packet1.hw_version_minor = packet_in.hw_version_minor;
9362 packet1.sw_version_major = packet_in.sw_version_major;
9363 packet1.sw_version_minor = packet_in.sw_version_minor;
9364
9365 mav_array_memcpy(packet1.name, packet_in.name, sizeof(char)*80);
9366 mav_array_memcpy(packet1.hw_unique_id, packet_in.hw_unique_id, sizeof(uint8_t)*16);
9367
9368#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9369 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9370 // cope with extensions
9371 memset(MAVLINK_MSG_ID_UAVCAN_NODE_INFO_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_UAVCAN_NODE_INFO_MIN_LEN);
9372 }
9373#endif
9374 memset(&packet2, 0, sizeof(packet2));
9375 mavlink_msg_uavcan_node_info_encode(system_id, component_id, &msg, &packet1);
9376 mavlink_msg_uavcan_node_info_decode(&msg, &packet2);
9377 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9378
9379 memset(&packet2, 0, sizeof(packet2));
9380 mavlink_msg_uavcan_node_info_pack(system_id, component_id, &msg , packet1.time_usec , packet1.uptime_sec , packet1.name , packet1.hw_version_major , packet1.hw_version_minor , packet1.hw_unique_id , packet1.sw_version_major , packet1.sw_version_minor , packet1.sw_vcs_commit );
9381 mavlink_msg_uavcan_node_info_decode(&msg, &packet2);
9382 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9383
9384 memset(&packet2, 0, sizeof(packet2));
9385 mavlink_msg_uavcan_node_info_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.uptime_sec , packet1.name , packet1.hw_version_major , packet1.hw_version_minor , packet1.hw_unique_id , packet1.sw_version_major , packet1.sw_version_minor , packet1.sw_vcs_commit );
9386 mavlink_msg_uavcan_node_info_decode(&msg, &packet2);
9387 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9388
9389 memset(&packet2, 0, sizeof(packet2));
9390 mavlink_msg_to_send_buffer(buffer, &msg);
9391 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9392 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9393 }
9394 mavlink_msg_uavcan_node_info_decode(last_msg, &packet2);
9395 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9396
9397 memset(&packet2, 0, sizeof(packet2));
9398 mavlink_msg_uavcan_node_info_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.uptime_sec , packet1.name , packet1.hw_version_major , packet1.hw_version_minor , packet1.hw_unique_id , packet1.sw_version_major , packet1.sw_version_minor , packet1.sw_vcs_commit );
9399 mavlink_msg_uavcan_node_info_decode(last_msg, &packet2);
9400 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9401}
9402
9403static void mavlink_test_param_ext_request_read(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9404{
9405#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9406 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9407 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PARAM_EXT_REQUEST_READ >= 256) {
9408 return;
9409 }
9410#endif
9411 mavlink_message_t msg;
9412 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9413 uint16_t i;
9414 mavlink_param_ext_request_read_t packet_in = {
9415 17235,139,206,"EFGHIJKLMNOPQRS"
9416 };
9417 mavlink_param_ext_request_read_t packet1, packet2;
9418 memset(&packet1, 0, sizeof(packet1));
9419 packet1.param_index = packet_in.param_index;
9420 packet1.target_system = packet_in.target_system;
9421 packet1.target_component = packet_in.target_component;
9422
9423 mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(char)*16);
9424
9425#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9426 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9427 // cope with extensions
9428 memset(MAVLINK_MSG_ID_PARAM_EXT_REQUEST_READ_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PARAM_EXT_REQUEST_READ_MIN_LEN);
9429 }
9430#endif
9431 memset(&packet2, 0, sizeof(packet2));
9432 mavlink_msg_param_ext_request_read_encode(system_id, component_id, &msg, &packet1);
9433 mavlink_msg_param_ext_request_read_decode(&msg, &packet2);
9434 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9435
9436 memset(&packet2, 0, sizeof(packet2));
9437 mavlink_msg_param_ext_request_read_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index );
9438 mavlink_msg_param_ext_request_read_decode(&msg, &packet2);
9439 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9440
9441 memset(&packet2, 0, sizeof(packet2));
9442 mavlink_msg_param_ext_request_read_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index );
9443 mavlink_msg_param_ext_request_read_decode(&msg, &packet2);
9444 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9445
9446 memset(&packet2, 0, sizeof(packet2));
9447 mavlink_msg_to_send_buffer(buffer, &msg);
9448 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9449 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9450 }
9451 mavlink_msg_param_ext_request_read_decode(last_msg, &packet2);
9452 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9453
9454 memset(&packet2, 0, sizeof(packet2));
9455 mavlink_msg_param_ext_request_read_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index );
9456 mavlink_msg_param_ext_request_read_decode(last_msg, &packet2);
9457 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9458}
9459
9460static void mavlink_test_param_ext_request_list(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9461{
9462#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9463 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9464 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PARAM_EXT_REQUEST_LIST >= 256) {
9465 return;
9466 }
9467#endif
9468 mavlink_message_t msg;
9469 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9470 uint16_t i;
9471 mavlink_param_ext_request_list_t packet_in = {
9472 5,72
9473 };
9474 mavlink_param_ext_request_list_t packet1, packet2;
9475 memset(&packet1, 0, sizeof(packet1));
9476 packet1.target_system = packet_in.target_system;
9477 packet1.target_component = packet_in.target_component;
9478
9479
9480#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9481 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9482 // cope with extensions
9483 memset(MAVLINK_MSG_ID_PARAM_EXT_REQUEST_LIST_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PARAM_EXT_REQUEST_LIST_MIN_LEN);
9484 }
9485#endif
9486 memset(&packet2, 0, sizeof(packet2));
9487 mavlink_msg_param_ext_request_list_encode(system_id, component_id, &msg, &packet1);
9488 mavlink_msg_param_ext_request_list_decode(&msg, &packet2);
9489 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9490
9491 memset(&packet2, 0, sizeof(packet2));
9492 mavlink_msg_param_ext_request_list_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component );
9493 mavlink_msg_param_ext_request_list_decode(&msg, &packet2);
9494 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9495
9496 memset(&packet2, 0, sizeof(packet2));
9497 mavlink_msg_param_ext_request_list_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component );
9498 mavlink_msg_param_ext_request_list_decode(&msg, &packet2);
9499 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9500
9501 memset(&packet2, 0, sizeof(packet2));
9502 mavlink_msg_to_send_buffer(buffer, &msg);
9503 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9504 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9505 }
9506 mavlink_msg_param_ext_request_list_decode(last_msg, &packet2);
9507 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9508
9509 memset(&packet2, 0, sizeof(packet2));
9510 mavlink_msg_param_ext_request_list_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component );
9511 mavlink_msg_param_ext_request_list_decode(last_msg, &packet2);
9512 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9513}
9514
9515static void mavlink_test_param_ext_value(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9516{
9517#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9518 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9519 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PARAM_EXT_VALUE >= 256) {
9520 return;
9521 }
9522#endif
9523 mavlink_message_t msg;
9524 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9525 uint16_t i;
9526 mavlink_param_ext_value_t packet_in = {
9527 17235,17339,"EFGHIJKLMNOPQRS","UVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQ",193
9528 };
9529 mavlink_param_ext_value_t packet1, packet2;
9530 memset(&packet1, 0, sizeof(packet1));
9531 packet1.param_count = packet_in.param_count;
9532 packet1.param_index = packet_in.param_index;
9533 packet1.param_type = packet_in.param_type;
9534
9535 mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(char)*16);
9536 mav_array_memcpy(packet1.param_value, packet_in.param_value, sizeof(char)*128);
9537
9538#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9539 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9540 // cope with extensions
9541 memset(MAVLINK_MSG_ID_PARAM_EXT_VALUE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PARAM_EXT_VALUE_MIN_LEN);
9542 }
9543#endif
9544 memset(&packet2, 0, sizeof(packet2));
9545 mavlink_msg_param_ext_value_encode(system_id, component_id, &msg, &packet1);
9546 mavlink_msg_param_ext_value_decode(&msg, &packet2);
9547 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9548
9549 memset(&packet2, 0, sizeof(packet2));
9550 mavlink_msg_param_ext_value_pack(system_id, component_id, &msg , packet1.param_id , packet1.param_value , packet1.param_type , packet1.param_count , packet1.param_index );
9551 mavlink_msg_param_ext_value_decode(&msg, &packet2);
9552 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9553
9554 memset(&packet2, 0, sizeof(packet2));
9555 mavlink_msg_param_ext_value_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.param_id , packet1.param_value , packet1.param_type , packet1.param_count , packet1.param_index );
9556 mavlink_msg_param_ext_value_decode(&msg, &packet2);
9557 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9558
9559 memset(&packet2, 0, sizeof(packet2));
9560 mavlink_msg_to_send_buffer(buffer, &msg);
9561 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9562 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9563 }
9564 mavlink_msg_param_ext_value_decode(last_msg, &packet2);
9565 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9566
9567 memset(&packet2, 0, sizeof(packet2));
9568 mavlink_msg_param_ext_value_send(MAVLINK_COMM_1 , packet1.param_id , packet1.param_value , packet1.param_type , packet1.param_count , packet1.param_index );
9569 mavlink_msg_param_ext_value_decode(last_msg, &packet2);
9570 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9571}
9572
9573static void mavlink_test_param_ext_set(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9574{
9575#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9576 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9577 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PARAM_EXT_SET >= 256) {
9578 return;
9579 }
9580#endif
9581 mavlink_message_t msg;
9582 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9583 uint16_t i;
9584 mavlink_param_ext_set_t packet_in = {
9585 5,72,"CDEFGHIJKLMNOPQ","STUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNO",59
9586 };
9587 mavlink_param_ext_set_t packet1, packet2;
9588 memset(&packet1, 0, sizeof(packet1));
9589 packet1.target_system = packet_in.target_system;
9590 packet1.target_component = packet_in.target_component;
9591 packet1.param_type = packet_in.param_type;
9592
9593 mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(char)*16);
9594 mav_array_memcpy(packet1.param_value, packet_in.param_value, sizeof(char)*128);
9595
9596#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9597 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9598 // cope with extensions
9599 memset(MAVLINK_MSG_ID_PARAM_EXT_SET_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PARAM_EXT_SET_MIN_LEN);
9600 }
9601#endif
9602 memset(&packet2, 0, sizeof(packet2));
9603 mavlink_msg_param_ext_set_encode(system_id, component_id, &msg, &packet1);
9604 mavlink_msg_param_ext_set_decode(&msg, &packet2);
9605 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9606
9607 memset(&packet2, 0, sizeof(packet2));
9608 mavlink_msg_param_ext_set_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_value , packet1.param_type );
9609 mavlink_msg_param_ext_set_decode(&msg, &packet2);
9610 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9611
9612 memset(&packet2, 0, sizeof(packet2));
9613 mavlink_msg_param_ext_set_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_value , packet1.param_type );
9614 mavlink_msg_param_ext_set_decode(&msg, &packet2);
9615 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9616
9617 memset(&packet2, 0, sizeof(packet2));
9618 mavlink_msg_to_send_buffer(buffer, &msg);
9619 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9620 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9621 }
9622 mavlink_msg_param_ext_set_decode(last_msg, &packet2);
9623 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9624
9625 memset(&packet2, 0, sizeof(packet2));
9626 mavlink_msg_param_ext_set_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_value , packet1.param_type );
9627 mavlink_msg_param_ext_set_decode(last_msg, &packet2);
9628 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9629}
9630
9631static void mavlink_test_param_ext_ack(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9632{
9633#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9634 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9635 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PARAM_EXT_ACK >= 256) {
9636 return;
9637 }
9638#endif
9639 mavlink_message_t msg;
9640 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9641 uint16_t i;
9642 mavlink_param_ext_ack_t packet_in = {
9643 "ABCDEFGHIJKLMNO","QRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLM",181,248
9644 };
9645 mavlink_param_ext_ack_t packet1, packet2;
9646 memset(&packet1, 0, sizeof(packet1));
9647 packet1.param_type = packet_in.param_type;
9648 packet1.param_result = packet_in.param_result;
9649
9650 mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(char)*16);
9651 mav_array_memcpy(packet1.param_value, packet_in.param_value, sizeof(char)*128);
9652
9653#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9654 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9655 // cope with extensions
9656 memset(MAVLINK_MSG_ID_PARAM_EXT_ACK_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PARAM_EXT_ACK_MIN_LEN);
9657 }
9658#endif
9659 memset(&packet2, 0, sizeof(packet2));
9660 mavlink_msg_param_ext_ack_encode(system_id, component_id, &msg, &packet1);
9661 mavlink_msg_param_ext_ack_decode(&msg, &packet2);
9662 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9663
9664 memset(&packet2, 0, sizeof(packet2));
9665 mavlink_msg_param_ext_ack_pack(system_id, component_id, &msg , packet1.param_id , packet1.param_value , packet1.param_type , packet1.param_result );
9666 mavlink_msg_param_ext_ack_decode(&msg, &packet2);
9667 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9668
9669 memset(&packet2, 0, sizeof(packet2));
9670 mavlink_msg_param_ext_ack_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.param_id , packet1.param_value , packet1.param_type , packet1.param_result );
9671 mavlink_msg_param_ext_ack_decode(&msg, &packet2);
9672 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9673
9674 memset(&packet2, 0, sizeof(packet2));
9675 mavlink_msg_to_send_buffer(buffer, &msg);
9676 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9677 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9678 }
9679 mavlink_msg_param_ext_ack_decode(last_msg, &packet2);
9680 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9681
9682 memset(&packet2, 0, sizeof(packet2));
9683 mavlink_msg_param_ext_ack_send(MAVLINK_COMM_1 , packet1.param_id , packet1.param_value , packet1.param_type , packet1.param_result );
9684 mavlink_msg_param_ext_ack_decode(last_msg, &packet2);
9685 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9686}
9687
9688static void mavlink_test_obstacle_distance(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9689{
9690#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9691 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
9692 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_OBSTACLE_DISTANCE >= 256) {
9693 return;
9694 }
9695#endif
9696 mavlink_message_t msg;
9697 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
9698 uint16_t i;
9699 mavlink_obstacle_distance_t packet_in = {
9700 93372036854775807ULL,29,{ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107 },132
9701 };
9702 mavlink_obstacle_distance_t packet1, packet2;
9703 memset(&packet1, 0, sizeof(packet1));
9704 packet1.time_usec = packet_in.time_usec;
9705 packet1.estimator_type = packet_in.estimator_type;
9706 packet1.increment = packet_in.increment;
9707
9708 mav_array_memcpy(packet1.distances, packet_in.distances, sizeof(uint8_t)*12);
9709
9710#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
9711 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
9712 // cope with extensions
9713 memset(MAVLINK_MSG_ID_OBSTACLE_DISTANCE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_OBSTACLE_DISTANCE_MIN_LEN);
9714 }
9715#endif
9716 memset(&packet2, 0, sizeof(packet2));
9717 mavlink_msg_obstacle_distance_encode(system_id, component_id, &msg, &packet1);
9718 mavlink_msg_obstacle_distance_decode(&msg, &packet2);
9719 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9720
9721 memset(&packet2, 0, sizeof(packet2));
9722 mavlink_msg_obstacle_distance_pack(system_id, component_id, &msg , packet1.time_usec , packet1.estimator_type , packet1.distances , packet1.increment );
9723 mavlink_msg_obstacle_distance_decode(&msg, &packet2);
9724 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9725
9726 memset(&packet2, 0, sizeof(packet2));
9727 mavlink_msg_obstacle_distance_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec , packet1.estimator_type , packet1.distances , packet1.increment );
9728 mavlink_msg_obstacle_distance_decode(&msg, &packet2);
9729 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9730
9731 memset(&packet2, 0, sizeof(packet2));
9732 mavlink_msg_to_send_buffer(buffer, &msg);
9733 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
9734 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
9735 }
9736 mavlink_msg_obstacle_distance_decode(last_msg, &packet2);
9737 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9738
9739 memset(&packet2, 0, sizeof(packet2));
9740 mavlink_msg_obstacle_distance_send(MAVLINK_COMM_1 , packet1.time_usec , packet1.estimator_type , packet1.distances , packet1.increment );
9741 mavlink_msg_obstacle_distance_decode(last_msg, &packet2);
9742 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
9743}
9744
9745static void mavlink_test_common(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
9746{
9747 mavlink_test_heartbeat(system_id, component_id, last_msg);
9748 mavlink_test_sys_status(system_id, component_id, last_msg);
9749 mavlink_test_system_time(system_id, component_id, last_msg);
9750 mavlink_test_ping(system_id, component_id, last_msg);
9751 mavlink_test_change_operator_control(system_id, component_id, last_msg);
9752 mavlink_test_change_operator_control_ack(system_id, component_id, last_msg);
9753 mavlink_test_auth_key(system_id, component_id, last_msg);
9754 mavlink_test_set_mode(system_id, component_id, last_msg);
9755 mavlink_test_param_request_read(system_id, component_id, last_msg);
9756 mavlink_test_param_request_list(system_id, component_id, last_msg);
9757 mavlink_test_param_value(system_id, component_id, last_msg);
9758 mavlink_test_param_set(system_id, component_id, last_msg);
9759 mavlink_test_gps_raw_int(system_id, component_id, last_msg);
9760 mavlink_test_gps_status(system_id, component_id, last_msg);
9761 mavlink_test_scaled_imu(system_id, component_id, last_msg);
9762 mavlink_test_raw_imu(system_id, component_id, last_msg);
9763 mavlink_test_raw_pressure(system_id, component_id, last_msg);
9764 mavlink_test_scaled_pressure(system_id, component_id, last_msg);
9765 mavlink_test_attitude(system_id, component_id, last_msg);
9766 mavlink_test_attitude_quaternion(system_id, component_id, last_msg);
9767 mavlink_test_local_position_ned(system_id, component_id, last_msg);
9768 mavlink_test_global_position_int(system_id, component_id, last_msg);
9769 mavlink_test_rc_channels_scaled(system_id, component_id, last_msg);
9770 mavlink_test_rc_channels_raw(system_id, component_id, last_msg);
9771 mavlink_test_servo_output_raw(system_id, component_id, last_msg);
9772 mavlink_test_mission_request_partial_list(system_id, component_id, last_msg);
9773 mavlink_test_mission_write_partial_list(system_id, component_id, last_msg);
9774 mavlink_test_mission_item(system_id, component_id, last_msg);
9775 mavlink_test_mission_request(system_id, component_id, last_msg);
9776 mavlink_test_mission_set_current(system_id, component_id, last_msg);
9777 mavlink_test_mission_current(system_id, component_id, last_msg);
9778 mavlink_test_mission_request_list(system_id, component_id, last_msg);
9779 mavlink_test_mission_count(system_id, component_id, last_msg);
9780 mavlink_test_mission_clear_all(system_id, component_id, last_msg);
9781 mavlink_test_mission_item_reached(system_id, component_id, last_msg);
9782 mavlink_test_mission_ack(system_id, component_id, last_msg);
9783 mavlink_test_set_gps_global_origin(system_id, component_id, last_msg);
9784 mavlink_test_gps_global_origin(system_id, component_id, last_msg);
9785 mavlink_test_param_map_rc(system_id, component_id, last_msg);
9786 mavlink_test_mission_request_int(system_id, component_id, last_msg);
9787 mavlink_test_safety_set_allowed_area(system_id, component_id, last_msg);
9788 mavlink_test_safety_allowed_area(system_id, component_id, last_msg);
9789 mavlink_test_attitude_quaternion_cov(system_id, component_id, last_msg);
9790 mavlink_test_nav_controller_output(system_id, component_id, last_msg);
9791 mavlink_test_global_position_int_cov(system_id, component_id, last_msg);
9792 mavlink_test_local_position_ned_cov(system_id, component_id, last_msg);
9793 mavlink_test_rc_channels(system_id, component_id, last_msg);
9794 mavlink_test_request_data_stream(system_id, component_id, last_msg);
9795 mavlink_test_data_stream(system_id, component_id, last_msg);
9796 mavlink_test_manual_control(system_id, component_id, last_msg);
9797 mavlink_test_rc_channels_override(system_id, component_id, last_msg);
9798 mavlink_test_mission_item_int(system_id, component_id, last_msg);
9799 mavlink_test_vfr_hud(system_id, component_id, last_msg);
9800 mavlink_test_command_int(system_id, component_id, last_msg);
9801 mavlink_test_command_long(system_id, component_id, last_msg);
9802 mavlink_test_command_ack(system_id, component_id, last_msg);
9803 mavlink_test_manual_setpoint(system_id, component_id, last_msg);
9804 mavlink_test_set_attitude_target(system_id, component_id, last_msg);
9805 mavlink_test_attitude_target(system_id, component_id, last_msg);
9806 mavlink_test_set_position_target_local_ned(system_id, component_id, last_msg);
9807 mavlink_test_position_target_local_ned(system_id, component_id, last_msg);
9808 mavlink_test_set_position_target_global_int(system_id, component_id, last_msg);
9809 mavlink_test_position_target_global_int(system_id, component_id, last_msg);
9810 mavlink_test_local_position_ned_system_global_offset(system_id, component_id, last_msg);
9811 mavlink_test_hil_state(system_id, component_id, last_msg);
9812 mavlink_test_hil_controls(system_id, component_id, last_msg);
9813 mavlink_test_hil_rc_inputs_raw(system_id, component_id, last_msg);
9814 mavlink_test_hil_actuator_controls(system_id, component_id, last_msg);
9815 mavlink_test_optical_flow(system_id, component_id, last_msg);
9816 mavlink_test_global_vision_position_estimate(system_id, component_id, last_msg);
9817 mavlink_test_vision_position_estimate(system_id, component_id, last_msg);
9818 mavlink_test_vision_speed_estimate(system_id, component_id, last_msg);
9819 mavlink_test_vicon_position_estimate(system_id, component_id, last_msg);
9820 mavlink_test_highres_imu(system_id, component_id, last_msg);
9821 mavlink_test_optical_flow_rad(system_id, component_id, last_msg);
9822 mavlink_test_hil_sensor(system_id, component_id, last_msg);
9823 mavlink_test_sim_state(system_id, component_id, last_msg);
9824 mavlink_test_radio_status(system_id, component_id, last_msg);
9825 mavlink_test_file_transfer_protocol(system_id, component_id, last_msg);
9826 mavlink_test_timesync(system_id, component_id, last_msg);
9827 mavlink_test_camera_trigger(system_id, component_id, last_msg);
9828 mavlink_test_hil_gps(system_id, component_id, last_msg);
9829 mavlink_test_hil_optical_flow(system_id, component_id, last_msg);
9830 mavlink_test_hil_state_quaternion(system_id, component_id, last_msg);
9831 mavlink_test_scaled_imu2(system_id, component_id, last_msg);
9832 mavlink_test_log_request_list(system_id, component_id, last_msg);
9833 mavlink_test_log_entry(system_id, component_id, last_msg);
9834 mavlink_test_log_request_data(system_id, component_id, last_msg);
9835 mavlink_test_log_data(system_id, component_id, last_msg);
9836 mavlink_test_log_erase(system_id, component_id, last_msg);
9837 mavlink_test_log_request_end(system_id, component_id, last_msg);
9838 mavlink_test_gps_inject_data(system_id, component_id, last_msg);
9839 mavlink_test_gps2_raw(system_id, component_id, last_msg);
9840 mavlink_test_power_status(system_id, component_id, last_msg);
9841 mavlink_test_serial_control(system_id, component_id, last_msg);
9842 mavlink_test_gps_rtk(system_id, component_id, last_msg);
9843 mavlink_test_gps2_rtk(system_id, component_id, last_msg);
9844 mavlink_test_scaled_imu3(system_id, component_id, last_msg);
9845 mavlink_test_data_transmission_handshake(system_id, component_id, last_msg);
9846 mavlink_test_encapsulated_data(system_id, component_id, last_msg);
9847 mavlink_test_distance_sensor(system_id, component_id, last_msg);
9848 mavlink_test_terrain_request(system_id, component_id, last_msg);
9849 mavlink_test_terrain_data(system_id, component_id, last_msg);
9850 mavlink_test_terrain_check(system_id, component_id, last_msg);
9851 mavlink_test_terrain_report(system_id, component_id, last_msg);
9852 mavlink_test_scaled_pressure2(system_id, component_id, last_msg);
9853 mavlink_test_att_pos_mocap(system_id, component_id, last_msg);
9854 mavlink_test_set_actuator_control_target(system_id, component_id, last_msg);
9855 mavlink_test_actuator_control_target(system_id, component_id, last_msg);
9856 mavlink_test_altitude(system_id, component_id, last_msg);
9857 mavlink_test_resource_request(system_id, component_id, last_msg);
9858 mavlink_test_scaled_pressure3(system_id, component_id, last_msg);
9859 mavlink_test_follow_target(system_id, component_id, last_msg);
9860 mavlink_test_control_system_state(system_id, component_id, last_msg);
9861 mavlink_test_battery_status(system_id, component_id, last_msg);
9862 mavlink_test_autopilot_version(system_id, component_id, last_msg);
9863 mavlink_test_landing_target(system_id, component_id, last_msg);
9864 mavlink_test_estimator_status(system_id, component_id, last_msg);
9865 mavlink_test_wind_cov(system_id, component_id, last_msg);
9866 mavlink_test_gps_input(system_id, component_id, last_msg);
9867 mavlink_test_gps_rtcm_data(system_id, component_id, last_msg);
9868 mavlink_test_high_latency(system_id, component_id, last_msg);
9869 mavlink_test_vibration(system_id, component_id, last_msg);
9870 mavlink_test_home_position(system_id, component_id, last_msg);
9871 mavlink_test_set_home_position(system_id, component_id, last_msg);
9872 mavlink_test_message_interval(system_id, component_id, last_msg);
9873 mavlink_test_extended_sys_state(system_id, component_id, last_msg);
9874 mavlink_test_adsb_vehicle(system_id, component_id, last_msg);
9875 mavlink_test_collision(system_id, component_id, last_msg);
9876 mavlink_test_v2_extension(system_id, component_id, last_msg);
9877 mavlink_test_memory_vect(system_id, component_id, last_msg);
9878 mavlink_test_debug_vect(system_id, component_id, last_msg);
9879 mavlink_test_named_value_float(system_id, component_id, last_msg);
9880 mavlink_test_named_value_int(system_id, component_id, last_msg);
9881 mavlink_test_statustext(system_id, component_id, last_msg);
9882 mavlink_test_debug(system_id, component_id, last_msg);
9883 mavlink_test_setup_signing(system_id, component_id, last_msg);
9884 mavlink_test_button_change(system_id, component_id, last_msg);
9885 mavlink_test_play_tune(system_id, component_id, last_msg);
9886 mavlink_test_camera_information(system_id, component_id, last_msg);
9887 mavlink_test_camera_settings(system_id, component_id, last_msg);
9888 mavlink_test_storage_information(system_id, component_id, last_msg);
9889 mavlink_test_camera_capture_status(system_id, component_id, last_msg);
9890 mavlink_test_camera_image_captured(system_id, component_id, last_msg);
9891 mavlink_test_flight_information(system_id, component_id, last_msg);
9892 mavlink_test_mount_orientation(system_id, component_id, last_msg);
9893 mavlink_test_logging_data(system_id, component_id, last_msg);
9894 mavlink_test_logging_data_acked(system_id, component_id, last_msg);
9895 mavlink_test_logging_ack(system_id, component_id, last_msg);
9896 mavlink_test_video_stream_information(system_id, component_id, last_msg);
9897 mavlink_test_set_video_stream_settings(system_id, component_id, last_msg);
9898 mavlink_test_wifi_config_ap(system_id, component_id, last_msg);
9899 mavlink_test_protocol_version(system_id, component_id, last_msg);
9900 mavlink_test_uavcan_node_status(system_id, component_id, last_msg);
9901 mavlink_test_uavcan_node_info(system_id, component_id, last_msg);
9902 mavlink_test_param_ext_request_read(system_id, component_id, last_msg);
9903 mavlink_test_param_ext_request_list(system_id, component_id, last_msg);
9904 mavlink_test_param_ext_value(system_id, component_id, last_msg);
9905 mavlink_test_param_ext_set(system_id, component_id, last_msg);
9906 mavlink_test_param_ext_ack(system_id, component_id, last_msg);
9907 mavlink_test_obstacle_distance(system_id, component_id, last_msg);
9908}
9909
9910#ifdef __cplusplus
9911}
9912#endif // __cplusplus
9913#endif // COMMON_TESTSUITE_H
__mavlink_status
定义 mavlink_types.h:217
__mavlink_status::flags
uint8_t flags
MAVLINK_STATUS_FLAG_*
定义 mavlink_types.h:227
制作者 doxygen 1.11.0