RflySimSDK v3.05
RflySimSDK说明文档
载入中...
搜索中...
未找到
testsuite.h
浏览该文件的文档.
1
5#pragma once
6#ifndef SLUGS_TESTSUITE_H
7#define SLUGS_TESTSUITE_H
8
9#ifdef __cplusplus
10extern "C" {
11#endif
12
13#ifndef MAVLINK_TEST_ALL
14#define MAVLINK_TEST_ALL
15static void mavlink_test_common(uint8_t, uint8_t, mavlink_message_t *last_msg);
16static void mavlink_test_slugs(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 mavlink_test_common(system_id, component_id, last_msg);
21 mavlink_test_slugs(system_id, component_id, last_msg);
22}
23#endif
24
25#include "../common/testsuite.h"
26
27
28static void mavlink_test_cpu_load(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_CPU_LOAD >= 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_cpu_load_t packet_in = {
40 17235,139,206
41 };
42 mavlink_cpu_load_t packet1, packet2;
43 memset(&packet1, 0, sizeof(packet1));
44 packet1.batVolt = packet_in.batVolt;
45 packet1.sensLoad = packet_in.sensLoad;
46 packet1.ctrlLoad = packet_in.ctrlLoad;
47
48
49#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
50 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
51 // cope with extensions
52 memset(MAVLINK_MSG_ID_CPU_LOAD_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CPU_LOAD_MIN_LEN);
53 }
54#endif
55 memset(&packet2, 0, sizeof(packet2));
56 mavlink_msg_cpu_load_encode(system_id, component_id, &msg, &packet1);
57 mavlink_msg_cpu_load_decode(&msg, &packet2);
58 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
59
60 memset(&packet2, 0, sizeof(packet2));
61 mavlink_msg_cpu_load_pack(system_id, component_id, &msg , packet1.sensLoad , packet1.ctrlLoad , packet1.batVolt );
62 mavlink_msg_cpu_load_decode(&msg, &packet2);
63 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
64
65 memset(&packet2, 0, sizeof(packet2));
66 mavlink_msg_cpu_load_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.sensLoad , packet1.ctrlLoad , packet1.batVolt );
67 mavlink_msg_cpu_load_decode(&msg, &packet2);
68 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
69
70 memset(&packet2, 0, sizeof(packet2));
71 mavlink_msg_to_send_buffer(buffer, &msg);
72 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
73 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
74 }
75 mavlink_msg_cpu_load_decode(last_msg, &packet2);
76 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
77
78 memset(&packet2, 0, sizeof(packet2));
79 mavlink_msg_cpu_load_send(MAVLINK_COMM_1 , packet1.sensLoad , packet1.ctrlLoad , packet1.batVolt );
80 mavlink_msg_cpu_load_decode(last_msg, &packet2);
81 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
82}
83
84static void mavlink_test_sensor_bias(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
85{
86#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
87 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
88 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SENSOR_BIAS >= 256) {
89 return;
90 }
91#endif
92 mavlink_message_t msg;
93 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
94 uint16_t i;
95 mavlink_sensor_bias_t packet_in = {
96 17.0,45.0,73.0,101.0,129.0,157.0
97 };
98 mavlink_sensor_bias_t packet1, packet2;
99 memset(&packet1, 0, sizeof(packet1));
100 packet1.axBias = packet_in.axBias;
101 packet1.ayBias = packet_in.ayBias;
102 packet1.azBias = packet_in.azBias;
103 packet1.gxBias = packet_in.gxBias;
104 packet1.gyBias = packet_in.gyBias;
105 packet1.gzBias = packet_in.gzBias;
106
107
108#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
109 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
110 // cope with extensions
111 memset(MAVLINK_MSG_ID_SENSOR_BIAS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SENSOR_BIAS_MIN_LEN);
112 }
113#endif
114 memset(&packet2, 0, sizeof(packet2));
115 mavlink_msg_sensor_bias_encode(system_id, component_id, &msg, &packet1);
116 mavlink_msg_sensor_bias_decode(&msg, &packet2);
117 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
118
119 memset(&packet2, 0, sizeof(packet2));
120 mavlink_msg_sensor_bias_pack(system_id, component_id, &msg , packet1.axBias , packet1.ayBias , packet1.azBias , packet1.gxBias , packet1.gyBias , packet1.gzBias );
121 mavlink_msg_sensor_bias_decode(&msg, &packet2);
122 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
123
124 memset(&packet2, 0, sizeof(packet2));
125 mavlink_msg_sensor_bias_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.axBias , packet1.ayBias , packet1.azBias , packet1.gxBias , packet1.gyBias , packet1.gzBias );
126 mavlink_msg_sensor_bias_decode(&msg, &packet2);
127 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
128
129 memset(&packet2, 0, sizeof(packet2));
130 mavlink_msg_to_send_buffer(buffer, &msg);
131 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
132 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
133 }
134 mavlink_msg_sensor_bias_decode(last_msg, &packet2);
135 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
136
137 memset(&packet2, 0, sizeof(packet2));
138 mavlink_msg_sensor_bias_send(MAVLINK_COMM_1 , packet1.axBias , packet1.ayBias , packet1.azBias , packet1.gxBias , packet1.gyBias , packet1.gzBias );
139 mavlink_msg_sensor_bias_decode(last_msg, &packet2);
140 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
141}
142
143static void mavlink_test_diagnostic(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
144{
145#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
146 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
147 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_DIAGNOSTIC >= 256) {
148 return;
149 }
150#endif
151 mavlink_message_t msg;
152 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
153 uint16_t i;
154 mavlink_diagnostic_t packet_in = {
155 17.0,45.0,73.0,17859,17963,18067
156 };
157 mavlink_diagnostic_t packet1, packet2;
158 memset(&packet1, 0, sizeof(packet1));
159 packet1.diagFl1 = packet_in.diagFl1;
160 packet1.diagFl2 = packet_in.diagFl2;
161 packet1.diagFl3 = packet_in.diagFl3;
162 packet1.diagSh1 = packet_in.diagSh1;
163 packet1.diagSh2 = packet_in.diagSh2;
164 packet1.diagSh3 = packet_in.diagSh3;
165
166
167#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
168 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
169 // cope with extensions
170 memset(MAVLINK_MSG_ID_DIAGNOSTIC_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_DIAGNOSTIC_MIN_LEN);
171 }
172#endif
173 memset(&packet2, 0, sizeof(packet2));
174 mavlink_msg_diagnostic_encode(system_id, component_id, &msg, &packet1);
175 mavlink_msg_diagnostic_decode(&msg, &packet2);
176 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
177
178 memset(&packet2, 0, sizeof(packet2));
179 mavlink_msg_diagnostic_pack(system_id, component_id, &msg , packet1.diagFl1 , packet1.diagFl2 , packet1.diagFl3 , packet1.diagSh1 , packet1.diagSh2 , packet1.diagSh3 );
180 mavlink_msg_diagnostic_decode(&msg, &packet2);
181 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
182
183 memset(&packet2, 0, sizeof(packet2));
184 mavlink_msg_diagnostic_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.diagFl1 , packet1.diagFl2 , packet1.diagFl3 , packet1.diagSh1 , packet1.diagSh2 , packet1.diagSh3 );
185 mavlink_msg_diagnostic_decode(&msg, &packet2);
186 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
187
188 memset(&packet2, 0, sizeof(packet2));
189 mavlink_msg_to_send_buffer(buffer, &msg);
190 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
191 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
192 }
193 mavlink_msg_diagnostic_decode(last_msg, &packet2);
194 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
195
196 memset(&packet2, 0, sizeof(packet2));
197 mavlink_msg_diagnostic_send(MAVLINK_COMM_1 , packet1.diagFl1 , packet1.diagFl2 , packet1.diagFl3 , packet1.diagSh1 , packet1.diagSh2 , packet1.diagSh3 );
198 mavlink_msg_diagnostic_decode(last_msg, &packet2);
199 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
200}
201
202static void mavlink_test_slugs_navigation(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
203{
204#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
205 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
206 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SLUGS_NAVIGATION >= 256) {
207 return;
208 }
209#endif
210 mavlink_message_t msg;
211 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
212 uint16_t i;
213 mavlink_slugs_navigation_t packet_in = {
214 17.0,45.0,73.0,101.0,129.0,157.0,185.0,18691,223,34
215 };
216 mavlink_slugs_navigation_t packet1, packet2;
217 memset(&packet1, 0, sizeof(packet1));
218 packet1.u_m = packet_in.u_m;
219 packet1.phi_c = packet_in.phi_c;
220 packet1.theta_c = packet_in.theta_c;
221 packet1.psiDot_c = packet_in.psiDot_c;
222 packet1.ay_body = packet_in.ay_body;
223 packet1.totalDist = packet_in.totalDist;
224 packet1.dist2Go = packet_in.dist2Go;
225 packet1.h_c = packet_in.h_c;
226 packet1.fromWP = packet_in.fromWP;
227 packet1.toWP = packet_in.toWP;
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_SLUGS_NAVIGATION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SLUGS_NAVIGATION_MIN_LEN);
234 }
235#endif
236 memset(&packet2, 0, sizeof(packet2));
237 mavlink_msg_slugs_navigation_encode(system_id, component_id, &msg, &packet1);
238 mavlink_msg_slugs_navigation_decode(&msg, &packet2);
239 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
240
241 memset(&packet2, 0, sizeof(packet2));
242 mavlink_msg_slugs_navigation_pack(system_id, component_id, &msg , packet1.u_m , packet1.phi_c , packet1.theta_c , packet1.psiDot_c , packet1.ay_body , packet1.totalDist , packet1.dist2Go , packet1.fromWP , packet1.toWP , packet1.h_c );
243 mavlink_msg_slugs_navigation_decode(&msg, &packet2);
244 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
245
246 memset(&packet2, 0, sizeof(packet2));
247 mavlink_msg_slugs_navigation_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.u_m , packet1.phi_c , packet1.theta_c , packet1.psiDot_c , packet1.ay_body , packet1.totalDist , packet1.dist2Go , packet1.fromWP , packet1.toWP , packet1.h_c );
248 mavlink_msg_slugs_navigation_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_slugs_navigation_decode(last_msg, &packet2);
257 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
258
259 memset(&packet2, 0, sizeof(packet2));
260 mavlink_msg_slugs_navigation_send(MAVLINK_COMM_1 , packet1.u_m , packet1.phi_c , packet1.theta_c , packet1.psiDot_c , packet1.ay_body , packet1.totalDist , packet1.dist2Go , packet1.fromWP , packet1.toWP , packet1.h_c );
261 mavlink_msg_slugs_navigation_decode(last_msg, &packet2);
262 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
263}
264
265static void mavlink_test_data_log(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_DATA_LOG >= 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_data_log_t packet_in = {
277 17.0,45.0,73.0,101.0,129.0,157.0
278 };
279 mavlink_data_log_t packet1, packet2;
280 memset(&packet1, 0, sizeof(packet1));
281 packet1.fl_1 = packet_in.fl_1;
282 packet1.fl_2 = packet_in.fl_2;
283 packet1.fl_3 = packet_in.fl_3;
284 packet1.fl_4 = packet_in.fl_4;
285 packet1.fl_5 = packet_in.fl_5;
286 packet1.fl_6 = packet_in.fl_6;
287
288
289#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
290 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
291 // cope with extensions
292 memset(MAVLINK_MSG_ID_DATA_LOG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_DATA_LOG_MIN_LEN);
293 }
294#endif
295 memset(&packet2, 0, sizeof(packet2));
296 mavlink_msg_data_log_encode(system_id, component_id, &msg, &packet1);
297 mavlink_msg_data_log_decode(&msg, &packet2);
298 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
299
300 memset(&packet2, 0, sizeof(packet2));
301 mavlink_msg_data_log_pack(system_id, component_id, &msg , packet1.fl_1 , packet1.fl_2 , packet1.fl_3 , packet1.fl_4 , packet1.fl_5 , packet1.fl_6 );
302 mavlink_msg_data_log_decode(&msg, &packet2);
303 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
304
305 memset(&packet2, 0, sizeof(packet2));
306 mavlink_msg_data_log_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.fl_1 , packet1.fl_2 , packet1.fl_3 , packet1.fl_4 , packet1.fl_5 , packet1.fl_6 );
307 mavlink_msg_data_log_decode(&msg, &packet2);
308 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
309
310 memset(&packet2, 0, sizeof(packet2));
311 mavlink_msg_to_send_buffer(buffer, &msg);
312 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
313 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
314 }
315 mavlink_msg_data_log_decode(last_msg, &packet2);
316 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
317
318 memset(&packet2, 0, sizeof(packet2));
319 mavlink_msg_data_log_send(MAVLINK_COMM_1 , packet1.fl_1 , packet1.fl_2 , packet1.fl_3 , packet1.fl_4 , packet1.fl_5 , packet1.fl_6 );
320 mavlink_msg_data_log_decode(last_msg, &packet2);
321 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
322}
323
324static void mavlink_test_gps_date_time(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
325{
326#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
327 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
328 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_GPS_DATE_TIME >= 256) {
329 return;
330 }
331#endif
332 mavlink_message_t msg;
333 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
334 uint16_t i;
335 mavlink_gps_date_time_t packet_in = {
336 5,72,139,206,17,84,151,218,29,96,163,230
337 };
338 mavlink_gps_date_time_t packet1, packet2;
339 memset(&packet1, 0, sizeof(packet1));
340 packet1.year = packet_in.year;
341 packet1.month = packet_in.month;
342 packet1.day = packet_in.day;
343 packet1.hour = packet_in.hour;
344 packet1.min = packet_in.min;
345 packet1.sec = packet_in.sec;
346 packet1.clockStat = packet_in.clockStat;
347 packet1.visSat = packet_in.visSat;
348 packet1.useSat = packet_in.useSat;
349 packet1.GppGl = packet_in.GppGl;
350 packet1.sigUsedMask = packet_in.sigUsedMask;
351 packet1.percentUsed = packet_in.percentUsed;
352
353
354#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
355 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
356 // cope with extensions
357 memset(MAVLINK_MSG_ID_GPS_DATE_TIME_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_GPS_DATE_TIME_MIN_LEN);
358 }
359#endif
360 memset(&packet2, 0, sizeof(packet2));
361 mavlink_msg_gps_date_time_encode(system_id, component_id, &msg, &packet1);
362 mavlink_msg_gps_date_time_decode(&msg, &packet2);
363 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
364
365 memset(&packet2, 0, sizeof(packet2));
366 mavlink_msg_gps_date_time_pack(system_id, component_id, &msg , packet1.year , packet1.month , packet1.day , packet1.hour , packet1.min , packet1.sec , packet1.clockStat , packet1.visSat , packet1.useSat , packet1.GppGl , packet1.sigUsedMask , packet1.percentUsed );
367 mavlink_msg_gps_date_time_decode(&msg, &packet2);
368 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
369
370 memset(&packet2, 0, sizeof(packet2));
371 mavlink_msg_gps_date_time_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.year , packet1.month , packet1.day , packet1.hour , packet1.min , packet1.sec , packet1.clockStat , packet1.visSat , packet1.useSat , packet1.GppGl , packet1.sigUsedMask , packet1.percentUsed );
372 mavlink_msg_gps_date_time_decode(&msg, &packet2);
373 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
374
375 memset(&packet2, 0, sizeof(packet2));
376 mavlink_msg_to_send_buffer(buffer, &msg);
377 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
378 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
379 }
380 mavlink_msg_gps_date_time_decode(last_msg, &packet2);
381 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
382
383 memset(&packet2, 0, sizeof(packet2));
384 mavlink_msg_gps_date_time_send(MAVLINK_COMM_1 , packet1.year , packet1.month , packet1.day , packet1.hour , packet1.min , packet1.sec , packet1.clockStat , packet1.visSat , packet1.useSat , packet1.GppGl , packet1.sigUsedMask , packet1.percentUsed );
385 mavlink_msg_gps_date_time_decode(last_msg, &packet2);
386 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
387}
388
389static void mavlink_test_mid_lvl_cmds(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
390{
391#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
392 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
393 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_MID_LVL_CMDS >= 256) {
394 return;
395 }
396#endif
397 mavlink_message_t msg;
398 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
399 uint16_t i;
400 mavlink_mid_lvl_cmds_t packet_in = {
401 17.0,45.0,73.0,41
402 };
403 mavlink_mid_lvl_cmds_t packet1, packet2;
404 memset(&packet1, 0, sizeof(packet1));
405 packet1.hCommand = packet_in.hCommand;
406 packet1.uCommand = packet_in.uCommand;
407 packet1.rCommand = packet_in.rCommand;
408 packet1.target = packet_in.target;
409
410
411#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
412 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
413 // cope with extensions
414 memset(MAVLINK_MSG_ID_MID_LVL_CMDS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_MID_LVL_CMDS_MIN_LEN);
415 }
416#endif
417 memset(&packet2, 0, sizeof(packet2));
418 mavlink_msg_mid_lvl_cmds_encode(system_id, component_id, &msg, &packet1);
419 mavlink_msg_mid_lvl_cmds_decode(&msg, &packet2);
420 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
421
422 memset(&packet2, 0, sizeof(packet2));
423 mavlink_msg_mid_lvl_cmds_pack(system_id, component_id, &msg , packet1.target , packet1.hCommand , packet1.uCommand , packet1.rCommand );
424 mavlink_msg_mid_lvl_cmds_decode(&msg, &packet2);
425 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
426
427 memset(&packet2, 0, sizeof(packet2));
428 mavlink_msg_mid_lvl_cmds_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.hCommand , packet1.uCommand , packet1.rCommand );
429 mavlink_msg_mid_lvl_cmds_decode(&msg, &packet2);
430 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
431
432 memset(&packet2, 0, sizeof(packet2));
433 mavlink_msg_to_send_buffer(buffer, &msg);
434 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
435 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
436 }
437 mavlink_msg_mid_lvl_cmds_decode(last_msg, &packet2);
438 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
439
440 memset(&packet2, 0, sizeof(packet2));
441 mavlink_msg_mid_lvl_cmds_send(MAVLINK_COMM_1 , packet1.target , packet1.hCommand , packet1.uCommand , packet1.rCommand );
442 mavlink_msg_mid_lvl_cmds_decode(last_msg, &packet2);
443 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
444}
445
446static void mavlink_test_ctrl_srfc_pt(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
447{
448#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
449 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
450 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_CTRL_SRFC_PT >= 256) {
451 return;
452 }
453#endif
454 mavlink_message_t msg;
455 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
456 uint16_t i;
457 mavlink_ctrl_srfc_pt_t packet_in = {
458 17235,139
459 };
460 mavlink_ctrl_srfc_pt_t packet1, packet2;
461 memset(&packet1, 0, sizeof(packet1));
462 packet1.bitfieldPt = packet_in.bitfieldPt;
463 packet1.target = packet_in.target;
464
465
466#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
467 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
468 // cope with extensions
469 memset(MAVLINK_MSG_ID_CTRL_SRFC_PT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CTRL_SRFC_PT_MIN_LEN);
470 }
471#endif
472 memset(&packet2, 0, sizeof(packet2));
473 mavlink_msg_ctrl_srfc_pt_encode(system_id, component_id, &msg, &packet1);
474 mavlink_msg_ctrl_srfc_pt_decode(&msg, &packet2);
475 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
476
477 memset(&packet2, 0, sizeof(packet2));
478 mavlink_msg_ctrl_srfc_pt_pack(system_id, component_id, &msg , packet1.target , packet1.bitfieldPt );
479 mavlink_msg_ctrl_srfc_pt_decode(&msg, &packet2);
480 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
481
482 memset(&packet2, 0, sizeof(packet2));
483 mavlink_msg_ctrl_srfc_pt_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.bitfieldPt );
484 mavlink_msg_ctrl_srfc_pt_decode(&msg, &packet2);
485 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
486
487 memset(&packet2, 0, sizeof(packet2));
488 mavlink_msg_to_send_buffer(buffer, &msg);
489 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
490 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
491 }
492 mavlink_msg_ctrl_srfc_pt_decode(last_msg, &packet2);
493 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
494
495 memset(&packet2, 0, sizeof(packet2));
496 mavlink_msg_ctrl_srfc_pt_send(MAVLINK_COMM_1 , packet1.target , packet1.bitfieldPt );
497 mavlink_msg_ctrl_srfc_pt_decode(last_msg, &packet2);
498 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
499}
500
501static void mavlink_test_slugs_camera_order(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
502{
503#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
504 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
505 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SLUGS_CAMERA_ORDER >= 256) {
506 return;
507 }
508#endif
509 mavlink_message_t msg;
510 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
511 uint16_t i;
512 mavlink_slugs_camera_order_t packet_in = {
513 5,72,139,206,17
514 };
515 mavlink_slugs_camera_order_t packet1, packet2;
516 memset(&packet1, 0, sizeof(packet1));
517 packet1.target = packet_in.target;
518 packet1.pan = packet_in.pan;
519 packet1.tilt = packet_in.tilt;
520 packet1.zoom = packet_in.zoom;
521 packet1.moveHome = packet_in.moveHome;
522
523
524#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
525 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
526 // cope with extensions
527 memset(MAVLINK_MSG_ID_SLUGS_CAMERA_ORDER_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SLUGS_CAMERA_ORDER_MIN_LEN);
528 }
529#endif
530 memset(&packet2, 0, sizeof(packet2));
531 mavlink_msg_slugs_camera_order_encode(system_id, component_id, &msg, &packet1);
532 mavlink_msg_slugs_camera_order_decode(&msg, &packet2);
533 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
534
535 memset(&packet2, 0, sizeof(packet2));
536 mavlink_msg_slugs_camera_order_pack(system_id, component_id, &msg , packet1.target , packet1.pan , packet1.tilt , packet1.zoom , packet1.moveHome );
537 mavlink_msg_slugs_camera_order_decode(&msg, &packet2);
538 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
539
540 memset(&packet2, 0, sizeof(packet2));
541 mavlink_msg_slugs_camera_order_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.pan , packet1.tilt , packet1.zoom , packet1.moveHome );
542 mavlink_msg_slugs_camera_order_decode(&msg, &packet2);
543 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
544
545 memset(&packet2, 0, sizeof(packet2));
546 mavlink_msg_to_send_buffer(buffer, &msg);
547 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
548 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
549 }
550 mavlink_msg_slugs_camera_order_decode(last_msg, &packet2);
551 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
552
553 memset(&packet2, 0, sizeof(packet2));
554 mavlink_msg_slugs_camera_order_send(MAVLINK_COMM_1 , packet1.target , packet1.pan , packet1.tilt , packet1.zoom , packet1.moveHome );
555 mavlink_msg_slugs_camera_order_decode(last_msg, &packet2);
556 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
557}
558
559static void mavlink_test_control_surface(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
560{
561#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
562 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
563 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_CONTROL_SURFACE >= 256) {
564 return;
565 }
566#endif
567 mavlink_message_t msg;
568 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
569 uint16_t i;
570 mavlink_control_surface_t packet_in = {
571 17.0,45.0,29,96
572 };
573 mavlink_control_surface_t packet1, packet2;
574 memset(&packet1, 0, sizeof(packet1));
575 packet1.mControl = packet_in.mControl;
576 packet1.bControl = packet_in.bControl;
577 packet1.target = packet_in.target;
578 packet1.idSurface = packet_in.idSurface;
579
580
581#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
582 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
583 // cope with extensions
584 memset(MAVLINK_MSG_ID_CONTROL_SURFACE_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_CONTROL_SURFACE_MIN_LEN);
585 }
586#endif
587 memset(&packet2, 0, sizeof(packet2));
588 mavlink_msg_control_surface_encode(system_id, component_id, &msg, &packet1);
589 mavlink_msg_control_surface_decode(&msg, &packet2);
590 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
591
592 memset(&packet2, 0, sizeof(packet2));
593 mavlink_msg_control_surface_pack(system_id, component_id, &msg , packet1.target , packet1.idSurface , packet1.mControl , packet1.bControl );
594 mavlink_msg_control_surface_decode(&msg, &packet2);
595 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
596
597 memset(&packet2, 0, sizeof(packet2));
598 mavlink_msg_control_surface_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.idSurface , packet1.mControl , packet1.bControl );
599 mavlink_msg_control_surface_decode(&msg, &packet2);
600 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
601
602 memset(&packet2, 0, sizeof(packet2));
603 mavlink_msg_to_send_buffer(buffer, &msg);
604 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
605 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
606 }
607 mavlink_msg_control_surface_decode(last_msg, &packet2);
608 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
609
610 memset(&packet2, 0, sizeof(packet2));
611 mavlink_msg_control_surface_send(MAVLINK_COMM_1 , packet1.target , packet1.idSurface , packet1.mControl , packet1.bControl );
612 mavlink_msg_control_surface_decode(last_msg, &packet2);
613 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
614}
615
616static void mavlink_test_slugs_mobile_location(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
617{
618#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
619 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
620 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SLUGS_MOBILE_LOCATION >= 256) {
621 return;
622 }
623#endif
624 mavlink_message_t msg;
625 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
626 uint16_t i;
627 mavlink_slugs_mobile_location_t packet_in = {
628 17.0,45.0,29
629 };
630 mavlink_slugs_mobile_location_t packet1, packet2;
631 memset(&packet1, 0, sizeof(packet1));
632 packet1.latitude = packet_in.latitude;
633 packet1.longitude = packet_in.longitude;
634 packet1.target = packet_in.target;
635
636
637#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
638 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
639 // cope with extensions
640 memset(MAVLINK_MSG_ID_SLUGS_MOBILE_LOCATION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SLUGS_MOBILE_LOCATION_MIN_LEN);
641 }
642#endif
643 memset(&packet2, 0, sizeof(packet2));
644 mavlink_msg_slugs_mobile_location_encode(system_id, component_id, &msg, &packet1);
645 mavlink_msg_slugs_mobile_location_decode(&msg, &packet2);
646 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
647
648 memset(&packet2, 0, sizeof(packet2));
649 mavlink_msg_slugs_mobile_location_pack(system_id, component_id, &msg , packet1.target , packet1.latitude , packet1.longitude );
650 mavlink_msg_slugs_mobile_location_decode(&msg, &packet2);
651 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
652
653 memset(&packet2, 0, sizeof(packet2));
654 mavlink_msg_slugs_mobile_location_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.latitude , packet1.longitude );
655 mavlink_msg_slugs_mobile_location_decode(&msg, &packet2);
656 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
657
658 memset(&packet2, 0, sizeof(packet2));
659 mavlink_msg_to_send_buffer(buffer, &msg);
660 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
661 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
662 }
663 mavlink_msg_slugs_mobile_location_decode(last_msg, &packet2);
664 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
665
666 memset(&packet2, 0, sizeof(packet2));
667 mavlink_msg_slugs_mobile_location_send(MAVLINK_COMM_1 , packet1.target , packet1.latitude , packet1.longitude );
668 mavlink_msg_slugs_mobile_location_decode(last_msg, &packet2);
669 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
670}
671
672static void mavlink_test_slugs_configuration_camera(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
673{
674#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
675 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
676 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SLUGS_CONFIGURATION_CAMERA >= 256) {
677 return;
678 }
679#endif
680 mavlink_message_t msg;
681 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
682 uint16_t i;
683 mavlink_slugs_configuration_camera_t packet_in = {
684 5,72,139
685 };
686 mavlink_slugs_configuration_camera_t packet1, packet2;
687 memset(&packet1, 0, sizeof(packet1));
688 packet1.target = packet_in.target;
689 packet1.idOrder = packet_in.idOrder;
690 packet1.order = packet_in.order;
691
692
693#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
694 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
695 // cope with extensions
696 memset(MAVLINK_MSG_ID_SLUGS_CONFIGURATION_CAMERA_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SLUGS_CONFIGURATION_CAMERA_MIN_LEN);
697 }
698#endif
699 memset(&packet2, 0, sizeof(packet2));
700 mavlink_msg_slugs_configuration_camera_encode(system_id, component_id, &msg, &packet1);
701 mavlink_msg_slugs_configuration_camera_decode(&msg, &packet2);
702 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
703
704 memset(&packet2, 0, sizeof(packet2));
705 mavlink_msg_slugs_configuration_camera_pack(system_id, component_id, &msg , packet1.target , packet1.idOrder , packet1.order );
706 mavlink_msg_slugs_configuration_camera_decode(&msg, &packet2);
707 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
708
709 memset(&packet2, 0, sizeof(packet2));
710 mavlink_msg_slugs_configuration_camera_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.idOrder , packet1.order );
711 mavlink_msg_slugs_configuration_camera_decode(&msg, &packet2);
712 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
713
714 memset(&packet2, 0, sizeof(packet2));
715 mavlink_msg_to_send_buffer(buffer, &msg);
716 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
717 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
718 }
719 mavlink_msg_slugs_configuration_camera_decode(last_msg, &packet2);
720 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
721
722 memset(&packet2, 0, sizeof(packet2));
723 mavlink_msg_slugs_configuration_camera_send(MAVLINK_COMM_1 , packet1.target , packet1.idOrder , packet1.order );
724 mavlink_msg_slugs_configuration_camera_decode(last_msg, &packet2);
725 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
726}
727
728static void mavlink_test_isr_location(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
729{
730#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
731 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
732 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_ISR_LOCATION >= 256) {
733 return;
734 }
735#endif
736 mavlink_message_t msg;
737 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
738 uint16_t i;
739 mavlink_isr_location_t packet_in = {
740 17.0,45.0,73.0,41,108,175,242
741 };
742 mavlink_isr_location_t packet1, packet2;
743 memset(&packet1, 0, sizeof(packet1));
744 packet1.latitude = packet_in.latitude;
745 packet1.longitude = packet_in.longitude;
746 packet1.height = packet_in.height;
747 packet1.target = packet_in.target;
748 packet1.option1 = packet_in.option1;
749 packet1.option2 = packet_in.option2;
750 packet1.option3 = packet_in.option3;
751
752
753#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
754 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
755 // cope with extensions
756 memset(MAVLINK_MSG_ID_ISR_LOCATION_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_ISR_LOCATION_MIN_LEN);
757 }
758#endif
759 memset(&packet2, 0, sizeof(packet2));
760 mavlink_msg_isr_location_encode(system_id, component_id, &msg, &packet1);
761 mavlink_msg_isr_location_decode(&msg, &packet2);
762 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
763
764 memset(&packet2, 0, sizeof(packet2));
765 mavlink_msg_isr_location_pack(system_id, component_id, &msg , packet1.target , packet1.latitude , packet1.longitude , packet1.height , packet1.option1 , packet1.option2 , packet1.option3 );
766 mavlink_msg_isr_location_decode(&msg, &packet2);
767 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
768
769 memset(&packet2, 0, sizeof(packet2));
770 mavlink_msg_isr_location_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.latitude , packet1.longitude , packet1.height , packet1.option1 , packet1.option2 , packet1.option3 );
771 mavlink_msg_isr_location_decode(&msg, &packet2);
772 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
773
774 memset(&packet2, 0, sizeof(packet2));
775 mavlink_msg_to_send_buffer(buffer, &msg);
776 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
777 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
778 }
779 mavlink_msg_isr_location_decode(last_msg, &packet2);
780 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
781
782 memset(&packet2, 0, sizeof(packet2));
783 mavlink_msg_isr_location_send(MAVLINK_COMM_1 , packet1.target , packet1.latitude , packet1.longitude , packet1.height , packet1.option1 , packet1.option2 , packet1.option3 );
784 mavlink_msg_isr_location_decode(last_msg, &packet2);
785 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
786}
787
788static void mavlink_test_volt_sensor(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
789{
790#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
791 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
792 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_VOLT_SENSOR >= 256) {
793 return;
794 }
795#endif
796 mavlink_message_t msg;
797 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
798 uint16_t i;
799 mavlink_volt_sensor_t packet_in = {
800 17235,17339,17
801 };
802 mavlink_volt_sensor_t packet1, packet2;
803 memset(&packet1, 0, sizeof(packet1));
804 packet1.voltage = packet_in.voltage;
805 packet1.reading2 = packet_in.reading2;
806 packet1.r2Type = packet_in.r2Type;
807
808
809#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
810 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
811 // cope with extensions
812 memset(MAVLINK_MSG_ID_VOLT_SENSOR_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_VOLT_SENSOR_MIN_LEN);
813 }
814#endif
815 memset(&packet2, 0, sizeof(packet2));
816 mavlink_msg_volt_sensor_encode(system_id, component_id, &msg, &packet1);
817 mavlink_msg_volt_sensor_decode(&msg, &packet2);
818 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
819
820 memset(&packet2, 0, sizeof(packet2));
821 mavlink_msg_volt_sensor_pack(system_id, component_id, &msg , packet1.r2Type , packet1.voltage , packet1.reading2 );
822 mavlink_msg_volt_sensor_decode(&msg, &packet2);
823 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
824
825 memset(&packet2, 0, sizeof(packet2));
826 mavlink_msg_volt_sensor_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.r2Type , packet1.voltage , packet1.reading2 );
827 mavlink_msg_volt_sensor_decode(&msg, &packet2);
828 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
829
830 memset(&packet2, 0, sizeof(packet2));
831 mavlink_msg_to_send_buffer(buffer, &msg);
832 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
833 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
834 }
835 mavlink_msg_volt_sensor_decode(last_msg, &packet2);
836 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
837
838 memset(&packet2, 0, sizeof(packet2));
839 mavlink_msg_volt_sensor_send(MAVLINK_COMM_1 , packet1.r2Type , packet1.voltage , packet1.reading2 );
840 mavlink_msg_volt_sensor_decode(last_msg, &packet2);
841 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
842}
843
844static void mavlink_test_ptz_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
845{
846#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
847 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
848 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_PTZ_STATUS >= 256) {
849 return;
850 }
851#endif
852 mavlink_message_t msg;
853 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
854 uint16_t i;
855 mavlink_ptz_status_t packet_in = {
856 17235,17339,17
857 };
858 mavlink_ptz_status_t packet1, packet2;
859 memset(&packet1, 0, sizeof(packet1));
860 packet1.pan = packet_in.pan;
861 packet1.tilt = packet_in.tilt;
862 packet1.zoom = packet_in.zoom;
863
864
865#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
866 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
867 // cope with extensions
868 memset(MAVLINK_MSG_ID_PTZ_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_PTZ_STATUS_MIN_LEN);
869 }
870#endif
871 memset(&packet2, 0, sizeof(packet2));
872 mavlink_msg_ptz_status_encode(system_id, component_id, &msg, &packet1);
873 mavlink_msg_ptz_status_decode(&msg, &packet2);
874 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
875
876 memset(&packet2, 0, sizeof(packet2));
877 mavlink_msg_ptz_status_pack(system_id, component_id, &msg , packet1.zoom , packet1.pan , packet1.tilt );
878 mavlink_msg_ptz_status_decode(&msg, &packet2);
879 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
880
881 memset(&packet2, 0, sizeof(packet2));
882 mavlink_msg_ptz_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.zoom , packet1.pan , packet1.tilt );
883 mavlink_msg_ptz_status_decode(&msg, &packet2);
884 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
885
886 memset(&packet2, 0, sizeof(packet2));
887 mavlink_msg_to_send_buffer(buffer, &msg);
888 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
889 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
890 }
891 mavlink_msg_ptz_status_decode(last_msg, &packet2);
892 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
893
894 memset(&packet2, 0, sizeof(packet2));
895 mavlink_msg_ptz_status_send(MAVLINK_COMM_1 , packet1.zoom , packet1.pan , packet1.tilt );
896 mavlink_msg_ptz_status_decode(last_msg, &packet2);
897 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
898}
899
900static void mavlink_test_uav_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
901{
902#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
903 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
904 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_UAV_STATUS >= 256) {
905 return;
906 }
907#endif
908 mavlink_message_t msg;
909 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
910 uint16_t i;
911 mavlink_uav_status_t packet_in = {
912 17.0,45.0,73.0,101.0,129.0,65
913 };
914 mavlink_uav_status_t packet1, packet2;
915 memset(&packet1, 0, sizeof(packet1));
916 packet1.latitude = packet_in.latitude;
917 packet1.longitude = packet_in.longitude;
918 packet1.altitude = packet_in.altitude;
919 packet1.speed = packet_in.speed;
920 packet1.course = packet_in.course;
921 packet1.target = packet_in.target;
922
923
924#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
925 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
926 // cope with extensions
927 memset(MAVLINK_MSG_ID_UAV_STATUS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_UAV_STATUS_MIN_LEN);
928 }
929#endif
930 memset(&packet2, 0, sizeof(packet2));
931 mavlink_msg_uav_status_encode(system_id, component_id, &msg, &packet1);
932 mavlink_msg_uav_status_decode(&msg, &packet2);
933 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
934
935 memset(&packet2, 0, sizeof(packet2));
936 mavlink_msg_uav_status_pack(system_id, component_id, &msg , packet1.target , packet1.latitude , packet1.longitude , packet1.altitude , packet1.speed , packet1.course );
937 mavlink_msg_uav_status_decode(&msg, &packet2);
938 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
939
940 memset(&packet2, 0, sizeof(packet2));
941 mavlink_msg_uav_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.latitude , packet1.longitude , packet1.altitude , packet1.speed , packet1.course );
942 mavlink_msg_uav_status_decode(&msg, &packet2);
943 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
944
945 memset(&packet2, 0, sizeof(packet2));
946 mavlink_msg_to_send_buffer(buffer, &msg);
947 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
948 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
949 }
950 mavlink_msg_uav_status_decode(last_msg, &packet2);
951 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
952
953 memset(&packet2, 0, sizeof(packet2));
954 mavlink_msg_uav_status_send(MAVLINK_COMM_1 , packet1.target , packet1.latitude , packet1.longitude , packet1.altitude , packet1.speed , packet1.course );
955 mavlink_msg_uav_status_decode(last_msg, &packet2);
956 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
957}
958
959static void mavlink_test_status_gps(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
960{
961#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
962 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
963 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_STATUS_GPS >= 256) {
964 return;
965 }
966#endif
967 mavlink_message_t msg;
968 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
969 uint16_t i;
970 mavlink_status_gps_t packet_in = {
971 17.0,17443,151,218,29,96,163
972 };
973 mavlink_status_gps_t packet1, packet2;
974 memset(&packet1, 0, sizeof(packet1));
975 packet1.magVar = packet_in.magVar;
976 packet1.csFails = packet_in.csFails;
977 packet1.gpsQuality = packet_in.gpsQuality;
978 packet1.msgsType = packet_in.msgsType;
979 packet1.posStatus = packet_in.posStatus;
980 packet1.magDir = packet_in.magDir;
981 packet1.modeInd = packet_in.modeInd;
982
983
984#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
985 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
986 // cope with extensions
987 memset(MAVLINK_MSG_ID_STATUS_GPS_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_STATUS_GPS_MIN_LEN);
988 }
989#endif
990 memset(&packet2, 0, sizeof(packet2));
991 mavlink_msg_status_gps_encode(system_id, component_id, &msg, &packet1);
992 mavlink_msg_status_gps_decode(&msg, &packet2);
993 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
994
995 memset(&packet2, 0, sizeof(packet2));
996 mavlink_msg_status_gps_pack(system_id, component_id, &msg , packet1.csFails , packet1.gpsQuality , packet1.msgsType , packet1.posStatus , packet1.magVar , packet1.magDir , packet1.modeInd );
997 mavlink_msg_status_gps_decode(&msg, &packet2);
998 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
999
1000 memset(&packet2, 0, sizeof(packet2));
1001 mavlink_msg_status_gps_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.csFails , packet1.gpsQuality , packet1.msgsType , packet1.posStatus , packet1.magVar , packet1.magDir , packet1.modeInd );
1002 mavlink_msg_status_gps_decode(&msg, &packet2);
1003 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1004
1005 memset(&packet2, 0, sizeof(packet2));
1006 mavlink_msg_to_send_buffer(buffer, &msg);
1007 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1008 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1009 }
1010 mavlink_msg_status_gps_decode(last_msg, &packet2);
1011 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1012
1013 memset(&packet2, 0, sizeof(packet2));
1014 mavlink_msg_status_gps_send(MAVLINK_COMM_1 , packet1.csFails , packet1.gpsQuality , packet1.msgsType , packet1.posStatus , packet1.magVar , packet1.magDir , packet1.modeInd );
1015 mavlink_msg_status_gps_decode(last_msg, &packet2);
1016 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1017}
1018
1019static void mavlink_test_novatel_diag(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1020{
1021#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1022 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1023 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_NOVATEL_DIAG >= 256) {
1024 return;
1025 }
1026#endif
1027 mavlink_message_t msg;
1028 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1029 uint16_t i;
1030 mavlink_novatel_diag_t packet_in = {
1031 963497464,45.0,17651,163,230,41,108
1032 };
1033 mavlink_novatel_diag_t packet1, packet2;
1034 memset(&packet1, 0, sizeof(packet1));
1035 packet1.receiverStatus = packet_in.receiverStatus;
1036 packet1.posSolAge = packet_in.posSolAge;
1037 packet1.csFails = packet_in.csFails;
1038 packet1.timeStatus = packet_in.timeStatus;
1039 packet1.solStatus = packet_in.solStatus;
1040 packet1.posType = packet_in.posType;
1041 packet1.velType = packet_in.velType;
1042
1043
1044#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1045 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1046 // cope with extensions
1047 memset(MAVLINK_MSG_ID_NOVATEL_DIAG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_NOVATEL_DIAG_MIN_LEN);
1048 }
1049#endif
1050 memset(&packet2, 0, sizeof(packet2));
1051 mavlink_msg_novatel_diag_encode(system_id, component_id, &msg, &packet1);
1052 mavlink_msg_novatel_diag_decode(&msg, &packet2);
1053 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1054
1055 memset(&packet2, 0, sizeof(packet2));
1056 mavlink_msg_novatel_diag_pack(system_id, component_id, &msg , packet1.timeStatus , packet1.receiverStatus , packet1.solStatus , packet1.posType , packet1.velType , packet1.posSolAge , packet1.csFails );
1057 mavlink_msg_novatel_diag_decode(&msg, &packet2);
1058 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1059
1060 memset(&packet2, 0, sizeof(packet2));
1061 mavlink_msg_novatel_diag_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.timeStatus , packet1.receiverStatus , packet1.solStatus , packet1.posType , packet1.velType , packet1.posSolAge , packet1.csFails );
1062 mavlink_msg_novatel_diag_decode(&msg, &packet2);
1063 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1064
1065 memset(&packet2, 0, sizeof(packet2));
1066 mavlink_msg_to_send_buffer(buffer, &msg);
1067 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1068 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1069 }
1070 mavlink_msg_novatel_diag_decode(last_msg, &packet2);
1071 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1072
1073 memset(&packet2, 0, sizeof(packet2));
1074 mavlink_msg_novatel_diag_send(MAVLINK_COMM_1 , packet1.timeStatus , packet1.receiverStatus , packet1.solStatus , packet1.posType , packet1.velType , packet1.posSolAge , packet1.csFails );
1075 mavlink_msg_novatel_diag_decode(last_msg, &packet2);
1076 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1077}
1078
1079static void mavlink_test_sensor_diag(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1080{
1081#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1082 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1083 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_SENSOR_DIAG >= 256) {
1084 return;
1085 }
1086#endif
1087 mavlink_message_t msg;
1088 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1089 uint16_t i;
1090 mavlink_sensor_diag_t packet_in = {
1091 17.0,45.0,17651,163
1092 };
1093 mavlink_sensor_diag_t packet1, packet2;
1094 memset(&packet1, 0, sizeof(packet1));
1095 packet1.float1 = packet_in.float1;
1096 packet1.float2 = packet_in.float2;
1097 packet1.int1 = packet_in.int1;
1098 packet1.char1 = packet_in.char1;
1099
1100
1101#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1102 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1103 // cope with extensions
1104 memset(MAVLINK_MSG_ID_SENSOR_DIAG_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_SENSOR_DIAG_MIN_LEN);
1105 }
1106#endif
1107 memset(&packet2, 0, sizeof(packet2));
1108 mavlink_msg_sensor_diag_encode(system_id, component_id, &msg, &packet1);
1109 mavlink_msg_sensor_diag_decode(&msg, &packet2);
1110 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1111
1112 memset(&packet2, 0, sizeof(packet2));
1113 mavlink_msg_sensor_diag_pack(system_id, component_id, &msg , packet1.float1 , packet1.float2 , packet1.int1 , packet1.char1 );
1114 mavlink_msg_sensor_diag_decode(&msg, &packet2);
1115 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1116
1117 memset(&packet2, 0, sizeof(packet2));
1118 mavlink_msg_sensor_diag_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.float1 , packet1.float2 , packet1.int1 , packet1.char1 );
1119 mavlink_msg_sensor_diag_decode(&msg, &packet2);
1120 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1121
1122 memset(&packet2, 0, sizeof(packet2));
1123 mavlink_msg_to_send_buffer(buffer, &msg);
1124 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1125 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1126 }
1127 mavlink_msg_sensor_diag_decode(last_msg, &packet2);
1128 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1129
1130 memset(&packet2, 0, sizeof(packet2));
1131 mavlink_msg_sensor_diag_send(MAVLINK_COMM_1 , packet1.float1 , packet1.float2 , packet1.int1 , packet1.char1 );
1132 mavlink_msg_sensor_diag_decode(last_msg, &packet2);
1133 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1134}
1135
1136static void mavlink_test_boot(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1137{
1138#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1139 mavlink_status_t *status = mavlink_get_channel_status(MAVLINK_COMM_0);
1140 if ((status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) && MAVLINK_MSG_ID_BOOT >= 256) {
1141 return;
1142 }
1143#endif
1144 mavlink_message_t msg;
1145 uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
1146 uint16_t i;
1147 mavlink_boot_t packet_in = {
1148 963497464
1149 };
1150 mavlink_boot_t packet1, packet2;
1151 memset(&packet1, 0, sizeof(packet1));
1152 packet1.version = packet_in.version;
1153
1154
1155#ifdef MAVLINK_STATUS_FLAG_OUT_MAVLINK1
1156 if (status->flags & MAVLINK_STATUS_FLAG_OUT_MAVLINK1) {
1157 // cope with extensions
1158 memset(MAVLINK_MSG_ID_BOOT_MIN_LEN + (char *)&packet1, 0, sizeof(packet1)-MAVLINK_MSG_ID_BOOT_MIN_LEN);
1159 }
1160#endif
1161 memset(&packet2, 0, sizeof(packet2));
1162 mavlink_msg_boot_encode(system_id, component_id, &msg, &packet1);
1163 mavlink_msg_boot_decode(&msg, &packet2);
1164 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1165
1166 memset(&packet2, 0, sizeof(packet2));
1167 mavlink_msg_boot_pack(system_id, component_id, &msg , packet1.version );
1168 mavlink_msg_boot_decode(&msg, &packet2);
1169 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1170
1171 memset(&packet2, 0, sizeof(packet2));
1172 mavlink_msg_boot_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.version );
1173 mavlink_msg_boot_decode(&msg, &packet2);
1174 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1175
1176 memset(&packet2, 0, sizeof(packet2));
1177 mavlink_msg_to_send_buffer(buffer, &msg);
1178 for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
1179 comm_send_ch(MAVLINK_COMM_0, buffer[i]);
1180 }
1181 mavlink_msg_boot_decode(last_msg, &packet2);
1182 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1183
1184 memset(&packet2, 0, sizeof(packet2));
1185 mavlink_msg_boot_send(MAVLINK_COMM_1 , packet1.version );
1186 mavlink_msg_boot_decode(last_msg, &packet2);
1187 MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
1188}
1189
1190static void mavlink_test_slugs(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
1191{
1192 mavlink_test_cpu_load(system_id, component_id, last_msg);
1193 mavlink_test_sensor_bias(system_id, component_id, last_msg);
1194 mavlink_test_diagnostic(system_id, component_id, last_msg);
1195 mavlink_test_slugs_navigation(system_id, component_id, last_msg);
1196 mavlink_test_data_log(system_id, component_id, last_msg);
1197 mavlink_test_gps_date_time(system_id, component_id, last_msg);
1198 mavlink_test_mid_lvl_cmds(system_id, component_id, last_msg);
1199 mavlink_test_ctrl_srfc_pt(system_id, component_id, last_msg);
1200 mavlink_test_slugs_camera_order(system_id, component_id, last_msg);
1201 mavlink_test_control_surface(system_id, component_id, last_msg);
1202 mavlink_test_slugs_mobile_location(system_id, component_id, last_msg);
1203 mavlink_test_slugs_configuration_camera(system_id, component_id, last_msg);
1204 mavlink_test_isr_location(system_id, component_id, last_msg);
1205 mavlink_test_volt_sensor(system_id, component_id, last_msg);
1206 mavlink_test_ptz_status(system_id, component_id, last_msg);
1207 mavlink_test_uav_status(system_id, component_id, last_msg);
1208 mavlink_test_status_gps(system_id, component_id, last_msg);
1209 mavlink_test_novatel_diag(system_id, component_id, last_msg);
1210 mavlink_test_sensor_diag(system_id, component_id, last_msg);
1211 mavlink_test_boot(system_id, component_id, last_msg);
1212}
1213
1214#ifdef __cplusplus
1215}
1216#endif // __cplusplus
1217#endif // SLUGS_TESTSUITE_H
testsuite.h
MAVLink comm protocol testsuite generated from common.xml
__mavlink_status
定义 mavlink_types.h:217
__mavlink_status::flags
uint8_t flags
MAVLINK_STATUS_FLAG_*
定义 mavlink_types.h:227
制作者 doxygen 1.11.0