WebSVN - Projects - Blame - Rev 1702 - /C-OSD/arducam-osd/libraries/GCS_MAVLink/include/mavlink/v0.9/common/testsuite.h

Rev	Author	Line No.	Line
1702	-	1	/** @file
		2	* @brief MAVLink comm protocol testsuite generated from common.xml
		3	* @see http://qgroundcontrol.org/mavlink/
		4	*/
		5	#ifndef COMMON_TESTSUITE_H
		6	#define COMMON_TESTSUITE_H
		7
		8	#ifdef __cplusplus
		9	extern "C" {
		10	#endif
		11
		12	#ifndef MAVLINK_TEST_ALL
		13	#define MAVLINK_TEST_ALL
		14
		15	static void mavlink_test_common(uint8_t, uint8_t, mavlink_message_t *last_msg);
		16
		17	static void mavlink_test_all(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		18	{
		19
		20	mavlink_test_common(system_id, component_id, last_msg);
		21	}
		22	#endif
		23
		24
		25
		26
		27	static void mavlink_test_heartbeat(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		28	{
		29	mavlink_message_t msg;
		30	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		31	uint16_t i;
		32	mavlink_heartbeat_t packet_in = {
		33	5,
		34	72,
		35	2,
		36	};
		37	mavlink_heartbeat_t packet1, packet2;
		38	memset(&packet1, 0, sizeof(packet1));
		39	packet1.type = packet_in.type;
		40	packet1.autopilot = packet_in.autopilot;
		41	packet1.mavlink_version = packet_in.mavlink_version;
		42
		43
		44
		45	memset(&packet2, 0, sizeof(packet2));
		46	mavlink_msg_heartbeat_encode(system_id, component_id, &msg, &packet1);
		47	mavlink_msg_heartbeat_decode(&msg, &packet2);
		48	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		49
		50	memset(&packet2, 0, sizeof(packet2));
		51	mavlink_msg_heartbeat_pack(system_id, component_id, &msg , packet1.type , packet1.autopilot );
		52	mavlink_msg_heartbeat_decode(&msg, &packet2);
		53	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		54
		55	memset(&packet2, 0, sizeof(packet2));
		56	mavlink_msg_heartbeat_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.type , packet1.autopilot );
		57	mavlink_msg_heartbeat_decode(&msg, &packet2);
		58	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		59
		60	memset(&packet2, 0, sizeof(packet2));
		61	mavlink_msg_to_send_buffer(buffer, &msg);
		62	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		63	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		64	}
		65	mavlink_msg_heartbeat_decode(last_msg, &packet2);
		66	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		67
		68	memset(&packet2, 0, sizeof(packet2));
		69	mavlink_msg_heartbeat_send(MAVLINK_COMM_1 , packet1.type , packet1.autopilot );
		70	mavlink_msg_heartbeat_decode(last_msg, &packet2);
		71	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		72	}
		73
		74	static void mavlink_test_boot(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		75	{
		76	mavlink_message_t msg;
		77	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		78	uint16_t i;
		79	mavlink_boot_t packet_in = {
		80	963497464,
		81	};
		82	mavlink_boot_t packet1, packet2;
		83	memset(&packet1, 0, sizeof(packet1));
		84	packet1.version = packet_in.version;
		85
		86
		87
		88	memset(&packet2, 0, sizeof(packet2));
		89	mavlink_msg_boot_encode(system_id, component_id, &msg, &packet1);
		90	mavlink_msg_boot_decode(&msg, &packet2);
		91	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		92
		93	memset(&packet2, 0, sizeof(packet2));
		94	mavlink_msg_boot_pack(system_id, component_id, &msg , packet1.version );
		95	mavlink_msg_boot_decode(&msg, &packet2);
		96	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		97
		98	memset(&packet2, 0, sizeof(packet2));
		99	mavlink_msg_boot_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.version );
		100	mavlink_msg_boot_decode(&msg, &packet2);
		101	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		102
		103	memset(&packet2, 0, sizeof(packet2));
		104	mavlink_msg_to_send_buffer(buffer, &msg);
		105	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		106	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		107	}
		108	mavlink_msg_boot_decode(last_msg, &packet2);
		109	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		110
		111	memset(&packet2, 0, sizeof(packet2));
		112	mavlink_msg_boot_send(MAVLINK_COMM_1 , packet1.version );
		113	mavlink_msg_boot_decode(last_msg, &packet2);
		114	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		115	}
		116
		117	static void mavlink_test_system_time(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		118	{
		119	mavlink_message_t msg;
		120	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		121	uint16_t i;
		122	mavlink_system_time_t packet_in = {
		123	93372036854775807ULL,
		124	};
		125	mavlink_system_time_t packet1, packet2;
		126	memset(&packet1, 0, sizeof(packet1));
		127	packet1.time_usec = packet_in.time_usec;
		128
		129
		130
		131	memset(&packet2, 0, sizeof(packet2));
		132	mavlink_msg_system_time_encode(system_id, component_id, &msg, &packet1);
		133	mavlink_msg_system_time_decode(&msg, &packet2);
		134	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		135
		136	memset(&packet2, 0, sizeof(packet2));
		137	mavlink_msg_system_time_pack(system_id, component_id, &msg , packet1.time_usec );
		138	mavlink_msg_system_time_decode(&msg, &packet2);
		139	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		140
		141	memset(&packet2, 0, sizeof(packet2));
		142	mavlink_msg_system_time_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_usec );
		143	mavlink_msg_system_time_decode(&msg, &packet2);
		144	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		145
		146	memset(&packet2, 0, sizeof(packet2));
		147	mavlink_msg_to_send_buffer(buffer, &msg);
		148	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		149	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		150	}
		151	mavlink_msg_system_time_decode(last_msg, &packet2);
		152	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		153
		154	memset(&packet2, 0, sizeof(packet2));
		155	mavlink_msg_system_time_send(MAVLINK_COMM_1 , packet1.time_usec );
		156	mavlink_msg_system_time_decode(last_msg, &packet2);
		157	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		158	}
		159
		160	static void mavlink_test_ping(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		161	{
		162	mavlink_message_t msg;
		163	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		164	uint16_t i;
		165	mavlink_ping_t packet_in = {
		166	963497464,
		167	17,
		168	84,
		169	93372036854776185ULL,
		170	};
		171	mavlink_ping_t packet1, packet2;
		172	memset(&packet1, 0, sizeof(packet1));
		173	packet1.seq = packet_in.seq;
		174	packet1.target_system = packet_in.target_system;
		175	packet1.target_component = packet_in.target_component;
		176	packet1.time = packet_in.time;
		177
		178
		179
		180	memset(&packet2, 0, sizeof(packet2));
		181	mavlink_msg_ping_encode(system_id, component_id, &msg, &packet1);
		182	mavlink_msg_ping_decode(&msg, &packet2);
		183	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		184
		185	memset(&packet2, 0, sizeof(packet2));
		186	mavlink_msg_ping_pack(system_id, component_id, &msg , packet1.seq , packet1.target_system , packet1.target_component , packet1.time );
		187	mavlink_msg_ping_decode(&msg, &packet2);
		188	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		189
		190	memset(&packet2, 0, sizeof(packet2));
		191	mavlink_msg_ping_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.seq , packet1.target_system , packet1.target_component , packet1.time );
		192	mavlink_msg_ping_decode(&msg, &packet2);
		193	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		194
		195	memset(&packet2, 0, sizeof(packet2));
		196	mavlink_msg_to_send_buffer(buffer, &msg);
		197	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		198	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		199	}
		200	mavlink_msg_ping_decode(last_msg, &packet2);
		201	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		202
		203	memset(&packet2, 0, sizeof(packet2));
		204	mavlink_msg_ping_send(MAVLINK_COMM_1 , packet1.seq , packet1.target_system , packet1.target_component , packet1.time );
		205	mavlink_msg_ping_decode(last_msg, &packet2);
		206	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		207	}
		208
		209	static void mavlink_test_system_time_utc(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		210	{
		211	mavlink_message_t msg;
		212	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		213	uint16_t i;
		214	mavlink_system_time_utc_t packet_in = {
		215	963497464,
		216	963497672,
		217	};
		218	mavlink_system_time_utc_t packet1, packet2;
		219	memset(&packet1, 0, sizeof(packet1));
		220	packet1.utc_date = packet_in.utc_date;
		221	packet1.utc_time = packet_in.utc_time;
		222
		223
		224
		225	memset(&packet2, 0, sizeof(packet2));
		226	mavlink_msg_system_time_utc_encode(system_id, component_id, &msg, &packet1);
		227	mavlink_msg_system_time_utc_decode(&msg, &packet2);
		228	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		229
		230	memset(&packet2, 0, sizeof(packet2));
		231	mavlink_msg_system_time_utc_pack(system_id, component_id, &msg , packet1.utc_date , packet1.utc_time );
		232	mavlink_msg_system_time_utc_decode(&msg, &packet2);
		233	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		234
		235	memset(&packet2, 0, sizeof(packet2));
		236	mavlink_msg_system_time_utc_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.utc_date , packet1.utc_time );
		237	mavlink_msg_system_time_utc_decode(&msg, &packet2);
		238	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		239
		240	memset(&packet2, 0, sizeof(packet2));
		241	mavlink_msg_to_send_buffer(buffer, &msg);
		242	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		243	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		244	}
		245	mavlink_msg_system_time_utc_decode(last_msg, &packet2);
		246	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		247
		248	memset(&packet2, 0, sizeof(packet2));
		249	mavlink_msg_system_time_utc_send(MAVLINK_COMM_1 , packet1.utc_date , packet1.utc_time );
		250	mavlink_msg_system_time_utc_decode(last_msg, &packet2);
		251	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		252	}
		253
		254	static void mavlink_test_change_operator_control(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		255	{
		256	mavlink_message_t msg;
		257	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		258	uint16_t i;
		259	mavlink_change_operator_control_t packet_in = {
		260	5,
		261	72,
		262	139,
		263	"DEFGHIJKLMNOPQRSTUVWXYZA",
		264	};
		265	mavlink_change_operator_control_t packet1, packet2;
		266	memset(&packet1, 0, sizeof(packet1));
		267	packet1.target_system = packet_in.target_system;
		268	packet1.control_request = packet_in.control_request;
		269	packet1.version = packet_in.version;
		270
		271	mav_array_memcpy(packet1.passkey, packet_in.passkey, sizeof(char)*25);
		272
		273
		274	memset(&packet2, 0, sizeof(packet2));
		275	mavlink_msg_change_operator_control_encode(system_id, component_id, &msg, &packet1);
		276	mavlink_msg_change_operator_control_decode(&msg, &packet2);
		277	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		278
		279	memset(&packet2, 0, sizeof(packet2));
		280	mavlink_msg_change_operator_control_pack(system_id, component_id, &msg , packet1.target_system , packet1.control_request , packet1.version , packet1.passkey );
		281	mavlink_msg_change_operator_control_decode(&msg, &packet2);
		282	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		283
		284	memset(&packet2, 0, sizeof(packet2));
		285	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 );
		286	mavlink_msg_change_operator_control_decode(&msg, &packet2);
		287	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		288
		289	memset(&packet2, 0, sizeof(packet2));
		290	mavlink_msg_to_send_buffer(buffer, &msg);
		291	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		292	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		293	}
		294	mavlink_msg_change_operator_control_decode(last_msg, &packet2);
		295	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		296
		297	memset(&packet2, 0, sizeof(packet2));
		298	mavlink_msg_change_operator_control_send(MAVLINK_COMM_1 , packet1.target_system , packet1.control_request , packet1.version , packet1.passkey );
		299	mavlink_msg_change_operator_control_decode(last_msg, &packet2);
		300	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		301	}
		302
		303	static void mavlink_test_change_operator_control_ack(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		304	{
		305	mavlink_message_t msg;
		306	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		307	uint16_t i;
		308	mavlink_change_operator_control_ack_t packet_in = {
		309	5,
		310	72,
		311	139,
		312	};
		313	mavlink_change_operator_control_ack_t packet1, packet2;
		314	memset(&packet1, 0, sizeof(packet1));
		315	packet1.gcs_system_id = packet_in.gcs_system_id;
		316	packet1.control_request = packet_in.control_request;
		317	packet1.ack = packet_in.ack;
		318
		319
		320
		321	memset(&packet2, 0, sizeof(packet2));
		322	mavlink_msg_change_operator_control_ack_encode(system_id, component_id, &msg, &packet1);
		323	mavlink_msg_change_operator_control_ack_decode(&msg, &packet2);
		324	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		325
		326	memset(&packet2, 0, sizeof(packet2));
		327	mavlink_msg_change_operator_control_ack_pack(system_id, component_id, &msg , packet1.gcs_system_id , packet1.control_request , packet1.ack );
		328	mavlink_msg_change_operator_control_ack_decode(&msg, &packet2);
		329	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		330
		331	memset(&packet2, 0, sizeof(packet2));
		332	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 );
		333	mavlink_msg_change_operator_control_ack_decode(&msg, &packet2);
		334	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		335
		336	memset(&packet2, 0, sizeof(packet2));
		337	mavlink_msg_to_send_buffer(buffer, &msg);
		338	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		339	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		340	}
		341	mavlink_msg_change_operator_control_ack_decode(last_msg, &packet2);
		342	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		343
		344	memset(&packet2, 0, sizeof(packet2));
		345	mavlink_msg_change_operator_control_ack_send(MAVLINK_COMM_1 , packet1.gcs_system_id , packet1.control_request , packet1.ack );
		346	mavlink_msg_change_operator_control_ack_decode(last_msg, &packet2);
		347	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		348	}
		349
		350	static void mavlink_test_auth_key(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		351	{
		352	mavlink_message_t msg;
		353	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		354	uint16_t i;
		355	mavlink_auth_key_t packet_in = {
		356	"ABCDEFGHIJKLMNOPQRSTUVWXYZABCDE",
		357	};
		358	mavlink_auth_key_t packet1, packet2;
		359	memset(&packet1, 0, sizeof(packet1));
		360
		361	mav_array_memcpy(packet1.key, packet_in.key, sizeof(char)*32);
		362
		363
		364	memset(&packet2, 0, sizeof(packet2));
		365	mavlink_msg_auth_key_encode(system_id, component_id, &msg, &packet1);
		366	mavlink_msg_auth_key_decode(&msg, &packet2);
		367	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		368
		369	memset(&packet2, 0, sizeof(packet2));
		370	mavlink_msg_auth_key_pack(system_id, component_id, &msg , packet1.key );
		371	mavlink_msg_auth_key_decode(&msg, &packet2);
		372	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		373
		374	memset(&packet2, 0, sizeof(packet2));
		375	mavlink_msg_auth_key_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.key );
		376	mavlink_msg_auth_key_decode(&msg, &packet2);
		377	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		378
		379	memset(&packet2, 0, sizeof(packet2));
		380	mavlink_msg_to_send_buffer(buffer, &msg);
		381	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		382	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		383	}
		384	mavlink_msg_auth_key_decode(last_msg, &packet2);
		385	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		386
		387	memset(&packet2, 0, sizeof(packet2));
		388	mavlink_msg_auth_key_send(MAVLINK_COMM_1 , packet1.key );
		389	mavlink_msg_auth_key_decode(last_msg, &packet2);
		390	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		391	}
		392
		393	static void mavlink_test_action_ack(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		394	{
		395	mavlink_message_t msg;
		396	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		397	uint16_t i;
		398	mavlink_action_ack_t packet_in = {
		399	5,
		400	72,
		401	};
		402	mavlink_action_ack_t packet1, packet2;
		403	memset(&packet1, 0, sizeof(packet1));
		404	packet1.action = packet_in.action;
		405	packet1.result = packet_in.result;
		406
		407
		408
		409	memset(&packet2, 0, sizeof(packet2));
		410	mavlink_msg_action_ack_encode(system_id, component_id, &msg, &packet1);
		411	mavlink_msg_action_ack_decode(&msg, &packet2);
		412	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		413
		414	memset(&packet2, 0, sizeof(packet2));
		415	mavlink_msg_action_ack_pack(system_id, component_id, &msg , packet1.action , packet1.result );
		416	mavlink_msg_action_ack_decode(&msg, &packet2);
		417	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		418
		419	memset(&packet2, 0, sizeof(packet2));
		420	mavlink_msg_action_ack_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.action , packet1.result );
		421	mavlink_msg_action_ack_decode(&msg, &packet2);
		422	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		423
		424	memset(&packet2, 0, sizeof(packet2));
		425	mavlink_msg_to_send_buffer(buffer, &msg);
		426	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		427	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		428	}
		429	mavlink_msg_action_ack_decode(last_msg, &packet2);
		430	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		431
		432	memset(&packet2, 0, sizeof(packet2));
		433	mavlink_msg_action_ack_send(MAVLINK_COMM_1 , packet1.action , packet1.result );
		434	mavlink_msg_action_ack_decode(last_msg, &packet2);
		435	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		436	}
		437
		438	static void mavlink_test_action(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		439	{
		440	mavlink_message_t msg;
		441	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		442	uint16_t i;
		443	mavlink_action_t packet_in = {
		444	5,
		445	72,
		446	139,
		447	};
		448	mavlink_action_t packet1, packet2;
		449	memset(&packet1, 0, sizeof(packet1));
		450	packet1.target = packet_in.target;
		451	packet1.target_component = packet_in.target_component;
		452	packet1.action = packet_in.action;
		453
		454
		455
		456	memset(&packet2, 0, sizeof(packet2));
		457	mavlink_msg_action_encode(system_id, component_id, &msg, &packet1);
		458	mavlink_msg_action_decode(&msg, &packet2);
		459	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		460
		461	memset(&packet2, 0, sizeof(packet2));
		462	mavlink_msg_action_pack(system_id, component_id, &msg , packet1.target , packet1.target_component , packet1.action );
		463	mavlink_msg_action_decode(&msg, &packet2);
		464	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		465
		466	memset(&packet2, 0, sizeof(packet2));
		467	mavlink_msg_action_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.target_component , packet1.action );
		468	mavlink_msg_action_decode(&msg, &packet2);
		469	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		470
		471	memset(&packet2, 0, sizeof(packet2));
		472	mavlink_msg_to_send_buffer(buffer, &msg);
		473	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		474	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		475	}
		476	mavlink_msg_action_decode(last_msg, &packet2);
		477	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		478
		479	memset(&packet2, 0, sizeof(packet2));
		480	mavlink_msg_action_send(MAVLINK_COMM_1 , packet1.target , packet1.target_component , packet1.action );
		481	mavlink_msg_action_decode(last_msg, &packet2);
		482	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		483	}
		484
		485	static void mavlink_test_set_mode(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		486	{
		487	mavlink_message_t msg;
		488	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		489	uint16_t i;
		490	mavlink_set_mode_t packet_in = {
		491	5,
		492	72,
		493	};
		494	mavlink_set_mode_t packet1, packet2;
		495	memset(&packet1, 0, sizeof(packet1));
		496	packet1.target = packet_in.target;
		497	packet1.mode = packet_in.mode;
		498
		499
		500
		501	memset(&packet2, 0, sizeof(packet2));
		502	mavlink_msg_set_mode_encode(system_id, component_id, &msg, &packet1);
		503	mavlink_msg_set_mode_decode(&msg, &packet2);
		504	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		505
		506	memset(&packet2, 0, sizeof(packet2));
		507	mavlink_msg_set_mode_pack(system_id, component_id, &msg , packet1.target , packet1.mode );
		508	mavlink_msg_set_mode_decode(&msg, &packet2);
		509	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		510
		511	memset(&packet2, 0, sizeof(packet2));
		512	mavlink_msg_set_mode_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.mode );
		513	mavlink_msg_set_mode_decode(&msg, &packet2);
		514	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		515
		516	memset(&packet2, 0, sizeof(packet2));
		517	mavlink_msg_to_send_buffer(buffer, &msg);
		518	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		519	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		520	}
		521	mavlink_msg_set_mode_decode(last_msg, &packet2);
		522	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		523
		524	memset(&packet2, 0, sizeof(packet2));
		525	mavlink_msg_set_mode_send(MAVLINK_COMM_1 , packet1.target , packet1.mode );
		526	mavlink_msg_set_mode_decode(last_msg, &packet2);
		527	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		528	}
		529
		530	static void mavlink_test_set_nav_mode(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		531	{
		532	mavlink_message_t msg;
		533	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		534	uint16_t i;
		535	mavlink_set_nav_mode_t packet_in = {
		536	5,
		537	72,
		538	};
		539	mavlink_set_nav_mode_t packet1, packet2;
		540	memset(&packet1, 0, sizeof(packet1));
		541	packet1.target = packet_in.target;
		542	packet1.nav_mode = packet_in.nav_mode;
		543
		544
		545
		546	memset(&packet2, 0, sizeof(packet2));
		547	mavlink_msg_set_nav_mode_encode(system_id, component_id, &msg, &packet1);
		548	mavlink_msg_set_nav_mode_decode(&msg, &packet2);
		549	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		550
		551	memset(&packet2, 0, sizeof(packet2));
		552	mavlink_msg_set_nav_mode_pack(system_id, component_id, &msg , packet1.target , packet1.nav_mode );
		553	mavlink_msg_set_nav_mode_decode(&msg, &packet2);
		554	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		555
		556	memset(&packet2, 0, sizeof(packet2));
		557	mavlink_msg_set_nav_mode_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.nav_mode );
		558	mavlink_msg_set_nav_mode_decode(&msg, &packet2);
		559	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		560
		561	memset(&packet2, 0, sizeof(packet2));
		562	mavlink_msg_to_send_buffer(buffer, &msg);
		563	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		564	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		565	}
		566	mavlink_msg_set_nav_mode_decode(last_msg, &packet2);
		567	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		568
		569	memset(&packet2, 0, sizeof(packet2));
		570	mavlink_msg_set_nav_mode_send(MAVLINK_COMM_1 , packet1.target , packet1.nav_mode );
		571	mavlink_msg_set_nav_mode_decode(last_msg, &packet2);
		572	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		573	}
		574
		575	static void mavlink_test_param_request_read(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		576	{
		577	mavlink_message_t msg;
		578	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		579	uint16_t i;
		580	mavlink_param_request_read_t packet_in = {
		581	5,
		582	72,
		583	{ 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153 },
		584	18119,
		585	};
		586	mavlink_param_request_read_t packet1, packet2;
		587	memset(&packet1, 0, sizeof(packet1));
		588	packet1.target_system = packet_in.target_system;
		589	packet1.target_component = packet_in.target_component;
		590	packet1.param_index = packet_in.param_index;
		591
		592	mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(int8_t)*15);
		593
		594
		595	memset(&packet2, 0, sizeof(packet2));
		596	mavlink_msg_param_request_read_encode(system_id, component_id, &msg, &packet1);
		597	mavlink_msg_param_request_read_decode(&msg, &packet2);
		598	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		599
		600	memset(&packet2, 0, sizeof(packet2));
		601	mavlink_msg_param_request_read_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index );
		602	mavlink_msg_param_request_read_decode(&msg, &packet2);
		603	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		604
		605	memset(&packet2, 0, sizeof(packet2));
		606	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 );
		607	mavlink_msg_param_request_read_decode(&msg, &packet2);
		608	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		609
		610	memset(&packet2, 0, sizeof(packet2));
		611	mavlink_msg_to_send_buffer(buffer, &msg);
		612	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		613	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		614	}
		615	mavlink_msg_param_request_read_decode(last_msg, &packet2);
		616	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		617
		618	memset(&packet2, 0, sizeof(packet2));
		619	mavlink_msg_param_request_read_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_index );
		620	mavlink_msg_param_request_read_decode(last_msg, &packet2);
		621	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		622	}
		623
		624	static void mavlink_test_param_request_list(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		625	{
		626	mavlink_message_t msg;
		627	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		628	uint16_t i;
		629	mavlink_param_request_list_t packet_in = {
		630	5,
		631	72,
		632	};
		633	mavlink_param_request_list_t packet1, packet2;
		634	memset(&packet1, 0, sizeof(packet1));
		635	packet1.target_system = packet_in.target_system;
		636	packet1.target_component = packet_in.target_component;
		637
		638
		639
		640	memset(&packet2, 0, sizeof(packet2));
		641	mavlink_msg_param_request_list_encode(system_id, component_id, &msg, &packet1);
		642	mavlink_msg_param_request_list_decode(&msg, &packet2);
		643	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		644
		645	memset(&packet2, 0, sizeof(packet2));
		646	mavlink_msg_param_request_list_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component );
		647	mavlink_msg_param_request_list_decode(&msg, &packet2);
		648	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		649
		650	memset(&packet2, 0, sizeof(packet2));
		651	mavlink_msg_param_request_list_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component );
		652	mavlink_msg_param_request_list_decode(&msg, &packet2);
		653	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		654
		655	memset(&packet2, 0, sizeof(packet2));
		656	mavlink_msg_to_send_buffer(buffer, &msg);
		657	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		658	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		659	}
		660	mavlink_msg_param_request_list_decode(last_msg, &packet2);
		661	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		662
		663	memset(&packet2, 0, sizeof(packet2));
		664	mavlink_msg_param_request_list_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component );
		665	mavlink_msg_param_request_list_decode(last_msg, &packet2);
		666	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		667	}
		668
		669	static void mavlink_test_param_value(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		670	{
		671	mavlink_message_t msg;
		672	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		673	uint16_t i;
		674	mavlink_param_value_t packet_in = {
		675	{ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 },
		676	122.0,
		677	18223,
		678	18327,
		679	};
		680	mavlink_param_value_t packet1, packet2;
		681	memset(&packet1, 0, sizeof(packet1));
		682	packet1.param_value = packet_in.param_value;
		683	packet1.param_count = packet_in.param_count;
		684	packet1.param_index = packet_in.param_index;
		685
		686	mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(int8_t)*15);
		687
		688
		689	memset(&packet2, 0, sizeof(packet2));
		690	mavlink_msg_param_value_encode(system_id, component_id, &msg, &packet1);
		691	mavlink_msg_param_value_decode(&msg, &packet2);
		692	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		693
		694	memset(&packet2, 0, sizeof(packet2));
		695	mavlink_msg_param_value_pack(system_id, component_id, &msg , packet1.param_id , packet1.param_value , packet1.param_count , packet1.param_index );
		696	mavlink_msg_param_value_decode(&msg, &packet2);
		697	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		698
		699	memset(&packet2, 0, sizeof(packet2));
		700	mavlink_msg_param_value_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.param_id , packet1.param_value , packet1.param_count , packet1.param_index );
		701	mavlink_msg_param_value_decode(&msg, &packet2);
		702	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		703
		704	memset(&packet2, 0, sizeof(packet2));
		705	mavlink_msg_to_send_buffer(buffer, &msg);
		706	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		707	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		708	}
		709	mavlink_msg_param_value_decode(last_msg, &packet2);
		710	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		711
		712	memset(&packet2, 0, sizeof(packet2));
		713	mavlink_msg_param_value_send(MAVLINK_COMM_1 , packet1.param_id , packet1.param_value , packet1.param_count , packet1.param_index );
		714	mavlink_msg_param_value_decode(last_msg, &packet2);
		715	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		716	}
		717
		718	static void mavlink_test_param_set(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		719	{
		720	mavlink_message_t msg;
		721	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		722	uint16_t i;
		723	mavlink_param_set_t packet_in = {
		724	5,
		725	72,
		726	{ 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153 },
		727	136.0,
		728	};
		729	mavlink_param_set_t packet1, packet2;
		730	memset(&packet1, 0, sizeof(packet1));
		731	packet1.target_system = packet_in.target_system;
		732	packet1.target_component = packet_in.target_component;
		733	packet1.param_value = packet_in.param_value;
		734
		735	mav_array_memcpy(packet1.param_id, packet_in.param_id, sizeof(int8_t)*15);
		736
		737
		738	memset(&packet2, 0, sizeof(packet2));
		739	mavlink_msg_param_set_encode(system_id, component_id, &msg, &packet1);
		740	mavlink_msg_param_set_decode(&msg, &packet2);
		741	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		742
		743	memset(&packet2, 0, sizeof(packet2));
		744	mavlink_msg_param_set_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_value );
		745	mavlink_msg_param_set_decode(&msg, &packet2);
		746	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		747
		748	memset(&packet2, 0, sizeof(packet2));
		749	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 );
		750	mavlink_msg_param_set_decode(&msg, &packet2);
		751	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		752
		753	memset(&packet2, 0, sizeof(packet2));
		754	mavlink_msg_to_send_buffer(buffer, &msg);
		755	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		756	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		757	}
		758	mavlink_msg_param_set_decode(last_msg, &packet2);
		759	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		760
		761	memset(&packet2, 0, sizeof(packet2));
		762	mavlink_msg_param_set_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.param_id , packet1.param_value );
		763	mavlink_msg_param_set_decode(last_msg, &packet2);
		764	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		765	}
		766
		767	static void mavlink_test_gps_raw_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		768	{
		769	mavlink_message_t msg;
		770	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		771	uint16_t i;
		772	mavlink_gps_raw_int_t packet_in = {
		773	93372036854775807ULL,
		774	29,
		775	963497932,
		776	963498140,
		777	963498348,
		778	164.0,
		779	192.0,
		780	220.0,
		781	248.0,
		782	};
		783	mavlink_gps_raw_int_t packet1, packet2;
		784	memset(&packet1, 0, sizeof(packet1));
		785	packet1.usec = packet_in.usec;
		786	packet1.fix_type = packet_in.fix_type;
		787	packet1.lat = packet_in.lat;
		788	packet1.lon = packet_in.lon;
		789	packet1.alt = packet_in.alt;
		790	packet1.eph = packet_in.eph;
		791	packet1.epv = packet_in.epv;
		792	packet1.v = packet_in.v;
		793	packet1.hdg = packet_in.hdg;
		794
		795
		796
		797	memset(&packet2, 0, sizeof(packet2));
		798	mavlink_msg_gps_raw_int_encode(system_id, component_id, &msg, &packet1);
		799	mavlink_msg_gps_raw_int_decode(&msg, &packet2);
		800	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		801
		802	memset(&packet2, 0, sizeof(packet2));
		803	mavlink_msg_gps_raw_int_pack(system_id, component_id, &msg , packet1.usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.v , packet1.hdg );
		804	mavlink_msg_gps_raw_int_decode(&msg, &packet2);
		805	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		806
		807	memset(&packet2, 0, sizeof(packet2));
		808	mavlink_msg_gps_raw_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.v , packet1.hdg );
		809	mavlink_msg_gps_raw_int_decode(&msg, &packet2);
		810	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		811
		812	memset(&packet2, 0, sizeof(packet2));
		813	mavlink_msg_to_send_buffer(buffer, &msg);
		814	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		815	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		816	}
		817	mavlink_msg_gps_raw_int_decode(last_msg, &packet2);
		818	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		819
		820	memset(&packet2, 0, sizeof(packet2));
		821	mavlink_msg_gps_raw_int_send(MAVLINK_COMM_1 , packet1.usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.v , packet1.hdg );
		822	mavlink_msg_gps_raw_int_decode(last_msg, &packet2);
		823	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		824	}
		825
		826	static void mavlink_test_scaled_imu(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		827	{
		828	mavlink_message_t msg;
		829	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		830	uint16_t i;
		831	mavlink_scaled_imu_t packet_in = {
		832	93372036854775807ULL,
		833	17651,
		834	17755,
		835	17859,
		836	17963,
		837	18067,
		838	18171,
		839	18275,
		840	18379,
		841	18483,
		842	};
		843	mavlink_scaled_imu_t packet1, packet2;
		844	memset(&packet1, 0, sizeof(packet1));
		845	packet1.usec = packet_in.usec;
		846	packet1.xacc = packet_in.xacc;
		847	packet1.yacc = packet_in.yacc;
		848	packet1.zacc = packet_in.zacc;
		849	packet1.xgyro = packet_in.xgyro;
		850	packet1.ygyro = packet_in.ygyro;
		851	packet1.zgyro = packet_in.zgyro;
		852	packet1.xmag = packet_in.xmag;
		853	packet1.ymag = packet_in.ymag;
		854	packet1.zmag = packet_in.zmag;
		855
		856
		857
		858	memset(&packet2, 0, sizeof(packet2));
		859	mavlink_msg_scaled_imu_encode(system_id, component_id, &msg, &packet1);
		860	mavlink_msg_scaled_imu_decode(&msg, &packet2);
		861	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		862
		863	memset(&packet2, 0, sizeof(packet2));
		864	mavlink_msg_scaled_imu_pack(system_id, component_id, &msg , packet1.usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
		865	mavlink_msg_scaled_imu_decode(&msg, &packet2);
		866	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		867
		868	memset(&packet2, 0, sizeof(packet2));
		869	mavlink_msg_scaled_imu_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
		870	mavlink_msg_scaled_imu_decode(&msg, &packet2);
		871	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		872
		873	memset(&packet2, 0, sizeof(packet2));
		874	mavlink_msg_to_send_buffer(buffer, &msg);
		875	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		876	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		877	}
		878	mavlink_msg_scaled_imu_decode(last_msg, &packet2);
		879	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		880
		881	memset(&packet2, 0, sizeof(packet2));
		882	mavlink_msg_scaled_imu_send(MAVLINK_COMM_1 , packet1.usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
		883	mavlink_msg_scaled_imu_decode(last_msg, &packet2);
		884	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		885	}
		886
		887	static void mavlink_test_gps_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		888	{
		889	mavlink_message_t msg;
		890	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		891	uint16_t i;
		892	mavlink_gps_status_t packet_in = {
		893	5,
		894	{ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91 },
		895	{ 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151 },
		896	{ 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211 },
		897	{ 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
		898	{ 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 },
		899	};
		900	mavlink_gps_status_t packet1, packet2;
		901	memset(&packet1, 0, sizeof(packet1));
		902	packet1.satellites_visible = packet_in.satellites_visible;
		903
		904	mav_array_memcpy(packet1.satellite_prn, packet_in.satellite_prn, sizeof(int8_t)*20);
		905	mav_array_memcpy(packet1.satellite_used, packet_in.satellite_used, sizeof(int8_t)*20);
		906	mav_array_memcpy(packet1.satellite_elevation, packet_in.satellite_elevation, sizeof(int8_t)*20);
		907	mav_array_memcpy(packet1.satellite_azimuth, packet_in.satellite_azimuth, sizeof(int8_t)*20);
		908	mav_array_memcpy(packet1.satellite_snr, packet_in.satellite_snr, sizeof(int8_t)*20);
		909
		910
		911	memset(&packet2, 0, sizeof(packet2));
		912	mavlink_msg_gps_status_encode(system_id, component_id, &msg, &packet1);
		913	mavlink_msg_gps_status_decode(&msg, &packet2);
		914	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		915
		916	memset(&packet2, 0, sizeof(packet2));
		917	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 );
		918	mavlink_msg_gps_status_decode(&msg, &packet2);
		919	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		920
		921	memset(&packet2, 0, sizeof(packet2));
		922	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 );
		923	mavlink_msg_gps_status_decode(&msg, &packet2);
		924	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		925
		926	memset(&packet2, 0, sizeof(packet2));
		927	mavlink_msg_to_send_buffer(buffer, &msg);
		928	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		929	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		930	}
		931	mavlink_msg_gps_status_decode(last_msg, &packet2);
		932	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		933
		934	memset(&packet2, 0, sizeof(packet2));
		935	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 );
		936	mavlink_msg_gps_status_decode(last_msg, &packet2);
		937	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		938	}
		939
		940	static void mavlink_test_raw_imu(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		941	{
		942	mavlink_message_t msg;
		943	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		944	uint16_t i;
		945	mavlink_raw_imu_t packet_in = {
		946	93372036854775807ULL,
		947	17651,
		948	17755,
		949	17859,
		950	17963,
		951	18067,
		952	18171,
		953	18275,
		954	18379,
		955	18483,
		956	};
		957	mavlink_raw_imu_t packet1, packet2;
		958	memset(&packet1, 0, sizeof(packet1));
		959	packet1.usec = packet_in.usec;
		960	packet1.xacc = packet_in.xacc;
		961	packet1.yacc = packet_in.yacc;
		962	packet1.zacc = packet_in.zacc;
		963	packet1.xgyro = packet_in.xgyro;
		964	packet1.ygyro = packet_in.ygyro;
		965	packet1.zgyro = packet_in.zgyro;
		966	packet1.xmag = packet_in.xmag;
		967	packet1.ymag = packet_in.ymag;
		968	packet1.zmag = packet_in.zmag;
		969
		970
		971
		972	memset(&packet2, 0, sizeof(packet2));
		973	mavlink_msg_raw_imu_encode(system_id, component_id, &msg, &packet1);
		974	mavlink_msg_raw_imu_decode(&msg, &packet2);
		975	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		976
		977	memset(&packet2, 0, sizeof(packet2));
		978	mavlink_msg_raw_imu_pack(system_id, component_id, &msg , packet1.usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
		979	mavlink_msg_raw_imu_decode(&msg, &packet2);
		980	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		981
		982	memset(&packet2, 0, sizeof(packet2));
		983	mavlink_msg_raw_imu_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
		984	mavlink_msg_raw_imu_decode(&msg, &packet2);
		985	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		986
		987	memset(&packet2, 0, sizeof(packet2));
		988	mavlink_msg_to_send_buffer(buffer, &msg);
		989	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		990	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		991	}
		992	mavlink_msg_raw_imu_decode(last_msg, &packet2);
		993	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		994
		995	memset(&packet2, 0, sizeof(packet2));
		996	mavlink_msg_raw_imu_send(MAVLINK_COMM_1 , packet1.usec , packet1.xacc , packet1.yacc , packet1.zacc , packet1.xgyro , packet1.ygyro , packet1.zgyro , packet1.xmag , packet1.ymag , packet1.zmag );
		997	mavlink_msg_raw_imu_decode(last_msg, &packet2);
		998	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		999	}
		1000
		1001	static void mavlink_test_raw_pressure(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1002	{
		1003	mavlink_message_t msg;
		1004	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1005	uint16_t i;
		1006	mavlink_raw_pressure_t packet_in = {
		1007	93372036854775807ULL,
		1008	17651,
		1009	17755,
		1010	17859,
		1011	17963,
		1012	};
		1013	mavlink_raw_pressure_t packet1, packet2;
		1014	memset(&packet1, 0, sizeof(packet1));
		1015	packet1.usec = packet_in.usec;
		1016	packet1.press_abs = packet_in.press_abs;
		1017	packet1.press_diff1 = packet_in.press_diff1;
		1018	packet1.press_diff2 = packet_in.press_diff2;
		1019	packet1.temperature = packet_in.temperature;
		1020
		1021
		1022
		1023	memset(&packet2, 0, sizeof(packet2));
		1024	mavlink_msg_raw_pressure_encode(system_id, component_id, &msg, &packet1);
		1025	mavlink_msg_raw_pressure_decode(&msg, &packet2);
		1026	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1027
		1028	memset(&packet2, 0, sizeof(packet2));
		1029	mavlink_msg_raw_pressure_pack(system_id, component_id, &msg , packet1.usec , packet1.press_abs , packet1.press_diff1 , packet1.press_diff2 , packet1.temperature );
		1030	mavlink_msg_raw_pressure_decode(&msg, &packet2);
		1031	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1032
		1033	memset(&packet2, 0, sizeof(packet2));
		1034	mavlink_msg_raw_pressure_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.press_abs , packet1.press_diff1 , packet1.press_diff2 , packet1.temperature );
		1035	mavlink_msg_raw_pressure_decode(&msg, &packet2);
		1036	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1037
		1038	memset(&packet2, 0, sizeof(packet2));
		1039	mavlink_msg_to_send_buffer(buffer, &msg);
		1040	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1041	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1042	}
		1043	mavlink_msg_raw_pressure_decode(last_msg, &packet2);
		1044	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1045
		1046	memset(&packet2, 0, sizeof(packet2));
		1047	mavlink_msg_raw_pressure_send(MAVLINK_COMM_1 , packet1.usec , packet1.press_abs , packet1.press_diff1 , packet1.press_diff2 , packet1.temperature );
		1048	mavlink_msg_raw_pressure_decode(last_msg, &packet2);
		1049	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1050	}
		1051
		1052	static void mavlink_test_scaled_pressure(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1053	{
		1054	mavlink_message_t msg;
		1055	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1056	uint16_t i;
		1057	mavlink_scaled_pressure_t packet_in = {
		1058	93372036854775807ULL,
		1059	73.0,
		1060	101.0,
		1061	18067,
		1062	};
		1063	mavlink_scaled_pressure_t packet1, packet2;
		1064	memset(&packet1, 0, sizeof(packet1));
		1065	packet1.usec = packet_in.usec;
		1066	packet1.press_abs = packet_in.press_abs;
		1067	packet1.press_diff = packet_in.press_diff;
		1068	packet1.temperature = packet_in.temperature;
		1069
		1070
		1071
		1072	memset(&packet2, 0, sizeof(packet2));
		1073	mavlink_msg_scaled_pressure_encode(system_id, component_id, &msg, &packet1);
		1074	mavlink_msg_scaled_pressure_decode(&msg, &packet2);
		1075	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1076
		1077	memset(&packet2, 0, sizeof(packet2));
		1078	mavlink_msg_scaled_pressure_pack(system_id, component_id, &msg , packet1.usec , packet1.press_abs , packet1.press_diff , packet1.temperature );
		1079	mavlink_msg_scaled_pressure_decode(&msg, &packet2);
		1080	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1081
		1082	memset(&packet2, 0, sizeof(packet2));
		1083	mavlink_msg_scaled_pressure_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.press_abs , packet1.press_diff , packet1.temperature );
		1084	mavlink_msg_scaled_pressure_decode(&msg, &packet2);
		1085	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1086
		1087	memset(&packet2, 0, sizeof(packet2));
		1088	mavlink_msg_to_send_buffer(buffer, &msg);
		1089	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1090	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1091	}
		1092	mavlink_msg_scaled_pressure_decode(last_msg, &packet2);
		1093	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1094
		1095	memset(&packet2, 0, sizeof(packet2));
		1096	mavlink_msg_scaled_pressure_send(MAVLINK_COMM_1 , packet1.usec , packet1.press_abs , packet1.press_diff , packet1.temperature );
		1097	mavlink_msg_scaled_pressure_decode(last_msg, &packet2);
		1098	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1099	}
		1100
		1101	static void mavlink_test_attitude(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1102	{
		1103	mavlink_message_t msg;
		1104	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1105	uint16_t i;
		1106	mavlink_attitude_t packet_in = {
		1107	93372036854775807ULL,
		1108	73.0,
		1109	101.0,
		1110	129.0,
		1111	157.0,
		1112	185.0,
		1113	213.0,
		1114	};
		1115	mavlink_attitude_t packet1, packet2;
		1116	memset(&packet1, 0, sizeof(packet1));
		1117	packet1.usec = packet_in.usec;
		1118	packet1.roll = packet_in.roll;
		1119	packet1.pitch = packet_in.pitch;
		1120	packet1.yaw = packet_in.yaw;
		1121	packet1.rollspeed = packet_in.rollspeed;
		1122	packet1.pitchspeed = packet_in.pitchspeed;
		1123	packet1.yawspeed = packet_in.yawspeed;
		1124
		1125
		1126
		1127	memset(&packet2, 0, sizeof(packet2));
		1128	mavlink_msg_attitude_encode(system_id, component_id, &msg, &packet1);
		1129	mavlink_msg_attitude_decode(&msg, &packet2);
		1130	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1131
		1132	memset(&packet2, 0, sizeof(packet2));
		1133	mavlink_msg_attitude_pack(system_id, component_id, &msg , packet1.usec , packet1.roll , packet1.pitch , packet1.yaw , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed );
		1134	mavlink_msg_attitude_decode(&msg, &packet2);
		1135	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1136
		1137	memset(&packet2, 0, sizeof(packet2));
		1138	mavlink_msg_attitude_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.roll , packet1.pitch , packet1.yaw , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed );
		1139	mavlink_msg_attitude_decode(&msg, &packet2);
		1140	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1141
		1142	memset(&packet2, 0, sizeof(packet2));
		1143	mavlink_msg_to_send_buffer(buffer, &msg);
		1144	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1145	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1146	}
		1147	mavlink_msg_attitude_decode(last_msg, &packet2);
		1148	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1149
		1150	memset(&packet2, 0, sizeof(packet2));
		1151	mavlink_msg_attitude_send(MAVLINK_COMM_1 , packet1.usec , packet1.roll , packet1.pitch , packet1.yaw , packet1.rollspeed , packet1.pitchspeed , packet1.yawspeed );
		1152	mavlink_msg_attitude_decode(last_msg, &packet2);
		1153	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1154	}
		1155
		1156	static void mavlink_test_local_position(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1157	{
		1158	mavlink_message_t msg;
		1159	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1160	uint16_t i;
		1161	mavlink_local_position_t packet_in = {
		1162	93372036854775807ULL,
		1163	73.0,
		1164	101.0,
		1165	129.0,
		1166	157.0,
		1167	185.0,
		1168	213.0,
		1169	};
		1170	mavlink_local_position_t packet1, packet2;
		1171	memset(&packet1, 0, sizeof(packet1));
		1172	packet1.usec = packet_in.usec;
		1173	packet1.x = packet_in.x;
		1174	packet1.y = packet_in.y;
		1175	packet1.z = packet_in.z;
		1176	packet1.vx = packet_in.vx;
		1177	packet1.vy = packet_in.vy;
		1178	packet1.vz = packet_in.vz;
		1179
		1180
		1181
		1182	memset(&packet2, 0, sizeof(packet2));
		1183	mavlink_msg_local_position_encode(system_id, component_id, &msg, &packet1);
		1184	mavlink_msg_local_position_decode(&msg, &packet2);
		1185	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1186
		1187	memset(&packet2, 0, sizeof(packet2));
		1188	mavlink_msg_local_position_pack(system_id, component_id, &msg , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz );
		1189	mavlink_msg_local_position_decode(&msg, &packet2);
		1190	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1191
		1192	memset(&packet2, 0, sizeof(packet2));
		1193	mavlink_msg_local_position_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz );
		1194	mavlink_msg_local_position_decode(&msg, &packet2);
		1195	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1196
		1197	memset(&packet2, 0, sizeof(packet2));
		1198	mavlink_msg_to_send_buffer(buffer, &msg);
		1199	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1200	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1201	}
		1202	mavlink_msg_local_position_decode(last_msg, &packet2);
		1203	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1204
		1205	memset(&packet2, 0, sizeof(packet2));
		1206	mavlink_msg_local_position_send(MAVLINK_COMM_1 , packet1.usec , packet1.x , packet1.y , packet1.z , packet1.vx , packet1.vy , packet1.vz );
		1207	mavlink_msg_local_position_decode(last_msg, &packet2);
		1208	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1209	}
		1210
		1211	static void mavlink_test_global_position(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1212	{
		1213	mavlink_message_t msg;
		1214	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1215	uint16_t i;
		1216	mavlink_global_position_t packet_in = {
		1217	93372036854775807ULL,
		1218	73.0,
		1219	101.0,
		1220	129.0,
		1221	157.0,
		1222	185.0,
		1223	213.0,
		1224	};
		1225	mavlink_global_position_t packet1, packet2;
		1226	memset(&packet1, 0, sizeof(packet1));
		1227	packet1.usec = packet_in.usec;
		1228	packet1.lat = packet_in.lat;
		1229	packet1.lon = packet_in.lon;
		1230	packet1.alt = packet_in.alt;
		1231	packet1.vx = packet_in.vx;
		1232	packet1.vy = packet_in.vy;
		1233	packet1.vz = packet_in.vz;
		1234
		1235
		1236
		1237	memset(&packet2, 0, sizeof(packet2));
		1238	mavlink_msg_global_position_encode(system_id, component_id, &msg, &packet1);
		1239	mavlink_msg_global_position_decode(&msg, &packet2);
		1240	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1241
		1242	memset(&packet2, 0, sizeof(packet2));
		1243	mavlink_msg_global_position_pack(system_id, component_id, &msg , packet1.usec , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz );
		1244	mavlink_msg_global_position_decode(&msg, &packet2);
		1245	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1246
		1247	memset(&packet2, 0, sizeof(packet2));
		1248	mavlink_msg_global_position_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz );
		1249	mavlink_msg_global_position_decode(&msg, &packet2);
		1250	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1251
		1252	memset(&packet2, 0, sizeof(packet2));
		1253	mavlink_msg_to_send_buffer(buffer, &msg);
		1254	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1255	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1256	}
		1257	mavlink_msg_global_position_decode(last_msg, &packet2);
		1258	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1259
		1260	memset(&packet2, 0, sizeof(packet2));
		1261	mavlink_msg_global_position_send(MAVLINK_COMM_1 , packet1.usec , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz );
		1262	mavlink_msg_global_position_decode(last_msg, &packet2);
		1263	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1264	}
		1265
		1266	static void mavlink_test_gps_raw(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1267	{
		1268	mavlink_message_t msg;
		1269	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1270	uint16_t i;
		1271	mavlink_gps_raw_t packet_in = {
		1272	93372036854775807ULL,
		1273	29,
		1274	80.0,
		1275	108.0,
		1276	136.0,
		1277	164.0,
		1278	192.0,
		1279	220.0,
		1280	248.0,
		1281	};
		1282	mavlink_gps_raw_t packet1, packet2;
		1283	memset(&packet1, 0, sizeof(packet1));
		1284	packet1.usec = packet_in.usec;
		1285	packet1.fix_type = packet_in.fix_type;
		1286	packet1.lat = packet_in.lat;
		1287	packet1.lon = packet_in.lon;
		1288	packet1.alt = packet_in.alt;
		1289	packet1.eph = packet_in.eph;
		1290	packet1.epv = packet_in.epv;
		1291	packet1.v = packet_in.v;
		1292	packet1.hdg = packet_in.hdg;
		1293
		1294
		1295
		1296	memset(&packet2, 0, sizeof(packet2));
		1297	mavlink_msg_gps_raw_encode(system_id, component_id, &msg, &packet1);
		1298	mavlink_msg_gps_raw_decode(&msg, &packet2);
		1299	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1300
		1301	memset(&packet2, 0, sizeof(packet2));
		1302	mavlink_msg_gps_raw_pack(system_id, component_id, &msg , packet1.usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.v , packet1.hdg );
		1303	mavlink_msg_gps_raw_decode(&msg, &packet2);
		1304	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1305
		1306	memset(&packet2, 0, sizeof(packet2));
		1307	mavlink_msg_gps_raw_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.v , packet1.hdg );
		1308	mavlink_msg_gps_raw_decode(&msg, &packet2);
		1309	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1310
		1311	memset(&packet2, 0, sizeof(packet2));
		1312	mavlink_msg_to_send_buffer(buffer, &msg);
		1313	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1314	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1315	}
		1316	mavlink_msg_gps_raw_decode(last_msg, &packet2);
		1317	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1318
		1319	memset(&packet2, 0, sizeof(packet2));
		1320	mavlink_msg_gps_raw_send(MAVLINK_COMM_1 , packet1.usec , packet1.fix_type , packet1.lat , packet1.lon , packet1.alt , packet1.eph , packet1.epv , packet1.v , packet1.hdg );
		1321	mavlink_msg_gps_raw_decode(last_msg, &packet2);
		1322	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1323	}
		1324
		1325	static void mavlink_test_sys_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1326	{
		1327	mavlink_message_t msg;
		1328	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1329	uint16_t i;
		1330	mavlink_sys_status_t packet_in = {
		1331	5,
		1332	72,
		1333	139,
		1334	17391,
		1335	17495,
		1336	17599,
		1337	17703,
		1338	};
		1339	mavlink_sys_status_t packet1, packet2;
		1340	memset(&packet1, 0, sizeof(packet1));
		1341	packet1.mode = packet_in.mode;
		1342	packet1.nav_mode = packet_in.nav_mode;
		1343	packet1.status = packet_in.status;
		1344	packet1.load = packet_in.load;
		1345	packet1.vbat = packet_in.vbat;
		1346	packet1.battery_remaining = packet_in.battery_remaining;
		1347	packet1.packet_drop = packet_in.packet_drop;
		1348
		1349
		1350
		1351	memset(&packet2, 0, sizeof(packet2));
		1352	mavlink_msg_sys_status_encode(system_id, component_id, &msg, &packet1);
		1353	mavlink_msg_sys_status_decode(&msg, &packet2);
		1354	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1355
		1356	memset(&packet2, 0, sizeof(packet2));
		1357	mavlink_msg_sys_status_pack(system_id, component_id, &msg , packet1.mode , packet1.nav_mode , packet1.status , packet1.load , packet1.vbat , packet1.battery_remaining , packet1.packet_drop );
		1358	mavlink_msg_sys_status_decode(&msg, &packet2);
		1359	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1360
		1361	memset(&packet2, 0, sizeof(packet2));
		1362	mavlink_msg_sys_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.mode , packet1.nav_mode , packet1.status , packet1.load , packet1.vbat , packet1.battery_remaining , packet1.packet_drop );
		1363	mavlink_msg_sys_status_decode(&msg, &packet2);
		1364	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1365
		1366	memset(&packet2, 0, sizeof(packet2));
		1367	mavlink_msg_to_send_buffer(buffer, &msg);
		1368	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1369	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1370	}
		1371	mavlink_msg_sys_status_decode(last_msg, &packet2);
		1372	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1373
		1374	memset(&packet2, 0, sizeof(packet2));
		1375	mavlink_msg_sys_status_send(MAVLINK_COMM_1 , packet1.mode , packet1.nav_mode , packet1.status , packet1.load , packet1.vbat , packet1.battery_remaining , packet1.packet_drop );
		1376	mavlink_msg_sys_status_decode(last_msg, &packet2);
		1377	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1378	}
		1379
		1380	static void mavlink_test_rc_channels_raw(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1381	{
		1382	mavlink_message_t msg;
		1383	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1384	uint16_t i;
		1385	mavlink_rc_channels_raw_t packet_in = {
		1386	17235,
		1387	17339,
		1388	17443,
		1389	17547,
		1390	17651,
		1391	17755,
		1392	17859,
		1393	17963,
		1394	53,
		1395	};
		1396	mavlink_rc_channels_raw_t packet1, packet2;
		1397	memset(&packet1, 0, sizeof(packet1));
		1398	packet1.chan1_raw = packet_in.chan1_raw;
		1399	packet1.chan2_raw = packet_in.chan2_raw;
		1400	packet1.chan3_raw = packet_in.chan3_raw;
		1401	packet1.chan4_raw = packet_in.chan4_raw;
		1402	packet1.chan5_raw = packet_in.chan5_raw;
		1403	packet1.chan6_raw = packet_in.chan6_raw;
		1404	packet1.chan7_raw = packet_in.chan7_raw;
		1405	packet1.chan8_raw = packet_in.chan8_raw;
		1406	packet1.rssi = packet_in.rssi;
		1407
		1408
		1409
		1410	memset(&packet2, 0, sizeof(packet2));
		1411	mavlink_msg_rc_channels_raw_encode(system_id, component_id, &msg, &packet1);
		1412	mavlink_msg_rc_channels_raw_decode(&msg, &packet2);
		1413	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1414
		1415	memset(&packet2, 0, sizeof(packet2));
		1416	mavlink_msg_rc_channels_raw_pack(system_id, component_id, &msg , 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 );
		1417	mavlink_msg_rc_channels_raw_decode(&msg, &packet2);
		1418	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1419
		1420	memset(&packet2, 0, sizeof(packet2));
		1421	mavlink_msg_rc_channels_raw_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , 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 );
		1422	mavlink_msg_rc_channels_raw_decode(&msg, &packet2);
		1423	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1424
		1425	memset(&packet2, 0, sizeof(packet2));
		1426	mavlink_msg_to_send_buffer(buffer, &msg);
		1427	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1428	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1429	}
		1430	mavlink_msg_rc_channels_raw_decode(last_msg, &packet2);
		1431	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1432
		1433	memset(&packet2, 0, sizeof(packet2));
		1434	mavlink_msg_rc_channels_raw_send(MAVLINK_COMM_1 , 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 );
		1435	mavlink_msg_rc_channels_raw_decode(last_msg, &packet2);
		1436	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1437	}
		1438
		1439	static void mavlink_test_rc_channels_scaled(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1440	{
		1441	mavlink_message_t msg;
		1442	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1443	uint16_t i;
		1444	mavlink_rc_channels_scaled_t packet_in = {
		1445	17235,
		1446	17339,
		1447	17443,
		1448	17547,
		1449	17651,
		1450	17755,
		1451	17859,
		1452	17963,
		1453	53,
		1454	};
		1455	mavlink_rc_channels_scaled_t packet1, packet2;
		1456	memset(&packet1, 0, sizeof(packet1));
		1457	packet1.chan1_scaled = packet_in.chan1_scaled;
		1458	packet1.chan2_scaled = packet_in.chan2_scaled;
		1459	packet1.chan3_scaled = packet_in.chan3_scaled;
		1460	packet1.chan4_scaled = packet_in.chan4_scaled;
		1461	packet1.chan5_scaled = packet_in.chan5_scaled;
		1462	packet1.chan6_scaled = packet_in.chan6_scaled;
		1463	packet1.chan7_scaled = packet_in.chan7_scaled;
		1464	packet1.chan8_scaled = packet_in.chan8_scaled;
		1465	packet1.rssi = packet_in.rssi;
		1466
		1467
		1468
		1469	memset(&packet2, 0, sizeof(packet2));
		1470	mavlink_msg_rc_channels_scaled_encode(system_id, component_id, &msg, &packet1);
		1471	mavlink_msg_rc_channels_scaled_decode(&msg, &packet2);
		1472	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1473
		1474	memset(&packet2, 0, sizeof(packet2));
		1475	mavlink_msg_rc_channels_scaled_pack(system_id, component_id, &msg , 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 );
		1476	mavlink_msg_rc_channels_scaled_decode(&msg, &packet2);
		1477	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1478
		1479	memset(&packet2, 0, sizeof(packet2));
		1480	mavlink_msg_rc_channels_scaled_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , 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 );
		1481	mavlink_msg_rc_channels_scaled_decode(&msg, &packet2);
		1482	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1483
		1484	memset(&packet2, 0, sizeof(packet2));
		1485	mavlink_msg_to_send_buffer(buffer, &msg);
		1486	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1487	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1488	}
		1489	mavlink_msg_rc_channels_scaled_decode(last_msg, &packet2);
		1490	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1491
		1492	memset(&packet2, 0, sizeof(packet2));
		1493	mavlink_msg_rc_channels_scaled_send(MAVLINK_COMM_1 , 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 );
		1494	mavlink_msg_rc_channels_scaled_decode(last_msg, &packet2);
		1495	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1496	}
		1497
		1498	static void mavlink_test_servo_output_raw(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1499	{
		1500	mavlink_message_t msg;
		1501	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1502	uint16_t i;
		1503	mavlink_servo_output_raw_t packet_in = {
		1504	17235,
		1505	17339,
		1506	17443,
		1507	17547,
		1508	17651,
		1509	17755,
		1510	17859,
		1511	17963,
		1512	};
		1513	mavlink_servo_output_raw_t packet1, packet2;
		1514	memset(&packet1, 0, sizeof(packet1));
		1515	packet1.servo1_raw = packet_in.servo1_raw;
		1516	packet1.servo2_raw = packet_in.servo2_raw;
		1517	packet1.servo3_raw = packet_in.servo3_raw;
		1518	packet1.servo4_raw = packet_in.servo4_raw;
		1519	packet1.servo5_raw = packet_in.servo5_raw;
		1520	packet1.servo6_raw = packet_in.servo6_raw;
		1521	packet1.servo7_raw = packet_in.servo7_raw;
		1522	packet1.servo8_raw = packet_in.servo8_raw;
		1523
		1524
		1525
		1526	memset(&packet2, 0, sizeof(packet2));
		1527	mavlink_msg_servo_output_raw_encode(system_id, component_id, &msg, &packet1);
		1528	mavlink_msg_servo_output_raw_decode(&msg, &packet2);
		1529	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1530
		1531	memset(&packet2, 0, sizeof(packet2));
		1532	mavlink_msg_servo_output_raw_pack(system_id, component_id, &msg , packet1.servo1_raw , packet1.servo2_raw , packet1.servo3_raw , packet1.servo4_raw , packet1.servo5_raw , packet1.servo6_raw , packet1.servo7_raw , packet1.servo8_raw );
		1533	mavlink_msg_servo_output_raw_decode(&msg, &packet2);
		1534	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1535
		1536	memset(&packet2, 0, sizeof(packet2));
		1537	mavlink_msg_servo_output_raw_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.servo1_raw , packet1.servo2_raw , packet1.servo3_raw , packet1.servo4_raw , packet1.servo5_raw , packet1.servo6_raw , packet1.servo7_raw , packet1.servo8_raw );
		1538	mavlink_msg_servo_output_raw_decode(&msg, &packet2);
		1539	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1540
		1541	memset(&packet2, 0, sizeof(packet2));
		1542	mavlink_msg_to_send_buffer(buffer, &msg);
		1543	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1544	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1545	}
		1546	mavlink_msg_servo_output_raw_decode(last_msg, &packet2);
		1547	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1548
		1549	memset(&packet2, 0, sizeof(packet2));
		1550	mavlink_msg_servo_output_raw_send(MAVLINK_COMM_1 , packet1.servo1_raw , packet1.servo2_raw , packet1.servo3_raw , packet1.servo4_raw , packet1.servo5_raw , packet1.servo6_raw , packet1.servo7_raw , packet1.servo8_raw );
		1551	mavlink_msg_servo_output_raw_decode(last_msg, &packet2);
		1552	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1553	}
		1554
		1555	static void mavlink_test_waypoint(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1556	{
		1557	mavlink_message_t msg;
		1558	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1559	uint16_t i;
		1560	mavlink_waypoint_t packet_in = {
		1561	5,
		1562	72,
		1563	17339,
		1564	17,
		1565	84,
		1566	151,
		1567	218,
		1568	73.0,
		1569	101.0,
		1570	129.0,
		1571	157.0,
		1572	185.0,
		1573	213.0,
		1574	241.0,
		1575	};
		1576	mavlink_waypoint_t packet1, packet2;
		1577	memset(&packet1, 0, sizeof(packet1));
		1578	packet1.target_system = packet_in.target_system;
		1579	packet1.target_component = packet_in.target_component;
		1580	packet1.seq = packet_in.seq;
		1581	packet1.frame = packet_in.frame;
		1582	packet1.command = packet_in.command;
		1583	packet1.current = packet_in.current;
		1584	packet1.autocontinue = packet_in.autocontinue;
		1585	packet1.param1 = packet_in.param1;
		1586	packet1.param2 = packet_in.param2;
		1587	packet1.param3 = packet_in.param3;
		1588	packet1.param4 = packet_in.param4;
		1589	packet1.x = packet_in.x;
		1590	packet1.y = packet_in.y;
		1591	packet1.z = packet_in.z;
		1592
		1593
		1594
		1595	memset(&packet2, 0, sizeof(packet2));
		1596	mavlink_msg_waypoint_encode(system_id, component_id, &msg, &packet1);
		1597	mavlink_msg_waypoint_decode(&msg, &packet2);
		1598	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1599
		1600	memset(&packet2, 0, sizeof(packet2));
		1601	mavlink_msg_waypoint_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 );
		1602	mavlink_msg_waypoint_decode(&msg, &packet2);
		1603	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1604
		1605	memset(&packet2, 0, sizeof(packet2));
		1606	mavlink_msg_waypoint_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 );
		1607	mavlink_msg_waypoint_decode(&msg, &packet2);
		1608	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1609
		1610	memset(&packet2, 0, sizeof(packet2));
		1611	mavlink_msg_to_send_buffer(buffer, &msg);
		1612	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1613	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1614	}
		1615	mavlink_msg_waypoint_decode(last_msg, &packet2);
		1616	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1617
		1618	memset(&packet2, 0, sizeof(packet2));
		1619	mavlink_msg_waypoint_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 );
		1620	mavlink_msg_waypoint_decode(last_msg, &packet2);
		1621	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1622	}
		1623
		1624	static void mavlink_test_waypoint_request(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1625	{
		1626	mavlink_message_t msg;
		1627	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1628	uint16_t i;
		1629	mavlink_waypoint_request_t packet_in = {
		1630	5,
		1631	72,
		1632	17339,
		1633	};
		1634	mavlink_waypoint_request_t packet1, packet2;
		1635	memset(&packet1, 0, sizeof(packet1));
		1636	packet1.target_system = packet_in.target_system;
		1637	packet1.target_component = packet_in.target_component;
		1638	packet1.seq = packet_in.seq;
		1639
		1640
		1641
		1642	memset(&packet2, 0, sizeof(packet2));
		1643	mavlink_msg_waypoint_request_encode(system_id, component_id, &msg, &packet1);
		1644	mavlink_msg_waypoint_request_decode(&msg, &packet2);
		1645	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1646
		1647	memset(&packet2, 0, sizeof(packet2));
		1648	mavlink_msg_waypoint_request_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.seq );
		1649	mavlink_msg_waypoint_request_decode(&msg, &packet2);
		1650	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1651
		1652	memset(&packet2, 0, sizeof(packet2));
		1653	mavlink_msg_waypoint_request_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.seq );
		1654	mavlink_msg_waypoint_request_decode(&msg, &packet2);
		1655	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1656
		1657	memset(&packet2, 0, sizeof(packet2));
		1658	mavlink_msg_to_send_buffer(buffer, &msg);
		1659	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1660	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1661	}
		1662	mavlink_msg_waypoint_request_decode(last_msg, &packet2);
		1663	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1664
		1665	memset(&packet2, 0, sizeof(packet2));
		1666	mavlink_msg_waypoint_request_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.seq );
		1667	mavlink_msg_waypoint_request_decode(last_msg, &packet2);
		1668	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1669	}
		1670
		1671	static void mavlink_test_waypoint_set_current(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1672	{
		1673	mavlink_message_t msg;
		1674	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1675	uint16_t i;
		1676	mavlink_waypoint_set_current_t packet_in = {
		1677	5,
		1678	72,
		1679	17339,
		1680	};
		1681	mavlink_waypoint_set_current_t packet1, packet2;
		1682	memset(&packet1, 0, sizeof(packet1));
		1683	packet1.target_system = packet_in.target_system;
		1684	packet1.target_component = packet_in.target_component;
		1685	packet1.seq = packet_in.seq;
		1686
		1687
		1688
		1689	memset(&packet2, 0, sizeof(packet2));
		1690	mavlink_msg_waypoint_set_current_encode(system_id, component_id, &msg, &packet1);
		1691	mavlink_msg_waypoint_set_current_decode(&msg, &packet2);
		1692	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1693
		1694	memset(&packet2, 0, sizeof(packet2));
		1695	mavlink_msg_waypoint_set_current_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.seq );
		1696	mavlink_msg_waypoint_set_current_decode(&msg, &packet2);
		1697	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1698
		1699	memset(&packet2, 0, sizeof(packet2));
		1700	mavlink_msg_waypoint_set_current_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.seq );
		1701	mavlink_msg_waypoint_set_current_decode(&msg, &packet2);
		1702	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1703
		1704	memset(&packet2, 0, sizeof(packet2));
		1705	mavlink_msg_to_send_buffer(buffer, &msg);
		1706	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1707	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1708	}
		1709	mavlink_msg_waypoint_set_current_decode(last_msg, &packet2);
		1710	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1711
		1712	memset(&packet2, 0, sizeof(packet2));
		1713	mavlink_msg_waypoint_set_current_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.seq );
		1714	mavlink_msg_waypoint_set_current_decode(last_msg, &packet2);
		1715	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1716	}
		1717
		1718	static void mavlink_test_waypoint_current(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1719	{
		1720	mavlink_message_t msg;
		1721	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1722	uint16_t i;
		1723	mavlink_waypoint_current_t packet_in = {
		1724	17235,
		1725	};
		1726	mavlink_waypoint_current_t packet1, packet2;
		1727	memset(&packet1, 0, sizeof(packet1));
		1728	packet1.seq = packet_in.seq;
		1729
		1730
		1731
		1732	memset(&packet2, 0, sizeof(packet2));
		1733	mavlink_msg_waypoint_current_encode(system_id, component_id, &msg, &packet1);
		1734	mavlink_msg_waypoint_current_decode(&msg, &packet2);
		1735	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1736
		1737	memset(&packet2, 0, sizeof(packet2));
		1738	mavlink_msg_waypoint_current_pack(system_id, component_id, &msg , packet1.seq );
		1739	mavlink_msg_waypoint_current_decode(&msg, &packet2);
		1740	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1741
		1742	memset(&packet2, 0, sizeof(packet2));
		1743	mavlink_msg_waypoint_current_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.seq );
		1744	mavlink_msg_waypoint_current_decode(&msg, &packet2);
		1745	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1746
		1747	memset(&packet2, 0, sizeof(packet2));
		1748	mavlink_msg_to_send_buffer(buffer, &msg);
		1749	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1750	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1751	}
		1752	mavlink_msg_waypoint_current_decode(last_msg, &packet2);
		1753	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1754
		1755	memset(&packet2, 0, sizeof(packet2));
		1756	mavlink_msg_waypoint_current_send(MAVLINK_COMM_1 , packet1.seq );
		1757	mavlink_msg_waypoint_current_decode(last_msg, &packet2);
		1758	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1759	}
		1760
		1761	static void mavlink_test_waypoint_request_list(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1762	{
		1763	mavlink_message_t msg;
		1764	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1765	uint16_t i;
		1766	mavlink_waypoint_request_list_t packet_in = {
		1767	5,
		1768	72,
		1769	};
		1770	mavlink_waypoint_request_list_t packet1, packet2;
		1771	memset(&packet1, 0, sizeof(packet1));
		1772	packet1.target_system = packet_in.target_system;
		1773	packet1.target_component = packet_in.target_component;
		1774
		1775
		1776
		1777	memset(&packet2, 0, sizeof(packet2));
		1778	mavlink_msg_waypoint_request_list_encode(system_id, component_id, &msg, &packet1);
		1779	mavlink_msg_waypoint_request_list_decode(&msg, &packet2);
		1780	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1781
		1782	memset(&packet2, 0, sizeof(packet2));
		1783	mavlink_msg_waypoint_request_list_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component );
		1784	mavlink_msg_waypoint_request_list_decode(&msg, &packet2);
		1785	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1786
		1787	memset(&packet2, 0, sizeof(packet2));
		1788	mavlink_msg_waypoint_request_list_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component );
		1789	mavlink_msg_waypoint_request_list_decode(&msg, &packet2);
		1790	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1791
		1792	memset(&packet2, 0, sizeof(packet2));
		1793	mavlink_msg_to_send_buffer(buffer, &msg);
		1794	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1795	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1796	}
		1797	mavlink_msg_waypoint_request_list_decode(last_msg, &packet2);
		1798	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1799
		1800	memset(&packet2, 0, sizeof(packet2));
		1801	mavlink_msg_waypoint_request_list_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component );
		1802	mavlink_msg_waypoint_request_list_decode(last_msg, &packet2);
		1803	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1804	}
		1805
		1806	static void mavlink_test_waypoint_count(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1807	{
		1808	mavlink_message_t msg;
		1809	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1810	uint16_t i;
		1811	mavlink_waypoint_count_t packet_in = {
		1812	5,
		1813	72,
		1814	17339,
		1815	};
		1816	mavlink_waypoint_count_t packet1, packet2;
		1817	memset(&packet1, 0, sizeof(packet1));
		1818	packet1.target_system = packet_in.target_system;
		1819	packet1.target_component = packet_in.target_component;
		1820	packet1.count = packet_in.count;
		1821
		1822
		1823
		1824	memset(&packet2, 0, sizeof(packet2));
		1825	mavlink_msg_waypoint_count_encode(system_id, component_id, &msg, &packet1);
		1826	mavlink_msg_waypoint_count_decode(&msg, &packet2);
		1827	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1828
		1829	memset(&packet2, 0, sizeof(packet2));
		1830	mavlink_msg_waypoint_count_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.count );
		1831	mavlink_msg_waypoint_count_decode(&msg, &packet2);
		1832	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1833
		1834	memset(&packet2, 0, sizeof(packet2));
		1835	mavlink_msg_waypoint_count_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.count );
		1836	mavlink_msg_waypoint_count_decode(&msg, &packet2);
		1837	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1838
		1839	memset(&packet2, 0, sizeof(packet2));
		1840	mavlink_msg_to_send_buffer(buffer, &msg);
		1841	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1842	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1843	}
		1844	mavlink_msg_waypoint_count_decode(last_msg, &packet2);
		1845	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1846
		1847	memset(&packet2, 0, sizeof(packet2));
		1848	mavlink_msg_waypoint_count_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.count );
		1849	mavlink_msg_waypoint_count_decode(last_msg, &packet2);
		1850	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1851	}
		1852
		1853	static void mavlink_test_waypoint_clear_all(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1854	{
		1855	mavlink_message_t msg;
		1856	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1857	uint16_t i;
		1858	mavlink_waypoint_clear_all_t packet_in = {
		1859	5,
		1860	72,
		1861	};
		1862	mavlink_waypoint_clear_all_t packet1, packet2;
		1863	memset(&packet1, 0, sizeof(packet1));
		1864	packet1.target_system = packet_in.target_system;
		1865	packet1.target_component = packet_in.target_component;
		1866
		1867
		1868
		1869	memset(&packet2, 0, sizeof(packet2));
		1870	mavlink_msg_waypoint_clear_all_encode(system_id, component_id, &msg, &packet1);
		1871	mavlink_msg_waypoint_clear_all_decode(&msg, &packet2);
		1872	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1873
		1874	memset(&packet2, 0, sizeof(packet2));
		1875	mavlink_msg_waypoint_clear_all_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component );
		1876	mavlink_msg_waypoint_clear_all_decode(&msg, &packet2);
		1877	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1878
		1879	memset(&packet2, 0, sizeof(packet2));
		1880	mavlink_msg_waypoint_clear_all_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component );
		1881	mavlink_msg_waypoint_clear_all_decode(&msg, &packet2);
		1882	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1883
		1884	memset(&packet2, 0, sizeof(packet2));
		1885	mavlink_msg_to_send_buffer(buffer, &msg);
		1886	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1887	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1888	}
		1889	mavlink_msg_waypoint_clear_all_decode(last_msg, &packet2);
		1890	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1891
		1892	memset(&packet2, 0, sizeof(packet2));
		1893	mavlink_msg_waypoint_clear_all_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component );
		1894	mavlink_msg_waypoint_clear_all_decode(last_msg, &packet2);
		1895	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1896	}
		1897
		1898	static void mavlink_test_waypoint_reached(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1899	{
		1900	mavlink_message_t msg;
		1901	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1902	uint16_t i;
		1903	mavlink_waypoint_reached_t packet_in = {
		1904	17235,
		1905	};
		1906	mavlink_waypoint_reached_t packet1, packet2;
		1907	memset(&packet1, 0, sizeof(packet1));
		1908	packet1.seq = packet_in.seq;
		1909
		1910
		1911
		1912	memset(&packet2, 0, sizeof(packet2));
		1913	mavlink_msg_waypoint_reached_encode(system_id, component_id, &msg, &packet1);
		1914	mavlink_msg_waypoint_reached_decode(&msg, &packet2);
		1915	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1916
		1917	memset(&packet2, 0, sizeof(packet2));
		1918	mavlink_msg_waypoint_reached_pack(system_id, component_id, &msg , packet1.seq );
		1919	mavlink_msg_waypoint_reached_decode(&msg, &packet2);
		1920	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1921
		1922	memset(&packet2, 0, sizeof(packet2));
		1923	mavlink_msg_waypoint_reached_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.seq );
		1924	mavlink_msg_waypoint_reached_decode(&msg, &packet2);
		1925	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1926
		1927	memset(&packet2, 0, sizeof(packet2));
		1928	mavlink_msg_to_send_buffer(buffer, &msg);
		1929	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1930	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1931	}
		1932	mavlink_msg_waypoint_reached_decode(last_msg, &packet2);
		1933	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1934
		1935	memset(&packet2, 0, sizeof(packet2));
		1936	mavlink_msg_waypoint_reached_send(MAVLINK_COMM_1 , packet1.seq );
		1937	mavlink_msg_waypoint_reached_decode(last_msg, &packet2);
		1938	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1939	}
		1940
		1941	static void mavlink_test_waypoint_ack(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1942	{
		1943	mavlink_message_t msg;
		1944	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1945	uint16_t i;
		1946	mavlink_waypoint_ack_t packet_in = {
		1947	5,
		1948	72,
		1949	139,
		1950	};
		1951	mavlink_waypoint_ack_t packet1, packet2;
		1952	memset(&packet1, 0, sizeof(packet1));
		1953	packet1.target_system = packet_in.target_system;
		1954	packet1.target_component = packet_in.target_component;
		1955	packet1.type = packet_in.type;
		1956
		1957
		1958
		1959	memset(&packet2, 0, sizeof(packet2));
		1960	mavlink_msg_waypoint_ack_encode(system_id, component_id, &msg, &packet1);
		1961	mavlink_msg_waypoint_ack_decode(&msg, &packet2);
		1962	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1963
		1964	memset(&packet2, 0, sizeof(packet2));
		1965	mavlink_msg_waypoint_ack_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.type );
		1966	mavlink_msg_waypoint_ack_decode(&msg, &packet2);
		1967	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1968
		1969	memset(&packet2, 0, sizeof(packet2));
		1970	mavlink_msg_waypoint_ack_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.type );
		1971	mavlink_msg_waypoint_ack_decode(&msg, &packet2);
		1972	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1973
		1974	memset(&packet2, 0, sizeof(packet2));
		1975	mavlink_msg_to_send_buffer(buffer, &msg);
		1976	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		1977	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		1978	}
		1979	mavlink_msg_waypoint_ack_decode(last_msg, &packet2);
		1980	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1981
		1982	memset(&packet2, 0, sizeof(packet2));
		1983	mavlink_msg_waypoint_ack_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.type );
		1984	mavlink_msg_waypoint_ack_decode(last_msg, &packet2);
		1985	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		1986	}
		1987
		1988	static void mavlink_test_gps_set_global_origin(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		1989	{
		1990	mavlink_message_t msg;
		1991	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		1992	uint16_t i;
		1993	mavlink_gps_set_global_origin_t packet_in = {
		1994	5,
		1995	72,
		1996	963497568,
		1997	963497776,
		1998	963497984,
		1999	};
		2000	mavlink_gps_set_global_origin_t packet1, packet2;
		2001	memset(&packet1, 0, sizeof(packet1));
		2002	packet1.target_system = packet_in.target_system;
		2003	packet1.target_component = packet_in.target_component;
		2004	packet1.latitude = packet_in.latitude;
		2005	packet1.longitude = packet_in.longitude;
		2006	packet1.altitude = packet_in.altitude;
		2007
		2008
		2009
		2010	memset(&packet2, 0, sizeof(packet2));
		2011	mavlink_msg_gps_set_global_origin_encode(system_id, component_id, &msg, &packet1);
		2012	mavlink_msg_gps_set_global_origin_decode(&msg, &packet2);
		2013	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2014
		2015	memset(&packet2, 0, sizeof(packet2));
		2016	mavlink_msg_gps_set_global_origin_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.latitude , packet1.longitude , packet1.altitude );
		2017	mavlink_msg_gps_set_global_origin_decode(&msg, &packet2);
		2018	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2019
		2020	memset(&packet2, 0, sizeof(packet2));
		2021	mavlink_msg_gps_set_global_origin_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.latitude , packet1.longitude , packet1.altitude );
		2022	mavlink_msg_gps_set_global_origin_decode(&msg, &packet2);
		2023	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2024
		2025	memset(&packet2, 0, sizeof(packet2));
		2026	mavlink_msg_to_send_buffer(buffer, &msg);
		2027	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2028	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2029	}
		2030	mavlink_msg_gps_set_global_origin_decode(last_msg, &packet2);
		2031	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2032
		2033	memset(&packet2, 0, sizeof(packet2));
		2034	mavlink_msg_gps_set_global_origin_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.latitude , packet1.longitude , packet1.altitude );
		2035	mavlink_msg_gps_set_global_origin_decode(last_msg, &packet2);
		2036	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2037	}
		2038
		2039	static void mavlink_test_gps_local_origin_set(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2040	{
		2041	mavlink_message_t msg;
		2042	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2043	uint16_t i;
		2044	mavlink_gps_local_origin_set_t packet_in = {
		2045	963497464,
		2046	963497672,
		2047	963497880,
		2048	};
		2049	mavlink_gps_local_origin_set_t packet1, packet2;
		2050	memset(&packet1, 0, sizeof(packet1));
		2051	packet1.latitude = packet_in.latitude;
		2052	packet1.longitude = packet_in.longitude;
		2053	packet1.altitude = packet_in.altitude;
		2054
		2055
		2056
		2057	memset(&packet2, 0, sizeof(packet2));
		2058	mavlink_msg_gps_local_origin_set_encode(system_id, component_id, &msg, &packet1);
		2059	mavlink_msg_gps_local_origin_set_decode(&msg, &packet2);
		2060	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2061
		2062	memset(&packet2, 0, sizeof(packet2));
		2063	mavlink_msg_gps_local_origin_set_pack(system_id, component_id, &msg , packet1.latitude , packet1.longitude , packet1.altitude );
		2064	mavlink_msg_gps_local_origin_set_decode(&msg, &packet2);
		2065	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2066
		2067	memset(&packet2, 0, sizeof(packet2));
		2068	mavlink_msg_gps_local_origin_set_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.latitude , packet1.longitude , packet1.altitude );
		2069	mavlink_msg_gps_local_origin_set_decode(&msg, &packet2);
		2070	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2071
		2072	memset(&packet2, 0, sizeof(packet2));
		2073	mavlink_msg_to_send_buffer(buffer, &msg);
		2074	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2075	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2076	}
		2077	mavlink_msg_gps_local_origin_set_decode(last_msg, &packet2);
		2078	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2079
		2080	memset(&packet2, 0, sizeof(packet2));
		2081	mavlink_msg_gps_local_origin_set_send(MAVLINK_COMM_1 , packet1.latitude , packet1.longitude , packet1.altitude );
		2082	mavlink_msg_gps_local_origin_set_decode(last_msg, &packet2);
		2083	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2084	}
		2085
		2086	static void mavlink_test_local_position_setpoint_set(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2087	{
		2088	mavlink_message_t msg;
		2089	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2090	uint16_t i;
		2091	mavlink_local_position_setpoint_set_t packet_in = {
		2092	5,
		2093	72,
		2094	31.0,
		2095	59.0,
		2096	87.0,
		2097	115.0,
		2098	};
		2099	mavlink_local_position_setpoint_set_t packet1, packet2;
		2100	memset(&packet1, 0, sizeof(packet1));
		2101	packet1.target_system = packet_in.target_system;
		2102	packet1.target_component = packet_in.target_component;
		2103	packet1.x = packet_in.x;
		2104	packet1.y = packet_in.y;
		2105	packet1.z = packet_in.z;
		2106	packet1.yaw = packet_in.yaw;
		2107
		2108
		2109
		2110	memset(&packet2, 0, sizeof(packet2));
		2111	mavlink_msg_local_position_setpoint_set_encode(system_id, component_id, &msg, &packet1);
		2112	mavlink_msg_local_position_setpoint_set_decode(&msg, &packet2);
		2113	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2114
		2115	memset(&packet2, 0, sizeof(packet2));
		2116	mavlink_msg_local_position_setpoint_set_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.x , packet1.y , packet1.z , packet1.yaw );
		2117	mavlink_msg_local_position_setpoint_set_decode(&msg, &packet2);
		2118	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2119
		2120	memset(&packet2, 0, sizeof(packet2));
		2121	mavlink_msg_local_position_setpoint_set_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.x , packet1.y , packet1.z , packet1.yaw );
		2122	mavlink_msg_local_position_setpoint_set_decode(&msg, &packet2);
		2123	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2124
		2125	memset(&packet2, 0, sizeof(packet2));
		2126	mavlink_msg_to_send_buffer(buffer, &msg);
		2127	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2128	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2129	}
		2130	mavlink_msg_local_position_setpoint_set_decode(last_msg, &packet2);
		2131	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2132
		2133	memset(&packet2, 0, sizeof(packet2));
		2134	mavlink_msg_local_position_setpoint_set_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.x , packet1.y , packet1.z , packet1.yaw );
		2135	mavlink_msg_local_position_setpoint_set_decode(last_msg, &packet2);
		2136	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2137	}
		2138
		2139	static void mavlink_test_local_position_setpoint(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2140	{
		2141	mavlink_message_t msg;
		2142	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2143	uint16_t i;
		2144	mavlink_local_position_setpoint_t packet_in = {
		2145	17.0,
		2146	45.0,
		2147	73.0,
		2148	101.0,
		2149	};
		2150	mavlink_local_position_setpoint_t packet1, packet2;
		2151	memset(&packet1, 0, sizeof(packet1));
		2152	packet1.x = packet_in.x;
		2153	packet1.y = packet_in.y;
		2154	packet1.z = packet_in.z;
		2155	packet1.yaw = packet_in.yaw;
		2156
		2157
		2158
		2159	memset(&packet2, 0, sizeof(packet2));
		2160	mavlink_msg_local_position_setpoint_encode(system_id, component_id, &msg, &packet1);
		2161	mavlink_msg_local_position_setpoint_decode(&msg, &packet2);
		2162	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2163
		2164	memset(&packet2, 0, sizeof(packet2));
		2165	mavlink_msg_local_position_setpoint_pack(system_id, component_id, &msg , packet1.x , packet1.y , packet1.z , packet1.yaw );
		2166	mavlink_msg_local_position_setpoint_decode(&msg, &packet2);
		2167	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2168
		2169	memset(&packet2, 0, sizeof(packet2));
		2170	mavlink_msg_local_position_setpoint_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.x , packet1.y , packet1.z , packet1.yaw );
		2171	mavlink_msg_local_position_setpoint_decode(&msg, &packet2);
		2172	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2173
		2174	memset(&packet2, 0, sizeof(packet2));
		2175	mavlink_msg_to_send_buffer(buffer, &msg);
		2176	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2177	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2178	}
		2179	mavlink_msg_local_position_setpoint_decode(last_msg, &packet2);
		2180	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2181
		2182	memset(&packet2, 0, sizeof(packet2));
		2183	mavlink_msg_local_position_setpoint_send(MAVLINK_COMM_1 , packet1.x , packet1.y , packet1.z , packet1.yaw );
		2184	mavlink_msg_local_position_setpoint_decode(last_msg, &packet2);
		2185	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2186	}
		2187
		2188	static void mavlink_test_control_status(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2189	{
		2190	mavlink_message_t msg;
		2191	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2192	uint16_t i;
		2193	mavlink_control_status_t packet_in = {
		2194	5,
		2195	72,
		2196	139,
		2197	206,
		2198	17,
		2199	84,
		2200	151,
		2201	218,
		2202	};
		2203	mavlink_control_status_t packet1, packet2;
		2204	memset(&packet1, 0, sizeof(packet1));
		2205	packet1.position_fix = packet_in.position_fix;
		2206	packet1.vision_fix = packet_in.vision_fix;
		2207	packet1.gps_fix = packet_in.gps_fix;
		2208	packet1.ahrs_health = packet_in.ahrs_health;
		2209	packet1.control_att = packet_in.control_att;
		2210	packet1.control_pos_xy = packet_in.control_pos_xy;
		2211	packet1.control_pos_z = packet_in.control_pos_z;
		2212	packet1.control_pos_yaw = packet_in.control_pos_yaw;
		2213
		2214
		2215
		2216	memset(&packet2, 0, sizeof(packet2));
		2217	mavlink_msg_control_status_encode(system_id, component_id, &msg, &packet1);
		2218	mavlink_msg_control_status_decode(&msg, &packet2);
		2219	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2220
		2221	memset(&packet2, 0, sizeof(packet2));
		2222	mavlink_msg_control_status_pack(system_id, component_id, &msg , packet1.position_fix , packet1.vision_fix , packet1.gps_fix , packet1.ahrs_health , packet1.control_att , packet1.control_pos_xy , packet1.control_pos_z , packet1.control_pos_yaw );
		2223	mavlink_msg_control_status_decode(&msg, &packet2);
		2224	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2225
		2226	memset(&packet2, 0, sizeof(packet2));
		2227	mavlink_msg_control_status_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.position_fix , packet1.vision_fix , packet1.gps_fix , packet1.ahrs_health , packet1.control_att , packet1.control_pos_xy , packet1.control_pos_z , packet1.control_pos_yaw );
		2228	mavlink_msg_control_status_decode(&msg, &packet2);
		2229	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2230
		2231	memset(&packet2, 0, sizeof(packet2));
		2232	mavlink_msg_to_send_buffer(buffer, &msg);
		2233	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2234	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2235	}
		2236	mavlink_msg_control_status_decode(last_msg, &packet2);
		2237	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2238
		2239	memset(&packet2, 0, sizeof(packet2));
		2240	mavlink_msg_control_status_send(MAVLINK_COMM_1 , packet1.position_fix , packet1.vision_fix , packet1.gps_fix , packet1.ahrs_health , packet1.control_att , packet1.control_pos_xy , packet1.control_pos_z , packet1.control_pos_yaw );
		2241	mavlink_msg_control_status_decode(last_msg, &packet2);
		2242	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2243	}
		2244
		2245	static void mavlink_test_safety_set_allowed_area(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2246	{
		2247	mavlink_message_t msg;
		2248	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2249	uint16_t i;
		2250	mavlink_safety_set_allowed_area_t packet_in = {
		2251	5,
		2252	72,
		2253	139,
		2254	38.0,
		2255	66.0,
		2256	94.0,
		2257	122.0,
		2258	150.0,
		2259	178.0,
		2260	};
		2261	mavlink_safety_set_allowed_area_t packet1, packet2;
		2262	memset(&packet1, 0, sizeof(packet1));
		2263	packet1.target_system = packet_in.target_system;
		2264	packet1.target_component = packet_in.target_component;
		2265	packet1.frame = packet_in.frame;
		2266	packet1.p1x = packet_in.p1x;
		2267	packet1.p1y = packet_in.p1y;
		2268	packet1.p1z = packet_in.p1z;
		2269	packet1.p2x = packet_in.p2x;
		2270	packet1.p2y = packet_in.p2y;
		2271	packet1.p2z = packet_in.p2z;
		2272
		2273
		2274
		2275	memset(&packet2, 0, sizeof(packet2));
		2276	mavlink_msg_safety_set_allowed_area_encode(system_id, component_id, &msg, &packet1);
		2277	mavlink_msg_safety_set_allowed_area_decode(&msg, &packet2);
		2278	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2279
		2280	memset(&packet2, 0, sizeof(packet2));
		2281	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 );
		2282	mavlink_msg_safety_set_allowed_area_decode(&msg, &packet2);
		2283	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2284
		2285	memset(&packet2, 0, sizeof(packet2));
		2286	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 );
		2287	mavlink_msg_safety_set_allowed_area_decode(&msg, &packet2);
		2288	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2289
		2290	memset(&packet2, 0, sizeof(packet2));
		2291	mavlink_msg_to_send_buffer(buffer, &msg);
		2292	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2293	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2294	}
		2295	mavlink_msg_safety_set_allowed_area_decode(last_msg, &packet2);
		2296	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2297
		2298	memset(&packet2, 0, sizeof(packet2));
		2299	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 );
		2300	mavlink_msg_safety_set_allowed_area_decode(last_msg, &packet2);
		2301	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2302	}
		2303
		2304	static void mavlink_test_safety_allowed_area(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2305	{
		2306	mavlink_message_t msg;
		2307	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2308	uint16_t i;
		2309	mavlink_safety_allowed_area_t packet_in = {
		2310	5,
		2311	24.0,
		2312	52.0,
		2313	80.0,
		2314	108.0,
		2315	136.0,
		2316	164.0,
		2317	};
		2318	mavlink_safety_allowed_area_t packet1, packet2;
		2319	memset(&packet1, 0, sizeof(packet1));
		2320	packet1.frame = packet_in.frame;
		2321	packet1.p1x = packet_in.p1x;
		2322	packet1.p1y = packet_in.p1y;
		2323	packet1.p1z = packet_in.p1z;
		2324	packet1.p2x = packet_in.p2x;
		2325	packet1.p2y = packet_in.p2y;
		2326	packet1.p2z = packet_in.p2z;
		2327
		2328
		2329
		2330	memset(&packet2, 0, sizeof(packet2));
		2331	mavlink_msg_safety_allowed_area_encode(system_id, component_id, &msg, &packet1);
		2332	mavlink_msg_safety_allowed_area_decode(&msg, &packet2);
		2333	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2334
		2335	memset(&packet2, 0, sizeof(packet2));
		2336	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 );
		2337	mavlink_msg_safety_allowed_area_decode(&msg, &packet2);
		2338	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2339
		2340	memset(&packet2, 0, sizeof(packet2));
		2341	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 );
		2342	mavlink_msg_safety_allowed_area_decode(&msg, &packet2);
		2343	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2344
		2345	memset(&packet2, 0, sizeof(packet2));
		2346	mavlink_msg_to_send_buffer(buffer, &msg);
		2347	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2348	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2349	}
		2350	mavlink_msg_safety_allowed_area_decode(last_msg, &packet2);
		2351	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2352
		2353	memset(&packet2, 0, sizeof(packet2));
		2354	mavlink_msg_safety_allowed_area_send(MAVLINK_COMM_1 , packet1.frame , packet1.p1x , packet1.p1y , packet1.p1z , packet1.p2x , packet1.p2y , packet1.p2z );
		2355	mavlink_msg_safety_allowed_area_decode(last_msg, &packet2);
		2356	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2357	}
		2358
		2359	static void mavlink_test_set_roll_pitch_yaw_thrust(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2360	{
		2361	mavlink_message_t msg;
		2362	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2363	uint16_t i;
		2364	mavlink_set_roll_pitch_yaw_thrust_t packet_in = {
		2365	5,
		2366	72,
		2367	31.0,
		2368	59.0,
		2369	87.0,
		2370	115.0,
		2371	};
		2372	mavlink_set_roll_pitch_yaw_thrust_t packet1, packet2;
		2373	memset(&packet1, 0, sizeof(packet1));
		2374	packet1.target_system = packet_in.target_system;
		2375	packet1.target_component = packet_in.target_component;
		2376	packet1.roll = packet_in.roll;
		2377	packet1.pitch = packet_in.pitch;
		2378	packet1.yaw = packet_in.yaw;
		2379	packet1.thrust = packet_in.thrust;
		2380
		2381
		2382
		2383	memset(&packet2, 0, sizeof(packet2));
		2384	mavlink_msg_set_roll_pitch_yaw_thrust_encode(system_id, component_id, &msg, &packet1);
		2385	mavlink_msg_set_roll_pitch_yaw_thrust_decode(&msg, &packet2);
		2386	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2387
		2388	memset(&packet2, 0, sizeof(packet2));
		2389	mavlink_msg_set_roll_pitch_yaw_thrust_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust );
		2390	mavlink_msg_set_roll_pitch_yaw_thrust_decode(&msg, &packet2);
		2391	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2392
		2393	memset(&packet2, 0, sizeof(packet2));
		2394	mavlink_msg_set_roll_pitch_yaw_thrust_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust );
		2395	mavlink_msg_set_roll_pitch_yaw_thrust_decode(&msg, &packet2);
		2396	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2397
		2398	memset(&packet2, 0, sizeof(packet2));
		2399	mavlink_msg_to_send_buffer(buffer, &msg);
		2400	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2401	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2402	}
		2403	mavlink_msg_set_roll_pitch_yaw_thrust_decode(last_msg, &packet2);
		2404	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2405
		2406	memset(&packet2, 0, sizeof(packet2));
		2407	mavlink_msg_set_roll_pitch_yaw_thrust_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust );
		2408	mavlink_msg_set_roll_pitch_yaw_thrust_decode(last_msg, &packet2);
		2409	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2410	}
		2411
		2412	static void mavlink_test_set_roll_pitch_yaw_speed_thrust(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2413	{
		2414	mavlink_message_t msg;
		2415	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2416	uint16_t i;
		2417	mavlink_set_roll_pitch_yaw_speed_thrust_t packet_in = {
		2418	5,
		2419	72,
		2420	31.0,
		2421	59.0,
		2422	87.0,
		2423	115.0,
		2424	};
		2425	mavlink_set_roll_pitch_yaw_speed_thrust_t packet1, packet2;
		2426	memset(&packet1, 0, sizeof(packet1));
		2427	packet1.target_system = packet_in.target_system;
		2428	packet1.target_component = packet_in.target_component;
		2429	packet1.roll_speed = packet_in.roll_speed;
		2430	packet1.pitch_speed = packet_in.pitch_speed;
		2431	packet1.yaw_speed = packet_in.yaw_speed;
		2432	packet1.thrust = packet_in.thrust;
		2433
		2434
		2435
		2436	memset(&packet2, 0, sizeof(packet2));
		2437	mavlink_msg_set_roll_pitch_yaw_speed_thrust_encode(system_id, component_id, &msg, &packet1);
		2438	mavlink_msg_set_roll_pitch_yaw_speed_thrust_decode(&msg, &packet2);
		2439	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2440
		2441	memset(&packet2, 0, sizeof(packet2));
		2442	mavlink_msg_set_roll_pitch_yaw_speed_thrust_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.roll_speed , packet1.pitch_speed , packet1.yaw_speed , packet1.thrust );
		2443	mavlink_msg_set_roll_pitch_yaw_speed_thrust_decode(&msg, &packet2);
		2444	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2445
		2446	memset(&packet2, 0, sizeof(packet2));
		2447	mavlink_msg_set_roll_pitch_yaw_speed_thrust_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target_system , packet1.target_component , packet1.roll_speed , packet1.pitch_speed , packet1.yaw_speed , packet1.thrust );
		2448	mavlink_msg_set_roll_pitch_yaw_speed_thrust_decode(&msg, &packet2);
		2449	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2450
		2451	memset(&packet2, 0, sizeof(packet2));
		2452	mavlink_msg_to_send_buffer(buffer, &msg);
		2453	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2454	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2455	}
		2456	mavlink_msg_set_roll_pitch_yaw_speed_thrust_decode(last_msg, &packet2);
		2457	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2458
		2459	memset(&packet2, 0, sizeof(packet2));
		2460	mavlink_msg_set_roll_pitch_yaw_speed_thrust_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.roll_speed , packet1.pitch_speed , packet1.yaw_speed , packet1.thrust );
		2461	mavlink_msg_set_roll_pitch_yaw_speed_thrust_decode(last_msg, &packet2);
		2462	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2463	}
		2464
		2465	static void mavlink_test_roll_pitch_yaw_thrust_setpoint(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2466	{
		2467	mavlink_message_t msg;
		2468	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2469	uint16_t i;
		2470	mavlink_roll_pitch_yaw_thrust_setpoint_t packet_in = {
		2471	93372036854775807ULL,
		2472	73.0,
		2473	101.0,
		2474	129.0,
		2475	157.0,
		2476	};
		2477	mavlink_roll_pitch_yaw_thrust_setpoint_t packet1, packet2;
		2478	memset(&packet1, 0, sizeof(packet1));
		2479	packet1.time_us = packet_in.time_us;
		2480	packet1.roll = packet_in.roll;
		2481	packet1.pitch = packet_in.pitch;
		2482	packet1.yaw = packet_in.yaw;
		2483	packet1.thrust = packet_in.thrust;
		2484
		2485
		2486
		2487	memset(&packet2, 0, sizeof(packet2));
		2488	mavlink_msg_roll_pitch_yaw_thrust_setpoint_encode(system_id, component_id, &msg, &packet1);
		2489	mavlink_msg_roll_pitch_yaw_thrust_setpoint_decode(&msg, &packet2);
		2490	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2491
		2492	memset(&packet2, 0, sizeof(packet2));
		2493	mavlink_msg_roll_pitch_yaw_thrust_setpoint_pack(system_id, component_id, &msg , packet1.time_us , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust );
		2494	mavlink_msg_roll_pitch_yaw_thrust_setpoint_decode(&msg, &packet2);
		2495	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2496
		2497	memset(&packet2, 0, sizeof(packet2));
		2498	mavlink_msg_roll_pitch_yaw_thrust_setpoint_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_us , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust );
		2499	mavlink_msg_roll_pitch_yaw_thrust_setpoint_decode(&msg, &packet2);
		2500	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2501
		2502	memset(&packet2, 0, sizeof(packet2));
		2503	mavlink_msg_to_send_buffer(buffer, &msg);
		2504	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2505	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2506	}
		2507	mavlink_msg_roll_pitch_yaw_thrust_setpoint_decode(last_msg, &packet2);
		2508	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2509
		2510	memset(&packet2, 0, sizeof(packet2));
		2511	mavlink_msg_roll_pitch_yaw_thrust_setpoint_send(MAVLINK_COMM_1 , packet1.time_us , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust );
		2512	mavlink_msg_roll_pitch_yaw_thrust_setpoint_decode(last_msg, &packet2);
		2513	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2514	}
		2515
		2516	static void mavlink_test_roll_pitch_yaw_speed_thrust_setpoint(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2517	{
		2518	mavlink_message_t msg;
		2519	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2520	uint16_t i;
		2521	mavlink_roll_pitch_yaw_speed_thrust_setpoint_t packet_in = {
		2522	93372036854775807ULL,
		2523	73.0,
		2524	101.0,
		2525	129.0,
		2526	157.0,
		2527	};
		2528	mavlink_roll_pitch_yaw_speed_thrust_setpoint_t packet1, packet2;
		2529	memset(&packet1, 0, sizeof(packet1));
		2530	packet1.time_us = packet_in.time_us;
		2531	packet1.roll_speed = packet_in.roll_speed;
		2532	packet1.pitch_speed = packet_in.pitch_speed;
		2533	packet1.yaw_speed = packet_in.yaw_speed;
		2534	packet1.thrust = packet_in.thrust;
		2535
		2536
		2537
		2538	memset(&packet2, 0, sizeof(packet2));
		2539	mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_encode(system_id, component_id, &msg, &packet1);
		2540	mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_decode(&msg, &packet2);
		2541	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2542
		2543	memset(&packet2, 0, sizeof(packet2));
		2544	mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_pack(system_id, component_id, &msg , packet1.time_us , packet1.roll_speed , packet1.pitch_speed , packet1.yaw_speed , packet1.thrust );
		2545	mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_decode(&msg, &packet2);
		2546	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2547
		2548	memset(&packet2, 0, sizeof(packet2));
		2549	mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_us , packet1.roll_speed , packet1.pitch_speed , packet1.yaw_speed , packet1.thrust );
		2550	mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_decode(&msg, &packet2);
		2551	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2552
		2553	memset(&packet2, 0, sizeof(packet2));
		2554	mavlink_msg_to_send_buffer(buffer, &msg);
		2555	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2556	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2557	}
		2558	mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_decode(last_msg, &packet2);
		2559	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2560
		2561	memset(&packet2, 0, sizeof(packet2));
		2562	mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_send(MAVLINK_COMM_1 , packet1.time_us , packet1.roll_speed , packet1.pitch_speed , packet1.yaw_speed , packet1.thrust );
		2563	mavlink_msg_roll_pitch_yaw_speed_thrust_setpoint_decode(last_msg, &packet2);
		2564	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2565	}
		2566
		2567	static void mavlink_test_nav_controller_output(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2568	{
		2569	mavlink_message_t msg;
		2570	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2571	uint16_t i;
		2572	mavlink_nav_controller_output_t packet_in = {
		2573	17.0,
		2574	45.0,
		2575	17651,
		2576	17755,
		2577	17859,
		2578	115.0,
		2579	143.0,
		2580	171.0,
		2581	};
		2582	mavlink_nav_controller_output_t packet1, packet2;
		2583	memset(&packet1, 0, sizeof(packet1));
		2584	packet1.nav_roll = packet_in.nav_roll;
		2585	packet1.nav_pitch = packet_in.nav_pitch;
		2586	packet1.nav_bearing = packet_in.nav_bearing;
		2587	packet1.target_bearing = packet_in.target_bearing;
		2588	packet1.wp_dist = packet_in.wp_dist;
		2589	packet1.alt_error = packet_in.alt_error;
		2590	packet1.aspd_error = packet_in.aspd_error;
		2591	packet1.xtrack_error = packet_in.xtrack_error;
		2592
		2593
		2594
		2595	memset(&packet2, 0, sizeof(packet2));
		2596	mavlink_msg_nav_controller_output_encode(system_id, component_id, &msg, &packet1);
		2597	mavlink_msg_nav_controller_output_decode(&msg, &packet2);
		2598	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2599
		2600	memset(&packet2, 0, sizeof(packet2));
		2601	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 );
		2602	mavlink_msg_nav_controller_output_decode(&msg, &packet2);
		2603	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2604
		2605	memset(&packet2, 0, sizeof(packet2));
		2606	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 );
		2607	mavlink_msg_nav_controller_output_decode(&msg, &packet2);
		2608	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2609
		2610	memset(&packet2, 0, sizeof(packet2));
		2611	mavlink_msg_to_send_buffer(buffer, &msg);
		2612	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2613	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2614	}
		2615	mavlink_msg_nav_controller_output_decode(last_msg, &packet2);
		2616	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2617
		2618	memset(&packet2, 0, sizeof(packet2));
		2619	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 );
		2620	mavlink_msg_nav_controller_output_decode(last_msg, &packet2);
		2621	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2622	}
		2623
		2624	static void mavlink_test_position_target(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2625	{
		2626	mavlink_message_t msg;
		2627	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2628	uint16_t i;
		2629	mavlink_position_target_t packet_in = {
		2630	17.0,
		2631	45.0,
		2632	73.0,
		2633	101.0,
		2634	};
		2635	mavlink_position_target_t packet1, packet2;
		2636	memset(&packet1, 0, sizeof(packet1));
		2637	packet1.x = packet_in.x;
		2638	packet1.y = packet_in.y;
		2639	packet1.z = packet_in.z;
		2640	packet1.yaw = packet_in.yaw;
		2641
		2642
		2643
		2644	memset(&packet2, 0, sizeof(packet2));
		2645	mavlink_msg_position_target_encode(system_id, component_id, &msg, &packet1);
		2646	mavlink_msg_position_target_decode(&msg, &packet2);
		2647	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2648
		2649	memset(&packet2, 0, sizeof(packet2));
		2650	mavlink_msg_position_target_pack(system_id, component_id, &msg , packet1.x , packet1.y , packet1.z , packet1.yaw );
		2651	mavlink_msg_position_target_decode(&msg, &packet2);
		2652	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2653
		2654	memset(&packet2, 0, sizeof(packet2));
		2655	mavlink_msg_position_target_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.x , packet1.y , packet1.z , packet1.yaw );
		2656	mavlink_msg_position_target_decode(&msg, &packet2);
		2657	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2658
		2659	memset(&packet2, 0, sizeof(packet2));
		2660	mavlink_msg_to_send_buffer(buffer, &msg);
		2661	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2662	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2663	}
		2664	mavlink_msg_position_target_decode(last_msg, &packet2);
		2665	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2666
		2667	memset(&packet2, 0, sizeof(packet2));
		2668	mavlink_msg_position_target_send(MAVLINK_COMM_1 , packet1.x , packet1.y , packet1.z , packet1.yaw );
		2669	mavlink_msg_position_target_decode(last_msg, &packet2);
		2670	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2671	}
		2672
		2673	static void mavlink_test_state_correction(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2674	{
		2675	mavlink_message_t msg;
		2676	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2677	uint16_t i;
		2678	mavlink_state_correction_t packet_in = {
		2679	17.0,
		2680	45.0,
		2681	73.0,
		2682	101.0,
		2683	129.0,
		2684	157.0,
		2685	185.0,
		2686	213.0,
		2687	241.0,
		2688	};
		2689	mavlink_state_correction_t packet1, packet2;
		2690	memset(&packet1, 0, sizeof(packet1));
		2691	packet1.xErr = packet_in.xErr;
		2692	packet1.yErr = packet_in.yErr;
		2693	packet1.zErr = packet_in.zErr;
		2694	packet1.rollErr = packet_in.rollErr;
		2695	packet1.pitchErr = packet_in.pitchErr;
		2696	packet1.yawErr = packet_in.yawErr;
		2697	packet1.vxErr = packet_in.vxErr;
		2698	packet1.vyErr = packet_in.vyErr;
		2699	packet1.vzErr = packet_in.vzErr;
		2700
		2701
		2702
		2703	memset(&packet2, 0, sizeof(packet2));
		2704	mavlink_msg_state_correction_encode(system_id, component_id, &msg, &packet1);
		2705	mavlink_msg_state_correction_decode(&msg, &packet2);
		2706	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2707
		2708	memset(&packet2, 0, sizeof(packet2));
		2709	mavlink_msg_state_correction_pack(system_id, component_id, &msg , packet1.xErr , packet1.yErr , packet1.zErr , packet1.rollErr , packet1.pitchErr , packet1.yawErr , packet1.vxErr , packet1.vyErr , packet1.vzErr );
		2710	mavlink_msg_state_correction_decode(&msg, &packet2);
		2711	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2712
		2713	memset(&packet2, 0, sizeof(packet2));
		2714	mavlink_msg_state_correction_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.xErr , packet1.yErr , packet1.zErr , packet1.rollErr , packet1.pitchErr , packet1.yawErr , packet1.vxErr , packet1.vyErr , packet1.vzErr );
		2715	mavlink_msg_state_correction_decode(&msg, &packet2);
		2716	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2717
		2718	memset(&packet2, 0, sizeof(packet2));
		2719	mavlink_msg_to_send_buffer(buffer, &msg);
		2720	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2721	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2722	}
		2723	mavlink_msg_state_correction_decode(last_msg, &packet2);
		2724	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2725
		2726	memset(&packet2, 0, sizeof(packet2));
		2727	mavlink_msg_state_correction_send(MAVLINK_COMM_1 , packet1.xErr , packet1.yErr , packet1.zErr , packet1.rollErr , packet1.pitchErr , packet1.yawErr , packet1.vxErr , packet1.vyErr , packet1.vzErr );
		2728	mavlink_msg_state_correction_decode(last_msg, &packet2);
		2729	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2730	}
		2731
		2732	static void mavlink_test_set_altitude(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2733	{
		2734	mavlink_message_t msg;
		2735	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2736	uint16_t i;
		2737	mavlink_set_altitude_t packet_in = {
		2738	5,
		2739	963497516,
		2740	};
		2741	mavlink_set_altitude_t packet1, packet2;
		2742	memset(&packet1, 0, sizeof(packet1));
		2743	packet1.target = packet_in.target;
		2744	packet1.mode = packet_in.mode;
		2745
		2746
		2747
		2748	memset(&packet2, 0, sizeof(packet2));
		2749	mavlink_msg_set_altitude_encode(system_id, component_id, &msg, &packet1);
		2750	mavlink_msg_set_altitude_decode(&msg, &packet2);
		2751	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2752
		2753	memset(&packet2, 0, sizeof(packet2));
		2754	mavlink_msg_set_altitude_pack(system_id, component_id, &msg , packet1.target , packet1.mode );
		2755	mavlink_msg_set_altitude_decode(&msg, &packet2);
		2756	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2757
		2758	memset(&packet2, 0, sizeof(packet2));
		2759	mavlink_msg_set_altitude_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.mode );
		2760	mavlink_msg_set_altitude_decode(&msg, &packet2);
		2761	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2762
		2763	memset(&packet2, 0, sizeof(packet2));
		2764	mavlink_msg_to_send_buffer(buffer, &msg);
		2765	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2766	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2767	}
		2768	mavlink_msg_set_altitude_decode(last_msg, &packet2);
		2769	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2770
		2771	memset(&packet2, 0, sizeof(packet2));
		2772	mavlink_msg_set_altitude_send(MAVLINK_COMM_1 , packet1.target , packet1.mode );
		2773	mavlink_msg_set_altitude_decode(last_msg, &packet2);
		2774	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2775	}
		2776
		2777	static void mavlink_test_request_data_stream(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2778	{
		2779	mavlink_message_t msg;
		2780	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2781	uint16_t i;
		2782	mavlink_request_data_stream_t packet_in = {
		2783	5,
		2784	72,
		2785	139,
		2786	17391,
		2787	84,
		2788	};
		2789	mavlink_request_data_stream_t packet1, packet2;
		2790	memset(&packet1, 0, sizeof(packet1));
		2791	packet1.target_system = packet_in.target_system;
		2792	packet1.target_component = packet_in.target_component;
		2793	packet1.req_stream_id = packet_in.req_stream_id;
		2794	packet1.req_message_rate = packet_in.req_message_rate;
		2795	packet1.start_stop = packet_in.start_stop;
		2796
		2797
		2798
		2799	memset(&packet2, 0, sizeof(packet2));
		2800	mavlink_msg_request_data_stream_encode(system_id, component_id, &msg, &packet1);
		2801	mavlink_msg_request_data_stream_decode(&msg, &packet2);
		2802	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2803
		2804	memset(&packet2, 0, sizeof(packet2));
		2805	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 );
		2806	mavlink_msg_request_data_stream_decode(&msg, &packet2);
		2807	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2808
		2809	memset(&packet2, 0, sizeof(packet2));
		2810	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 );
		2811	mavlink_msg_request_data_stream_decode(&msg, &packet2);
		2812	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2813
		2814	memset(&packet2, 0, sizeof(packet2));
		2815	mavlink_msg_to_send_buffer(buffer, &msg);
		2816	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2817	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2818	}
		2819	mavlink_msg_request_data_stream_decode(last_msg, &packet2);
		2820	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2821
		2822	memset(&packet2, 0, sizeof(packet2));
		2823	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 );
		2824	mavlink_msg_request_data_stream_decode(last_msg, &packet2);
		2825	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2826	}
		2827
		2828	static void mavlink_test_hil_state(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2829	{
		2830	mavlink_message_t msg;
		2831	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2832	uint16_t i;
		2833	mavlink_hil_state_t packet_in = {
		2834	93372036854775807ULL,
		2835	73.0,
		2836	101.0,
		2837	129.0,
		2838	157.0,
		2839	185.0,
		2840	213.0,
		2841	963499128,
		2842	963499336,
		2843	963499544,
		2844	19523,
		2845	19627,
		2846	19731,
		2847	19835,
		2848	19939,
		2849	20043,
		2850	};
		2851	mavlink_hil_state_t packet1, packet2;
		2852	memset(&packet1, 0, sizeof(packet1));
		2853	packet1.usec = packet_in.usec;
		2854	packet1.roll = packet_in.roll;
		2855	packet1.pitch = packet_in.pitch;
		2856	packet1.yaw = packet_in.yaw;
		2857	packet1.rollspeed = packet_in.rollspeed;
		2858	packet1.pitchspeed = packet_in.pitchspeed;
		2859	packet1.yawspeed = packet_in.yawspeed;
		2860	packet1.lat = packet_in.lat;
		2861	packet1.lon = packet_in.lon;
		2862	packet1.alt = packet_in.alt;
		2863	packet1.vx = packet_in.vx;
		2864	packet1.vy = packet_in.vy;
		2865	packet1.vz = packet_in.vz;
		2866	packet1.xacc = packet_in.xacc;
		2867	packet1.yacc = packet_in.yacc;
		2868	packet1.zacc = packet_in.zacc;
		2869
		2870
		2871
		2872	memset(&packet2, 0, sizeof(packet2));
		2873	mavlink_msg_hil_state_encode(system_id, component_id, &msg, &packet1);
		2874	mavlink_msg_hil_state_decode(&msg, &packet2);
		2875	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2876
		2877	memset(&packet2, 0, sizeof(packet2));
		2878	mavlink_msg_hil_state_pack(system_id, component_id, &msg , packet1.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 );
		2879	mavlink_msg_hil_state_decode(&msg, &packet2);
		2880	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2881
		2882	memset(&packet2, 0, sizeof(packet2));
		2883	mavlink_msg_hil_state_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.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 );
		2884	mavlink_msg_hil_state_decode(&msg, &packet2);
		2885	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2886
		2887	memset(&packet2, 0, sizeof(packet2));
		2888	mavlink_msg_to_send_buffer(buffer, &msg);
		2889	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2890	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2891	}
		2892	mavlink_msg_hil_state_decode(last_msg, &packet2);
		2893	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2894
		2895	memset(&packet2, 0, sizeof(packet2));
		2896	mavlink_msg_hil_state_send(MAVLINK_COMM_1 , packet1.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 );
		2897	mavlink_msg_hil_state_decode(last_msg, &packet2);
		2898	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2899	}
		2900
		2901	static void mavlink_test_hil_controls(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2902	{
		2903	mavlink_message_t msg;
		2904	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2905	uint16_t i;
		2906	mavlink_hil_controls_t packet_in = {
		2907	93372036854775807ULL,
		2908	73.0,
		2909	101.0,
		2910	129.0,
		2911	157.0,
		2912	77,
		2913	144,
		2914	};
		2915	mavlink_hil_controls_t packet1, packet2;
		2916	memset(&packet1, 0, sizeof(packet1));
		2917	packet1.time_us = packet_in.time_us;
		2918	packet1.roll_ailerons = packet_in.roll_ailerons;
		2919	packet1.pitch_elevator = packet_in.pitch_elevator;
		2920	packet1.yaw_rudder = packet_in.yaw_rudder;
		2921	packet1.throttle = packet_in.throttle;
		2922	packet1.mode = packet_in.mode;
		2923	packet1.nav_mode = packet_in.nav_mode;
		2924
		2925
		2926
		2927	memset(&packet2, 0, sizeof(packet2));
		2928	mavlink_msg_hil_controls_encode(system_id, component_id, &msg, &packet1);
		2929	mavlink_msg_hil_controls_decode(&msg, &packet2);
		2930	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2931
		2932	memset(&packet2, 0, sizeof(packet2));
		2933	mavlink_msg_hil_controls_pack(system_id, component_id, &msg , packet1.time_us , packet1.roll_ailerons , packet1.pitch_elevator , packet1.yaw_rudder , packet1.throttle , packet1.mode , packet1.nav_mode );
		2934	mavlink_msg_hil_controls_decode(&msg, &packet2);
		2935	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2936
		2937	memset(&packet2, 0, sizeof(packet2));
		2938	mavlink_msg_hil_controls_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time_us , packet1.roll_ailerons , packet1.pitch_elevator , packet1.yaw_rudder , packet1.throttle , packet1.mode , packet1.nav_mode );
		2939	mavlink_msg_hil_controls_decode(&msg, &packet2);
		2940	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2941
		2942	memset(&packet2, 0, sizeof(packet2));
		2943	mavlink_msg_to_send_buffer(buffer, &msg);
		2944	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		2945	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		2946	}
		2947	mavlink_msg_hil_controls_decode(last_msg, &packet2);
		2948	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2949
		2950	memset(&packet2, 0, sizeof(packet2));
		2951	mavlink_msg_hil_controls_send(MAVLINK_COMM_1 , packet1.time_us , packet1.roll_ailerons , packet1.pitch_elevator , packet1.yaw_rudder , packet1.throttle , packet1.mode , packet1.nav_mode );
		2952	mavlink_msg_hil_controls_decode(last_msg, &packet2);
		2953	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2954	}
		2955
		2956	static void mavlink_test_manual_control(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		2957	{
		2958	mavlink_message_t msg;
		2959	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		2960	uint16_t i;
		2961	mavlink_manual_control_t packet_in = {
		2962	5,
		2963	24.0,
		2964	52.0,
		2965	80.0,
		2966	108.0,
		2967	120,
		2968	187,
		2969	254,
		2970	65,
		2971	};
		2972	mavlink_manual_control_t packet1, packet2;
		2973	memset(&packet1, 0, sizeof(packet1));
		2974	packet1.target = packet_in.target;
		2975	packet1.roll = packet_in.roll;
		2976	packet1.pitch = packet_in.pitch;
		2977	packet1.yaw = packet_in.yaw;
		2978	packet1.thrust = packet_in.thrust;
		2979	packet1.roll_manual = packet_in.roll_manual;
		2980	packet1.pitch_manual = packet_in.pitch_manual;
		2981	packet1.yaw_manual = packet_in.yaw_manual;
		2982	packet1.thrust_manual = packet_in.thrust_manual;
		2983
		2984
		2985
		2986	memset(&packet2, 0, sizeof(packet2));
		2987	mavlink_msg_manual_control_encode(system_id, component_id, &msg, &packet1);
		2988	mavlink_msg_manual_control_decode(&msg, &packet2);
		2989	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2990
		2991	memset(&packet2, 0, sizeof(packet2));
		2992	mavlink_msg_manual_control_pack(system_id, component_id, &msg , packet1.target , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust , packet1.roll_manual , packet1.pitch_manual , packet1.yaw_manual , packet1.thrust_manual );
		2993	mavlink_msg_manual_control_decode(&msg, &packet2);
		2994	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		2995
		2996	memset(&packet2, 0, sizeof(packet2));
		2997	mavlink_msg_manual_control_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.target , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust , packet1.roll_manual , packet1.pitch_manual , packet1.yaw_manual , packet1.thrust_manual );
		2998	mavlink_msg_manual_control_decode(&msg, &packet2);
		2999	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3000
		3001	memset(&packet2, 0, sizeof(packet2));
		3002	mavlink_msg_to_send_buffer(buffer, &msg);
		3003	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3004	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3005	}
		3006	mavlink_msg_manual_control_decode(last_msg, &packet2);
		3007	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3008
		3009	memset(&packet2, 0, sizeof(packet2));
		3010	mavlink_msg_manual_control_send(MAVLINK_COMM_1 , packet1.target , packet1.roll , packet1.pitch , packet1.yaw , packet1.thrust , packet1.roll_manual , packet1.pitch_manual , packet1.yaw_manual , packet1.thrust_manual );
		3011	mavlink_msg_manual_control_decode(last_msg, &packet2);
		3012	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3013	}
		3014
		3015	static void mavlink_test_rc_channels_override(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3016	{
		3017	mavlink_message_t msg;
		3018	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3019	uint16_t i;
		3020	mavlink_rc_channels_override_t packet_in = {
		3021	5,
		3022	72,
		3023	17339,
		3024	17443,
		3025	17547,
		3026	17651,
		3027	17755,
		3028	17859,
		3029	17963,
		3030	18067,
		3031	};
		3032	mavlink_rc_channels_override_t packet1, packet2;
		3033	memset(&packet1, 0, sizeof(packet1));
		3034	packet1.target_system = packet_in.target_system;
		3035	packet1.target_component = packet_in.target_component;
		3036	packet1.chan1_raw = packet_in.chan1_raw;
		3037	packet1.chan2_raw = packet_in.chan2_raw;
		3038	packet1.chan3_raw = packet_in.chan3_raw;
		3039	packet1.chan4_raw = packet_in.chan4_raw;
		3040	packet1.chan5_raw = packet_in.chan5_raw;
		3041	packet1.chan6_raw = packet_in.chan6_raw;
		3042	packet1.chan7_raw = packet_in.chan7_raw;
		3043	packet1.chan8_raw = packet_in.chan8_raw;
		3044
		3045
		3046
		3047	memset(&packet2, 0, sizeof(packet2));
		3048	mavlink_msg_rc_channels_override_encode(system_id, component_id, &msg, &packet1);
		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(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 );
		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_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 );
		3059	mavlink_msg_rc_channels_override_decode(&msg, &packet2);
		3060	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3061
		3062	memset(&packet2, 0, sizeof(packet2));
		3063	mavlink_msg_to_send_buffer(buffer, &msg);
		3064	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3065	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3066	}
		3067	mavlink_msg_rc_channels_override_decode(last_msg, &packet2);
		3068	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3069
		3070	memset(&packet2, 0, sizeof(packet2));
		3071	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 );
		3072	mavlink_msg_rc_channels_override_decode(last_msg, &packet2);
		3073	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3074	}
		3075
		3076	static void mavlink_test_global_position_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3077	{
		3078	mavlink_message_t msg;
		3079	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3080	uint16_t i;
		3081	mavlink_global_position_int_t packet_in = {
		3082	963497464,
		3083	963497672,
		3084	963497880,
		3085	17859,
		3086	17963,
		3087	18067,
		3088	};
		3089	mavlink_global_position_int_t packet1, packet2;
		3090	memset(&packet1, 0, sizeof(packet1));
		3091	packet1.lat = packet_in.lat;
		3092	packet1.lon = packet_in.lon;
		3093	packet1.alt = packet_in.alt;
		3094	packet1.vx = packet_in.vx;
		3095	packet1.vy = packet_in.vy;
		3096	packet1.vz = packet_in.vz;
		3097
		3098
		3099
		3100	memset(&packet2, 0, sizeof(packet2));
		3101	mavlink_msg_global_position_int_encode(system_id, component_id, &msg, &packet1);
		3102	mavlink_msg_global_position_int_decode(&msg, &packet2);
		3103	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3104
		3105	memset(&packet2, 0, sizeof(packet2));
		3106	mavlink_msg_global_position_int_pack(system_id, component_id, &msg , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz );
		3107	mavlink_msg_global_position_int_decode(&msg, &packet2);
		3108	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3109
		3110	memset(&packet2, 0, sizeof(packet2));
		3111	mavlink_msg_global_position_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz );
		3112	mavlink_msg_global_position_int_decode(&msg, &packet2);
		3113	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3114
		3115	memset(&packet2, 0, sizeof(packet2));
		3116	mavlink_msg_to_send_buffer(buffer, &msg);
		3117	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3118	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3119	}
		3120	mavlink_msg_global_position_int_decode(last_msg, &packet2);
		3121	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3122
		3123	memset(&packet2, 0, sizeof(packet2));
		3124	mavlink_msg_global_position_int_send(MAVLINK_COMM_1 , packet1.lat , packet1.lon , packet1.alt , packet1.vx , packet1.vy , packet1.vz );
		3125	mavlink_msg_global_position_int_decode(last_msg, &packet2);
		3126	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3127	}
		3128
		3129	static void mavlink_test_vfr_hud(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3130	{
		3131	mavlink_message_t msg;
		3132	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3133	uint16_t i;
		3134	mavlink_vfr_hud_t packet_in = {
		3135	17.0,
		3136	45.0,
		3137	17651,
		3138	17755,
		3139	101.0,
		3140	129.0,
		3141	};
		3142	mavlink_vfr_hud_t packet1, packet2;
		3143	memset(&packet1, 0, sizeof(packet1));
		3144	packet1.airspeed = packet_in.airspeed;
		3145	packet1.groundspeed = packet_in.groundspeed;
		3146	packet1.heading = packet_in.heading;
		3147	packet1.throttle = packet_in.throttle;
		3148	packet1.alt = packet_in.alt;
		3149	packet1.climb = packet_in.climb;
		3150
		3151
		3152
		3153	memset(&packet2, 0, sizeof(packet2));
		3154	mavlink_msg_vfr_hud_encode(system_id, component_id, &msg, &packet1);
		3155	mavlink_msg_vfr_hud_decode(&msg, &packet2);
		3156	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3157
		3158	memset(&packet2, 0, sizeof(packet2));
		3159	mavlink_msg_vfr_hud_pack(system_id, component_id, &msg , packet1.airspeed , packet1.groundspeed , packet1.heading , packet1.throttle , packet1.alt , packet1.climb );
		3160	mavlink_msg_vfr_hud_decode(&msg, &packet2);
		3161	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3162
		3163	memset(&packet2, 0, sizeof(packet2));
		3164	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 );
		3165	mavlink_msg_vfr_hud_decode(&msg, &packet2);
		3166	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3167
		3168	memset(&packet2, 0, sizeof(packet2));
		3169	mavlink_msg_to_send_buffer(buffer, &msg);
		3170	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3171	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3172	}
		3173	mavlink_msg_vfr_hud_decode(last_msg, &packet2);
		3174	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3175
		3176	memset(&packet2, 0, sizeof(packet2));
		3177	mavlink_msg_vfr_hud_send(MAVLINK_COMM_1 , packet1.airspeed , packet1.groundspeed , packet1.heading , packet1.throttle , packet1.alt , packet1.climb );
		3178	mavlink_msg_vfr_hud_decode(last_msg, &packet2);
		3179	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3180	}
		3181
		3182	static void mavlink_test_command(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3183	{
		3184	mavlink_message_t msg;
		3185	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3186	uint16_t i;
		3187	mavlink_command_t packet_in = {
		3188	5,
		3189	72,
		3190	139,
		3191	206,
		3192	45.0,
		3193	73.0,
		3194	101.0,
		3195	129.0,
		3196	};
		3197	mavlink_command_t packet1, packet2;
		3198	memset(&packet1, 0, sizeof(packet1));
		3199	packet1.target_system = packet_in.target_system;
		3200	packet1.target_component = packet_in.target_component;
		3201	packet1.command = packet_in.command;
		3202	packet1.confirmation = packet_in.confirmation;
		3203	packet1.param1 = packet_in.param1;
		3204	packet1.param2 = packet_in.param2;
		3205	packet1.param3 = packet_in.param3;
		3206	packet1.param4 = packet_in.param4;
		3207
		3208
		3209
		3210	memset(&packet2, 0, sizeof(packet2));
		3211	mavlink_msg_command_encode(system_id, component_id, &msg, &packet1);
		3212	mavlink_msg_command_decode(&msg, &packet2);
		3213	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3214
		3215	memset(&packet2, 0, sizeof(packet2));
		3216	mavlink_msg_command_pack(system_id, component_id, &msg , packet1.target_system , packet1.target_component , packet1.command , packet1.confirmation , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 );
		3217	mavlink_msg_command_decode(&msg, &packet2);
		3218	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3219
		3220	memset(&packet2, 0, sizeof(packet2));
		3221	mavlink_msg_command_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 );
		3222	mavlink_msg_command_decode(&msg, &packet2);
		3223	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3224
		3225	memset(&packet2, 0, sizeof(packet2));
		3226	mavlink_msg_to_send_buffer(buffer, &msg);
		3227	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3228	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3229	}
		3230	mavlink_msg_command_decode(last_msg, &packet2);
		3231	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3232
		3233	memset(&packet2, 0, sizeof(packet2));
		3234	mavlink_msg_command_send(MAVLINK_COMM_1 , packet1.target_system , packet1.target_component , packet1.command , packet1.confirmation , packet1.param1 , packet1.param2 , packet1.param3 , packet1.param4 );
		3235	mavlink_msg_command_decode(last_msg, &packet2);
		3236	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3237	}
		3238
		3239	static void mavlink_test_command_ack(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3240	{
		3241	mavlink_message_t msg;
		3242	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3243	uint16_t i;
		3244	mavlink_command_ack_t packet_in = {
		3245	17.0,
		3246	45.0,
		3247	};
		3248	mavlink_command_ack_t packet1, packet2;
		3249	memset(&packet1, 0, sizeof(packet1));
		3250	packet1.command = packet_in.command;
		3251	packet1.result = packet_in.result;
		3252
		3253
		3254
		3255	memset(&packet2, 0, sizeof(packet2));
		3256	mavlink_msg_command_ack_encode(system_id, component_id, &msg, &packet1);
		3257	mavlink_msg_command_ack_decode(&msg, &packet2);
		3258	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3259
		3260	memset(&packet2, 0, sizeof(packet2));
		3261	mavlink_msg_command_ack_pack(system_id, component_id, &msg , packet1.command , packet1.result );
		3262	mavlink_msg_command_ack_decode(&msg, &packet2);
		3263	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3264
		3265	memset(&packet2, 0, sizeof(packet2));
		3266	mavlink_msg_command_ack_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.command , packet1.result );
		3267	mavlink_msg_command_ack_decode(&msg, &packet2);
		3268	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3269
		3270	memset(&packet2, 0, sizeof(packet2));
		3271	mavlink_msg_to_send_buffer(buffer, &msg);
		3272	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3273	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3274	}
		3275	mavlink_msg_command_ack_decode(last_msg, &packet2);
		3276	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3277
		3278	memset(&packet2, 0, sizeof(packet2));
		3279	mavlink_msg_command_ack_send(MAVLINK_COMM_1 , packet1.command , packet1.result );
		3280	mavlink_msg_command_ack_decode(last_msg, &packet2);
		3281	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3282	}
		3283
		3284	static void mavlink_test_optical_flow(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3285	{
		3286	mavlink_message_t msg;
		3287	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3288	uint16_t i;
		3289	mavlink_optical_flow_t packet_in = {
		3290	93372036854775807ULL,
		3291	29,
		3292	17703,
		3293	17807,
		3294	108,
		3295	115.0,
		3296	};
		3297	mavlink_optical_flow_t packet1, packet2;
		3298	memset(&packet1, 0, sizeof(packet1));
		3299	packet1.time = packet_in.time;
		3300	packet1.sensor_id = packet_in.sensor_id;
		3301	packet1.flow_x = packet_in.flow_x;
		3302	packet1.flow_y = packet_in.flow_y;
		3303	packet1.quality = packet_in.quality;
		3304	packet1.ground_distance = packet_in.ground_distance;
		3305
		3306
		3307
		3308	memset(&packet2, 0, sizeof(packet2));
		3309	mavlink_msg_optical_flow_encode(system_id, component_id, &msg, &packet1);
		3310	mavlink_msg_optical_flow_decode(&msg, &packet2);
		3311	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3312
		3313	memset(&packet2, 0, sizeof(packet2));
		3314	mavlink_msg_optical_flow_pack(system_id, component_id, &msg , packet1.time , packet1.sensor_id , packet1.flow_x , packet1.flow_y , packet1.quality , packet1.ground_distance );
		3315	mavlink_msg_optical_flow_decode(&msg, &packet2);
		3316	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3317
		3318	memset(&packet2, 0, sizeof(packet2));
		3319	mavlink_msg_optical_flow_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time , packet1.sensor_id , packet1.flow_x , packet1.flow_y , packet1.quality , packet1.ground_distance );
		3320	mavlink_msg_optical_flow_decode(&msg, &packet2);
		3321	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3322
		3323	memset(&packet2, 0, sizeof(packet2));
		3324	mavlink_msg_to_send_buffer(buffer, &msg);
		3325	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3326	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3327	}
		3328	mavlink_msg_optical_flow_decode(last_msg, &packet2);
		3329	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3330
		3331	memset(&packet2, 0, sizeof(packet2));
		3332	mavlink_msg_optical_flow_send(MAVLINK_COMM_1 , packet1.time , packet1.sensor_id , packet1.flow_x , packet1.flow_y , packet1.quality , packet1.ground_distance );
		3333	mavlink_msg_optical_flow_decode(last_msg, &packet2);
		3334	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3335	}
		3336
		3337	static void mavlink_test_object_detection_event(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3338	{
		3339	mavlink_message_t msg;
		3340	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3341	uint16_t i;
		3342	mavlink_object_detection_event_t packet_in = {
		3343	963497464,
		3344	17443,
		3345	151,
		3346	"HIJKLMNOPQRSTUVWXYZ",
		3347	22,
		3348	213.0,
		3349	241.0,
		3350	};
		3351	mavlink_object_detection_event_t packet1, packet2;
		3352	memset(&packet1, 0, sizeof(packet1));
		3353	packet1.time = packet_in.time;
		3354	packet1.object_id = packet_in.object_id;
		3355	packet1.type = packet_in.type;
		3356	packet1.quality = packet_in.quality;
		3357	packet1.bearing = packet_in.bearing;
		3358	packet1.distance = packet_in.distance;
		3359
		3360	mav_array_memcpy(packet1.name, packet_in.name, sizeof(char)*20);
		3361
		3362
		3363	memset(&packet2, 0, sizeof(packet2));
		3364	mavlink_msg_object_detection_event_encode(system_id, component_id, &msg, &packet1);
		3365	mavlink_msg_object_detection_event_decode(&msg, &packet2);
		3366	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3367
		3368	memset(&packet2, 0, sizeof(packet2));
		3369	mavlink_msg_object_detection_event_pack(system_id, component_id, &msg , packet1.time , packet1.object_id , packet1.type , packet1.name , packet1.quality , packet1.bearing , packet1.distance );
		3370	mavlink_msg_object_detection_event_decode(&msg, &packet2);
		3371	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3372
		3373	memset(&packet2, 0, sizeof(packet2));
		3374	mavlink_msg_object_detection_event_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.time , packet1.object_id , packet1.type , packet1.name , packet1.quality , packet1.bearing , packet1.distance );
		3375	mavlink_msg_object_detection_event_decode(&msg, &packet2);
		3376	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3377
		3378	memset(&packet2, 0, sizeof(packet2));
		3379	mavlink_msg_to_send_buffer(buffer, &msg);
		3380	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3381	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3382	}
		3383	mavlink_msg_object_detection_event_decode(last_msg, &packet2);
		3384	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3385
		3386	memset(&packet2, 0, sizeof(packet2));
		3387	mavlink_msg_object_detection_event_send(MAVLINK_COMM_1 , packet1.time , packet1.object_id , packet1.type , packet1.name , packet1.quality , packet1.bearing , packet1.distance );
		3388	mavlink_msg_object_detection_event_decode(last_msg, &packet2);
		3389	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3390	}
		3391
		3392	static void mavlink_test_debug_vect(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3393	{
		3394	mavlink_message_t msg;
		3395	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3396	uint16_t i;
		3397	mavlink_debug_vect_t packet_in = {
		3398	"ABCDEFGHI",
		3399	93372036854776437ULL,
		3400	143.0,
		3401	171.0,
		3402	199.0,
		3403	};
		3404	mavlink_debug_vect_t packet1, packet2;
		3405	memset(&packet1, 0, sizeof(packet1));
		3406	packet1.usec = packet_in.usec;
		3407	packet1.x = packet_in.x;
		3408	packet1.y = packet_in.y;
		3409	packet1.z = packet_in.z;
		3410
		3411	mav_array_memcpy(packet1.name, packet_in.name, sizeof(char)*10);
		3412
		3413
		3414	memset(&packet2, 0, sizeof(packet2));
		3415	mavlink_msg_debug_vect_encode(system_id, component_id, &msg, &packet1);
		3416	mavlink_msg_debug_vect_decode(&msg, &packet2);
		3417	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3418
		3419	memset(&packet2, 0, sizeof(packet2));
		3420	mavlink_msg_debug_vect_pack(system_id, component_id, &msg , packet1.name , packet1.usec , packet1.x , packet1.y , packet1.z );
		3421	mavlink_msg_debug_vect_decode(&msg, &packet2);
		3422	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3423
		3424	memset(&packet2, 0, sizeof(packet2));
		3425	mavlink_msg_debug_vect_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.name , packet1.usec , packet1.x , packet1.y , packet1.z );
		3426	mavlink_msg_debug_vect_decode(&msg, &packet2);
		3427	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3428
		3429	memset(&packet2, 0, sizeof(packet2));
		3430	mavlink_msg_to_send_buffer(buffer, &msg);
		3431	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3432	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3433	}
		3434	mavlink_msg_debug_vect_decode(last_msg, &packet2);
		3435	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3436
		3437	memset(&packet2, 0, sizeof(packet2));
		3438	mavlink_msg_debug_vect_send(MAVLINK_COMM_1 , packet1.name , packet1.usec , packet1.x , packet1.y , packet1.z );
		3439	mavlink_msg_debug_vect_decode(last_msg, &packet2);
		3440	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3441	}
		3442
		3443	static void mavlink_test_named_value_float(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3444	{
		3445	mavlink_message_t msg;
		3446	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3447	uint16_t i;
		3448	mavlink_named_value_float_t packet_in = {
		3449	"ABCDEFGHI",
		3450	87.0,
		3451	};
		3452	mavlink_named_value_float_t packet1, packet2;
		3453	memset(&packet1, 0, sizeof(packet1));
		3454	packet1.value = packet_in.value;
		3455
		3456	mav_array_memcpy(packet1.name, packet_in.name, sizeof(char)*10);
		3457
		3458
		3459	memset(&packet2, 0, sizeof(packet2));
		3460	mavlink_msg_named_value_float_encode(system_id, component_id, &msg, &packet1);
		3461	mavlink_msg_named_value_float_decode(&msg, &packet2);
		3462	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3463
		3464	memset(&packet2, 0, sizeof(packet2));
		3465	mavlink_msg_named_value_float_pack(system_id, component_id, &msg , packet1.name , packet1.value );
		3466	mavlink_msg_named_value_float_decode(&msg, &packet2);
		3467	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3468
		3469	memset(&packet2, 0, sizeof(packet2));
		3470	mavlink_msg_named_value_float_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.name , packet1.value );
		3471	mavlink_msg_named_value_float_decode(&msg, &packet2);
		3472	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3473
		3474	memset(&packet2, 0, sizeof(packet2));
		3475	mavlink_msg_to_send_buffer(buffer, &msg);
		3476	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3477	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3478	}
		3479	mavlink_msg_named_value_float_decode(last_msg, &packet2);
		3480	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3481
		3482	memset(&packet2, 0, sizeof(packet2));
		3483	mavlink_msg_named_value_float_send(MAVLINK_COMM_1 , packet1.name , packet1.value );
		3484	mavlink_msg_named_value_float_decode(last_msg, &packet2);
		3485	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3486	}
		3487
		3488	static void mavlink_test_named_value_int(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3489	{
		3490	mavlink_message_t msg;
		3491	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3492	uint16_t i;
		3493	mavlink_named_value_int_t packet_in = {
		3494	"ABCDEFGHI",
		3495	963497984,
		3496	};
		3497	mavlink_named_value_int_t packet1, packet2;
		3498	memset(&packet1, 0, sizeof(packet1));
		3499	packet1.value = packet_in.value;
		3500
		3501	mav_array_memcpy(packet1.name, packet_in.name, sizeof(char)*10);
		3502
		3503
		3504	memset(&packet2, 0, sizeof(packet2));
		3505	mavlink_msg_named_value_int_encode(system_id, component_id, &msg, &packet1);
		3506	mavlink_msg_named_value_int_decode(&msg, &packet2);
		3507	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3508
		3509	memset(&packet2, 0, sizeof(packet2));
		3510	mavlink_msg_named_value_int_pack(system_id, component_id, &msg , packet1.name , packet1.value );
		3511	mavlink_msg_named_value_int_decode(&msg, &packet2);
		3512	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3513
		3514	memset(&packet2, 0, sizeof(packet2));
		3515	mavlink_msg_named_value_int_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.name , packet1.value );
		3516	mavlink_msg_named_value_int_decode(&msg, &packet2);
		3517	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3518
		3519	memset(&packet2, 0, sizeof(packet2));
		3520	mavlink_msg_to_send_buffer(buffer, &msg);
		3521	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3522	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3523	}
		3524	mavlink_msg_named_value_int_decode(last_msg, &packet2);
		3525	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3526
		3527	memset(&packet2, 0, sizeof(packet2));
		3528	mavlink_msg_named_value_int_send(MAVLINK_COMM_1 , packet1.name , packet1.value );
		3529	mavlink_msg_named_value_int_decode(last_msg, &packet2);
		3530	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3531	}
		3532
		3533	static void mavlink_test_statustext(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3534	{
		3535	mavlink_message_t msg;
		3536	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3537	uint16_t i;
		3538	mavlink_statustext_t packet_in = {
		3539	5,
		3540	{ 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 },
		3541	};
		3542	mavlink_statustext_t packet1, packet2;
		3543	memset(&packet1, 0, sizeof(packet1));
		3544	packet1.severity = packet_in.severity;
		3545
		3546	mav_array_memcpy(packet1.text, packet_in.text, sizeof(int8_t)*50);
		3547
		3548
		3549	memset(&packet2, 0, sizeof(packet2));
		3550	mavlink_msg_statustext_encode(system_id, component_id, &msg, &packet1);
		3551	mavlink_msg_statustext_decode(&msg, &packet2);
		3552	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3553
		3554	memset(&packet2, 0, sizeof(packet2));
		3555	mavlink_msg_statustext_pack(system_id, component_id, &msg , packet1.severity , packet1.text );
		3556	mavlink_msg_statustext_decode(&msg, &packet2);
		3557	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3558
		3559	memset(&packet2, 0, sizeof(packet2));
		3560	mavlink_msg_statustext_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.severity , packet1.text );
		3561	mavlink_msg_statustext_decode(&msg, &packet2);
		3562	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3563
		3564	memset(&packet2, 0, sizeof(packet2));
		3565	mavlink_msg_to_send_buffer(buffer, &msg);
		3566	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3567	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3568	}
		3569	mavlink_msg_statustext_decode(last_msg, &packet2);
		3570	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3571
		3572	memset(&packet2, 0, sizeof(packet2));
		3573	mavlink_msg_statustext_send(MAVLINK_COMM_1 , packet1.severity , packet1.text );
		3574	mavlink_msg_statustext_decode(last_msg, &packet2);
		3575	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3576	}
		3577
		3578	static void mavlink_test_debug(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3579	{
		3580	mavlink_message_t msg;
		3581	uint8_t buffer[MAVLINK_MAX_PACKET_LEN];
		3582	uint16_t i;
		3583	mavlink_debug_t packet_in = {
		3584	5,
		3585	24.0,
		3586	};
		3587	mavlink_debug_t packet1, packet2;
		3588	memset(&packet1, 0, sizeof(packet1));
		3589	packet1.ind = packet_in.ind;
		3590	packet1.value = packet_in.value;
		3591
		3592
		3593
		3594	memset(&packet2, 0, sizeof(packet2));
		3595	mavlink_msg_debug_encode(system_id, component_id, &msg, &packet1);
		3596	mavlink_msg_debug_decode(&msg, &packet2);
		3597	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3598
		3599	memset(&packet2, 0, sizeof(packet2));
		3600	mavlink_msg_debug_pack(system_id, component_id, &msg , packet1.ind , packet1.value );
		3601	mavlink_msg_debug_decode(&msg, &packet2);
		3602	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3603
		3604	memset(&packet2, 0, sizeof(packet2));
		3605	mavlink_msg_debug_pack_chan(system_id, component_id, MAVLINK_COMM_0, &msg , packet1.ind , packet1.value );
		3606	mavlink_msg_debug_decode(&msg, &packet2);
		3607	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3608
		3609	memset(&packet2, 0, sizeof(packet2));
		3610	mavlink_msg_to_send_buffer(buffer, &msg);
		3611	for (i=0; i<mavlink_msg_get_send_buffer_length(&msg); i++) {
		3612	comm_send_ch(MAVLINK_COMM_0, buffer[i]);
		3613	}
		3614	mavlink_msg_debug_decode(last_msg, &packet2);
		3615	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3616
		3617	memset(&packet2, 0, sizeof(packet2));
		3618	mavlink_msg_debug_send(MAVLINK_COMM_1 , packet1.ind , packet1.value );
		3619	mavlink_msg_debug_decode(last_msg, &packet2);
		3620	MAVLINK_ASSERT(memcmp(&packet1, &packet2, sizeof(packet1)) == 0);
		3621	}
		3622
		3623	static void mavlink_test_common(uint8_t system_id, uint8_t component_id, mavlink_message_t *last_msg)
		3624	{
		3625	mavlink_test_heartbeat(system_id, component_id, last_msg);
		3626	mavlink_test_boot(system_id, component_id, last_msg);
		3627	mavlink_test_system_time(system_id, component_id, last_msg);
		3628	mavlink_test_ping(system_id, component_id, last_msg);
		3629	mavlink_test_system_time_utc(system_id, component_id, last_msg);
		3630	mavlink_test_change_operator_control(system_id, component_id, last_msg);
		3631	mavlink_test_change_operator_control_ack(system_id, component_id, last_msg);
		3632	mavlink_test_auth_key(system_id, component_id, last_msg);
		3633	mavlink_test_action_ack(system_id, component_id, last_msg);
		3634	mavlink_test_action(system_id, component_id, last_msg);
		3635	mavlink_test_set_mode(system_id, component_id, last_msg);
		3636	mavlink_test_set_nav_mode(system_id, component_id, last_msg);
		3637	mavlink_test_param_request_read(system_id, component_id, last_msg);
		3638	mavlink_test_param_request_list(system_id, component_id, last_msg);
		3639	mavlink_test_param_value(system_id, component_id, last_msg);
		3640	mavlink_test_param_set(system_id, component_id, last_msg);
		3641	mavlink_test_gps_raw_int(system_id, component_id, last_msg);
		3642	mavlink_test_scaled_imu(system_id, component_id, last_msg);
		3643	mavlink_test_gps_status(system_id, component_id, last_msg);
		3644	mavlink_test_raw_imu(system_id, component_id, last_msg);
		3645	mavlink_test_raw_pressure(system_id, component_id, last_msg);
		3646	mavlink_test_scaled_pressure(system_id, component_id, last_msg);
		3647	mavlink_test_attitude(system_id, component_id, last_msg);
		3648	mavlink_test_local_position(system_id, component_id, last_msg);
		3649	mavlink_test_global_position(system_id, component_id, last_msg);
		3650	mavlink_test_gps_raw(system_id, component_id, last_msg);
		3651	mavlink_test_sys_status(system_id, component_id, last_msg);
		3652	mavlink_test_rc_channels_raw(system_id, component_id, last_msg);
		3653	mavlink_test_rc_channels_scaled(system_id, component_id, last_msg);
		3654	mavlink_test_servo_output_raw(system_id, component_id, last_msg);
		3655	mavlink_test_waypoint(system_id, component_id, last_msg);
		3656	mavlink_test_waypoint_request(system_id, component_id, last_msg);
		3657	mavlink_test_waypoint_set_current(system_id, component_id, last_msg);
		3658	mavlink_test_waypoint_current(system_id, component_id, last_msg);
		3659	mavlink_test_waypoint_request_list(system_id, component_id, last_msg);
		3660	mavlink_test_waypoint_count(system_id, component_id, last_msg);
		3661	mavlink_test_waypoint_clear_all(system_id, component_id, last_msg);
		3662	mavlink_test_waypoint_reached(system_id, component_id, last_msg);
		3663	mavlink_test_waypoint_ack(system_id, component_id, last_msg);
		3664	mavlink_test_gps_set_global_origin(system_id, component_id, last_msg);
		3665	mavlink_test_gps_local_origin_set(system_id, component_id, last_msg);
		3666	mavlink_test_local_position_setpoint_set(system_id, component_id, last_msg);
		3667	mavlink_test_local_position_setpoint(system_id, component_id, last_msg);
		3668	mavlink_test_control_status(system_id, component_id, last_msg);
		3669	mavlink_test_safety_set_allowed_area(system_id, component_id, last_msg);
		3670	mavlink_test_safety_allowed_area(system_id, component_id, last_msg);
		3671	mavlink_test_set_roll_pitch_yaw_thrust(system_id, component_id, last_msg);
		3672	mavlink_test_set_roll_pitch_yaw_speed_thrust(system_id, component_id, last_msg);
		3673	mavlink_test_roll_pitch_yaw_thrust_setpoint(system_id, component_id, last_msg);
		3674	mavlink_test_roll_pitch_yaw_speed_thrust_setpoint(system_id, component_id, last_msg);
		3675	mavlink_test_nav_controller_output(system_id, component_id, last_msg);
		3676	mavlink_test_position_target(system_id, component_id, last_msg);
		3677	mavlink_test_state_correction(system_id, component_id, last_msg);
		3678	mavlink_test_set_altitude(system_id, component_id, last_msg);
		3679	mavlink_test_request_data_stream(system_id, component_id, last_msg);
		3680	mavlink_test_hil_state(system_id, component_id, last_msg);
		3681	mavlink_test_hil_controls(system_id, component_id, last_msg);
		3682	mavlink_test_manual_control(system_id, component_id, last_msg);
		3683	mavlink_test_rc_channels_override(system_id, component_id, last_msg);
		3684	mavlink_test_global_position_int(system_id, component_id, last_msg);
		3685	mavlink_test_vfr_hud(system_id, component_id, last_msg);
		3686	mavlink_test_command(system_id, component_id, last_msg);
		3687	mavlink_test_command_ack(system_id, component_id, last_msg);
		3688	mavlink_test_optical_flow(system_id, component_id, last_msg);
		3689	mavlink_test_object_detection_event(system_id, component_id, last_msg);
		3690	mavlink_test_debug_vect(system_id, component_id, last_msg);
		3691	mavlink_test_named_value_float(system_id, component_id, last_msg);
		3692	mavlink_test_named_value_int(system_id, component_id, last_msg);
		3693	mavlink_test_statustext(system_id, component_id, last_msg);
		3694	mavlink_test_debug(system_id, component_id, last_msg);
		3695	}
		3696
		3697	#ifdef __cplusplus
		3698	}
		3699	#endif // __cplusplus
		3700	#endif // COMMON_TESTSUITE_H

Subversion Repositories Projects

(root)/C-OSD/arducam-osd/libraries/GCS_MAVLink/include/mavlink/v0.9/common/testsuite.h - Rev 1702